/
qqmlcomponent.cpp
1424 lines (1176 loc) · 45 KB
/
qqmlcomponent.cpp
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
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/****************************************************************************
**
** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/
**
** This file is part of the QtQml module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** GNU Lesser General Public License Usage
** 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.1, 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.
**
** Other Usage
** Alternatively, this file may be used in accordance with the terms and
** conditions contained in a signed written agreement between you and Nokia.
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qqmlcomponent.h"
#include "qqmlcomponent_p.h"
#include "qqmlcomponentattached_p.h"
#include "qqmlcompiler_p.h"
#include "qqmlcontext_p.h"
#include "qqmlengine_p.h"
#include "qqmlvme_p.h"
#include "qqml.h"
#include "qqmlengine.h"
#include "qqmlbinding_p.h"
#include "qqmlglobal_p.h"
#include "qqmlscript_p.h"
#include <private/qqmlprofilerservice_p.h>
#include <private/qqmlenginedebugservice_p.h>
#include "qqmlincubator.h"
#include "qqmlincubator_p.h"
#include <private/qqmljavascriptexpression_p.h>
#include <private/qv8engine_p.h>
#include <private/qv8include_p.h>
#include <QStack>
#include <QStringList>
#include <QtCore/qdebug.h>
#include <qqmlinfo.h>
QT_BEGIN_NAMESPACE
class QQmlComponentExtension : public QV8Engine::Deletable
{
public:
QQmlComponentExtension(QV8Engine *);
virtual ~QQmlComponentExtension();
v8::Persistent<v8::Function> incubationConstructor;
v8::Persistent<v8::Script> initialProperties;
v8::Persistent<v8::Function> forceCompletion;
};
V8_DEFINE_EXTENSION(QQmlComponentExtension, componentExtension);
/*
Try to do what's necessary for a reasonable display of the type
name, but no more (just enough for the client to do more extensive cleanup).
Should only be called when debugging is enabled.
*/
static inline QString buildTypeNameForDebug(const QMetaObject *metaObject)
{
static const QString qmlMarker(QLatin1String("_QML"));
static const QChar underscore(QLatin1Char('_'));
static const QChar asterisk(QLatin1Char('*'));
QQmlType *type = QQmlMetaType::qmlType(metaObject);
QString typeName = type ? type->qmlTypeName() : QString::fromUtf8(metaObject->className());
if (!type) {
//### optimize further?
int marker = typeName.indexOf(qmlMarker);
if (marker != -1 && marker < typeName.count() - 1) {
if (typeName[marker + 1] == underscore) {
const QString className = typeName.left(marker) + asterisk;
type = QQmlMetaType::qmlType(QMetaType::type(className.toUtf8()));
if (type)
typeName = type->qmlTypeName();
}
}
}
return typeName;
}
/*!
\class QQmlComponent
\since 4.7
\brief The QQmlComponent class encapsulates a QML component definition.
\mainclass
Components are reusable, encapsulated QML elements with well-defined interfaces.
They are often defined in \l {qdeclarativedocuments.html}{Component Files}.
A QQmlComponent instance can be created from a QML file.
For example, if there is a \c main.qml file like this:
\qml
import QtQuick 2.0
Item {
width: 200
height: 200
}
\endqml
The following code loads this QML file as a component, creates an instance of
this component using create(), and then queries the \l Item's \l {Item::}{width}
value:
\code
QQmlEngine *engine = new QQmlEngine;
QQmlComponent component(engine, QUrl::fromLocalFile("main.qml"));
QObject *myObject = component.create();
QQuickItem *item = qobject_cast<QQuickItem*>(myObject);
int width = item->width(); // width = 200
\endcode
\section2 Network Components
If the URL passed to QQmlComponent is a network resource, or if the QML document references a
network resource, the QQmlComponent has to fetch the network data before it is able to create
objects. In this case, the QQmlComponent will have a \l {QQmlComponent::Loading}{Loading}
\l {QQmlComponent::status()}{status}. An application will have to wait until the component
is \l {QQmlComponent::Ready}{Ready} before calling \l {QQmlComponent::create()}.
The following example shows how to load a QML file from a network resource. After creating
the QQmlComponent, it tests whether the component is loading. If it is, it connects to the
QQmlComponent::statusChanged() signal and otherwise calls the \c {continueLoading()} method
directly. Note that QQmlComponent::isLoading() may be false for a network component if the
component has been cached and is ready immediately.
\code
MyApplication::MyApplication()
{
// ...
component = new QQmlComponent(engine, QUrl("http://www.example.com/main.qml"));
if (component->isLoading())
QObject::connect(component, SIGNAL(statusChanged(QQmlComponent::Status)),
this, SLOT(continueLoading()));
else
continueLoading();
}
void MyApplication::continueLoading()
{
if (component->isError()) {
qWarning() << component->errors();
} else {
QObject *myObject = component->create();
}
}
\endcode
\sa {Using QML Bindings in C++ Applications}, {Integrating QML Code with Existing Qt UI Code}
*/
/*!
\qmlclass Component QQmlComponent
\ingroup qml-utility-elements
\since 4.7
\brief The Component element encapsulates a QML component definition.
Components are reusable, encapsulated QML elements with well-defined interfaces.
Components are often defined by \l {qdeclarativedocuments.html}{component files} -
that is, \c .qml files. The \e Component element essentially allows QML components
to be defined inline, within a \l {QML Document}{QML document}, rather than as a separate QML file.
This may be useful for reusing a small component within a QML file, or for defining
a component that logically belongs with other QML components within a file.
For example, here is a component that is used by multiple \l Loader objects.
It contains a single item, a \l Rectangle:
\snippet doc/src/snippets/qml/component.qml 0
Notice that while a \l Rectangle by itself would be automatically
rendered and displayed, this is not the case for the above rectangle
because it is defined inside a \c Component. The component encapsulates the
QML elements within, as if they were defined in a separate QML
file, and is not loaded until requested (in this case, by the
two \l Loader objects).
Defining a \c Component is similar to defining a \l {QML Document}{QML document}.
A QML document has a single top-level item that defines the behaviors and
properties of that component, and cannot define properties or behaviors outside
of that top-level item. In the same way, a \c Component definition contains a single
top level item (which in the above example is a \l Rectangle) and cannot define any
data outside of this item, with the exception of an \e id (which in the above example
is \e redSquare).
The \c Component element is commonly used to provide graphical components
for views. For example, the ListView::delegate property requires a \c Component
to specify how each list item is to be displayed.
\c Component objects can also be created dynamically using
\l{QML:Qt::createComponent()}{Qt.createComponent()}.
*/
/*!
\qmlattachedsignal Component::onCompleted()
Emitted after component "startup" has completed. This can be used to
execute script code at startup, once the full QML environment has been
established.
The \c {Component::onCompleted} attached property can be applied to
any element. The order of running the \c onCompleted scripts is
undefined.
\qml
Rectangle {
Component.onCompleted: console.log("Completed Running!")
Rectangle {
Component.onCompleted: console.log("Nested Completed Running!")
}
}
\endqml
*/
/*!
\qmlattachedsignal Component::onDestruction()
Emitted as the component begins destruction. This can be used to undo
work done in the onCompleted signal, or other imperative code in your
application.
The \c {Component::onDestruction} attached property can be applied to
any element. However, it applies to the destruction of the component as
a whole, and not the destruction of the specific object. The order of
running the \c onDestruction scripts is undefined.
\qml
Rectangle {
Component.onDestruction: console.log("Destruction Beginning!")
Rectangle {
Component.onDestruction: console.log("Nested Destruction Beginning!")
}
}
\endqml
\sa QtQml
*/
/*!
\enum QQmlComponent::Status
Specifies the loading status of the QQmlComponent.
\value Null This QQmlComponent has no data. Call loadUrl() or setData() to add QML content.
\value Ready This QQmlComponent is ready and create() may be called.
\value Loading This QQmlComponent is loading network data.
\value Error An error has occurred. Call errors() to retrieve a list of \{QQmlError}{errors}.
*/
/*!
\enum QQmlComponent::CompilationMode
Specifies whether the QQmlComponent should load the component immediately, or asynchonously.
\value PreferSynchronous Prefer loading/compiling the component immediately, blocking the thread.
This is not always possible, e.g. remote URLs will always load asynchronously.
\value Asynchronous Load/compile the component in a background thread.
*/
void QQmlComponentPrivate::typeDataReady(QQmlTypeData *)
{
Q_Q(QQmlComponent);
Q_ASSERT(typeData);
fromTypeData(typeData);
typeData = 0;
progress = 1.0;
emit q->statusChanged(q->status());
emit q->progressChanged(progress);
}
void QQmlComponentPrivate::typeDataProgress(QQmlTypeData *, qreal p)
{
Q_Q(QQmlComponent);
progress = p;
emit q->progressChanged(p);
}
void QQmlComponentPrivate::fromTypeData(QQmlTypeData *data)
{
url = data->finalUrl();
QQmlCompiledData *c = data->compiledData();
if (!c) {
Q_ASSERT(data->isError());
state.errors = data->errors();
} else {
cc = c;
}
data->release();
}
void QQmlComponentPrivate::clear()
{
if (typeData) {
typeData->unregisterCallback(this);
typeData->release();
typeData = 0;
}
if (cc) {
cc->release();
cc = 0;
}
}
/*!
\internal
*/
QQmlComponent::QQmlComponent(QObject *parent)
: QObject(*(new QQmlComponentPrivate), parent)
{
}
/*!
Destruct the QQmlComponent.
*/
QQmlComponent::~QQmlComponent()
{
Q_D(QQmlComponent);
if (d->state.completePending) {
qWarning("QQmlComponent: Component destroyed while completion pending");
d->completeCreate();
}
if (d->typeData) {
d->typeData->unregisterCallback(d);
d->typeData->release();
}
if (d->cc)
d->cc->release();
}
/*!
\qmlproperty enumeration Component::status
This property holds the status of component loading. It can be one of:
\list
\li Component.Null - no data is available for the component
\li Component.Ready - the component has been loaded, and can be used to create instances.
\li Component.Loading - the component is currently being loaded
\li Component.Error - an error occurred while loading the component.
Calling errorString() will provide a human-readable description of any errors.
\endlist
*/
/*!
\property QQmlComponent::status
The component's current \l{QQmlComponent::Status} {status}.
*/
QQmlComponent::Status QQmlComponent::status() const
{
Q_D(const QQmlComponent);
if (d->typeData)
return Loading;
else if (!d->state.errors.isEmpty())
return Error;
else if (d->engine && d->cc)
return Ready;
else
return Null;
}
/*!
Returns true if status() == QQmlComponent::Null.
*/
bool QQmlComponent::isNull() const
{
return status() == Null;
}
/*!
Returns true if status() == QQmlComponent::Ready.
*/
bool QQmlComponent::isReady() const
{
return status() == Ready;
}
/*!
Returns true if status() == QQmlComponent::Error.
*/
bool QQmlComponent::isError() const
{
return status() == Error;
}
/*!
Returns true if status() == QQmlComponent::Loading.
*/
bool QQmlComponent::isLoading() const
{
return status() == Loading;
}
/*!
\qmlproperty real Component::progress
The progress of loading the component, from 0.0 (nothing loaded)
to 1.0 (finished).
*/
/*!
\property QQmlComponent::progress
The progress of loading the component, from 0.0 (nothing loaded)
to 1.0 (finished).
*/
qreal QQmlComponent::progress() const
{
Q_D(const QQmlComponent);
return d->progress;
}
/*!
\fn void QQmlComponent::progressChanged(qreal progress)
Emitted whenever the component's loading progress changes. \a progress will be the
current progress between 0.0 (nothing loaded) and 1.0 (finished).
*/
/*!
\fn void QQmlComponent::statusChanged(QQmlComponent::Status status)
Emitted whenever the component's status changes. \a status will be the
new status.
*/
/*!
Create a QQmlComponent with no data and give it the specified
\a engine and \a parent. Set the data with setData().
*/
QQmlComponent::QQmlComponent(QQmlEngine *engine, QObject *parent)
: QObject(*(new QQmlComponentPrivate), parent)
{
Q_D(QQmlComponent);
d->engine = engine;
}
/*!
Create a QQmlComponent from the given \a url and give it the
specified \a parent and \a engine.
Ensure that the URL provided is full and correct, in particular, use
\l QUrl::fromLocalFile() when loading a file from the local filesystem.
\sa loadUrl()
*/
QQmlComponent::QQmlComponent(QQmlEngine *engine, const QUrl &url, QObject *parent)
: QObject(*(new QQmlComponentPrivate), parent)
{
Q_D(QQmlComponent);
d->engine = engine;
d->loadUrl(url);
}
/*!
Create a QQmlComponent from the given \a url and give it the
specified \a parent and \a engine. If \a mode is \l Asynchronous,
the component will be loaded and compiled asynchronously.
Ensure that the URL provided is full and correct, in particular, use
\l QUrl::fromLocalFile() when loading a file from the local filesystem.
\sa loadUrl()
*/QQmlComponent::QQmlComponent(QQmlEngine *engine, const QUrl &url, CompilationMode mode, QObject *parent)
: QObject(*(new QQmlComponentPrivate), parent)
{
Q_D(QQmlComponent);
d->engine = engine;
d->loadUrl(url, mode);
}
/*!
Create a QQmlComponent from the given \a fileName and give it the specified
\a parent and \a engine.
\sa loadUrl()
*/
QQmlComponent::QQmlComponent(QQmlEngine *engine, const QString &fileName,
QObject *parent)
: QObject(*(new QQmlComponentPrivate), parent)
{
Q_D(QQmlComponent);
d->engine = engine;
d->loadUrl(d->engine->baseUrl().resolved(QUrl::fromLocalFile(fileName)));
}
/*!
Create a QQmlComponent from the given \a fileName and give it the specified
\a parent and \a engine. If \a mode is \l Asynchronous,
the component will be loaded and compiled asynchronously.
\sa loadUrl()
*/
QQmlComponent::QQmlComponent(QQmlEngine *engine, const QString &fileName,
CompilationMode mode, QObject *parent)
: QObject(*(new QQmlComponentPrivate), parent)
{
Q_D(QQmlComponent);
d->engine = engine;
d->loadUrl(d->engine->baseUrl().resolved(QUrl::fromLocalFile(fileName)), mode);
}
/*!
\internal
*/
QQmlComponent::QQmlComponent(QQmlEngine *engine, QQmlCompiledData *cc, int start, QObject *parent)
: QObject(*(new QQmlComponentPrivate), parent)
{
Q_D(QQmlComponent);
d->engine = engine;
d->cc = cc;
cc->addref();
d->start = start;
d->url = cc->url;
d->progress = 1.0;
}
/*!
Sets the QQmlComponent to use the given QML \a data. If \a url
is provided, it is used to set the component name and to provide
a base path for items resolved by this component.
*/
void QQmlComponent::setData(const QByteArray &data, const QUrl &url)
{
Q_D(QQmlComponent);
d->clear();
d->url = url;
QQmlTypeData *typeData = QQmlEnginePrivate::get(d->engine)->typeLoader.get(data, url);
if (typeData->isCompleteOrError()) {
d->fromTypeData(typeData);
} else {
d->typeData = typeData;
d->typeData->registerCallback(d);
}
d->progress = 1.0;
emit statusChanged(status());
emit progressChanged(d->progress);
}
/*!
Returns the QQmlContext the component was created in. This is only
valid for components created directly from QML.
*/
QQmlContext *QQmlComponent::creationContext() const
{
Q_D(const QQmlComponent);
if(d->creationContext)
return d->creationContext->asQQmlContext();
return qmlContext(this);
}
/*!
Load the QQmlComponent from the provided \a url.
Ensure that the URL provided is full and correct, in particular, use
\l QUrl::fromLocalFile() when loading a file from the local filesystem.
*/
void QQmlComponent::loadUrl(const QUrl &url)
{
Q_D(QQmlComponent);
d->loadUrl(url);
}
/*!
Load the QQmlComponent from the provided \a url.
If \a mode is \l Asynchronous, the component will be loaded and compiled asynchronously.
Ensure that the URL provided is full and correct, in particular, use
\l QUrl::fromLocalFile() when loading a file from the local filesystem.
*/
void QQmlComponent::loadUrl(const QUrl &url, QQmlComponent::CompilationMode mode)
{
Q_D(QQmlComponent);
d->loadUrl(url, mode);
}
void QQmlComponentPrivate::loadUrl(const QUrl &newUrl, QQmlComponent::CompilationMode mode)
{
Q_Q(QQmlComponent);
clear();
if ((newUrl.isRelative() && !newUrl.isEmpty())
|| newUrl.scheme() == QLatin1String("file")) // Workaround QTBUG-11929
url = engine->baseUrl().resolved(newUrl);
else
url = newUrl;
if (newUrl.isEmpty()) {
QQmlError error;
error.setDescription(q->tr("Invalid empty URL"));
state.errors << error;
return;
}
if (progress != 0.0) {
progress = 0.0;
emit q->progressChanged(progress);
}
QQmlDataLoader::Mode loaderMode = (mode == QQmlComponent::Asynchronous)
? QQmlDataLoader::Asynchronous
: QQmlDataLoader::PreferSynchronous;
QQmlTypeData *data = QQmlEnginePrivate::get(engine)->typeLoader.get(url, loaderMode);
if (data->isCompleteOrError()) {
fromTypeData(data);
progress = 1.0;
} else {
typeData = data;
typeData->registerCallback(this);
progress = data->progress();
}
emit q->statusChanged(q->status());
if (progress != 0.0)
emit q->progressChanged(progress);
}
/*!
Return the list of errors that occurred during the last compile or create
operation. An empty list is returned if isError() is not set.
*/
QList<QQmlError> QQmlComponent::errors() const
{
Q_D(const QQmlComponent);
if (isError())
return d->state.errors;
else
return QList<QQmlError>();
}
/*!
\qmlmethod string Component::errorString()
Returns a human-readable description of any errors.
The string includes the file, location, and description of each error.
If multiple errors are present they are separated by a newline character.
If no errors are present, an empty string is returned.
*/
/*!
\internal
errorString is only meant as a way to get the errors in script
*/
QString QQmlComponent::errorString() const
{
Q_D(const QQmlComponent);
QString ret;
if(!isError())
return ret;
foreach(const QQmlError &e, d->state.errors) {
ret += e.url().toString() + QLatin1Char(':') +
QString::number(e.line()) + QLatin1Char(' ') +
e.description() + QLatin1Char('\n');
}
return ret;
}
/*!
\qmlproperty url Component::url
The component URL. This is the URL that was used to construct the component.
*/
/*!
\property QQmlComponent::url
The component URL. This is the URL passed to either the constructor,
or the loadUrl() or setData() methods.
*/
QUrl QQmlComponent::url() const
{
Q_D(const QQmlComponent);
return d->url;
}
/*!
\internal
*/
QQmlComponent::QQmlComponent(QQmlComponentPrivate &dd, QObject *parent)
: QObject(dd, parent)
{
}
/*!
Create an object instance from this component. Returns 0 if creation
failed. \a context specifies the context within which to create the object
instance.
If \a context is 0 (the default), it will create the instance in the
engine' s \l {QQmlEngine::rootContext()}{root context}.
*/
QObject *QQmlComponent::create(QQmlContext *context)
{
Q_D(QQmlComponent);
if (!context)
context = d->engine->rootContext();
QObject *rv = beginCreate(context);
completeCreate();
return rv;
}
/*!
This method provides more advanced control over component instance creation.
In general, programmers should use QQmlComponent::create() to create a
component.
Create an object instance from this component. Returns 0 if creation
failed. \a publicContext specifies the context within which to create the object
instance.
When QQmlComponent constructs an instance, it occurs in three steps:
\list 1
\li The object hierarchy is created, and constant values are assigned.
\li Property bindings are evaluated for the the first time.
\li If applicable, QQmlParserStatus::componentComplete() is called on objects.
\endlist
QQmlComponent::beginCreate() differs from QQmlComponent::create() in that it
only performs step 1. QQmlComponent::completeCreate() must be called to
complete steps 2 and 3.
This breaking point is sometimes useful when using attached properties to
communicate information to an instantiated component, as it allows their
initial values to be configured before property bindings take effect.
*/
QObject *QQmlComponent::beginCreate(QQmlContext *publicContext)
{
Q_D(QQmlComponent);
Q_ASSERT(publicContext);
QQmlContextData *context = QQmlContextData::get(publicContext);
return d->beginCreate(context);
}
QObject *
QQmlComponentPrivate::beginCreate(QQmlContextData *context)
{
Q_Q(QQmlComponent);
if (!context) {
qWarning("QQmlComponent: Cannot create a component in a null context");
return 0;
}
if (!context->isValid()) {
qWarning("QQmlComponent: Cannot create a component in an invalid context");
return 0;
}
if (context->engine != engine) {
qWarning("QQmlComponent: Must create component in context from the same QQmlEngine");
return 0;
}
if (state.completePending) {
qWarning("QQmlComponent: Cannot create new component instance before completing the previous");
return 0;
}
if (!q->isReady()) {
qWarning("QQmlComponent: Component is not ready");
return 0;
}
QQmlEnginePrivate *enginePriv = QQmlEnginePrivate::get(engine);
if (enginePriv->inProgressCreations == 0) {
// only track root, since further ones might not be properly nested
profiler = new QQmlObjectCreatingProfiler();
}
enginePriv->inProgressCreations++;
state.errors.clear();
state.completePending = true;
enginePriv->referenceScarceResources();
state.vme.init(context, cc, start, creationContext);
QObject *rv = state.vme.execute(&state.errors);
enginePriv->dereferenceScarceResources();
if (rv) {
QQmlData *ddata = QQmlData::get(rv);
Q_ASSERT(ddata);
ddata->indestructible = true;
}
if (enginePriv->isDebugging && rv) {
if (!context->isInternal)
context->asQQmlContextPrivate()->instances.append(rv);
QQmlEngineDebugService::instance()->objectCreated(engine, rv);
if (profiler && profiler->enabled) {
profiler->setTypeName(buildTypeNameForDebug(rv->metaObject()));
QQmlData *data = QQmlData::get(rv);
Q_ASSERT(data);
profiler->setLocation(cc->url, data->lineNumber, data->columnNumber);
}
}
return rv;
}
void QQmlComponentPrivate::beginDeferred(QQmlEnginePrivate *enginePriv,
QObject *object, ConstructionState *state)
{
enginePriv->inProgressCreations++;
state->errors.clear();
state->completePending = true;
state->vme.initDeferred(object);
state->vme.execute(&state->errors);
}
void QQmlComponentPrivate::complete(QQmlEnginePrivate *enginePriv, ConstructionState *state)
{
if (state->completePending) {
state->vme.complete();
state->completePending = false;
enginePriv->inProgressCreations--;
if (0 == enginePriv->inProgressCreations) {
while (enginePriv->erroredBindings) {
enginePriv->warning(enginePriv->erroredBindings->error);
enginePriv->erroredBindings->removeError();
}
}
}
}
/*!
This method provides more advanced control over component instance creation.
In general, programmers should use QQmlComponent::create() to create a
component.
Complete a component creation begin with QQmlComponent::beginCreate().
*/
void QQmlComponent::completeCreate()
{
Q_D(QQmlComponent);
d->completeCreate();
}
void QQmlComponentPrivate::completeCreate()
{
if (state.completePending) {
QQmlEnginePrivate *ep = QQmlEnginePrivate::get(engine);
complete(ep, &state);
delete profiler;
profiler = 0;
}
}
QQmlComponentAttached::QQmlComponentAttached(QObject *parent)
: QObject(parent), prev(0), next(0)
{
}
QQmlComponentAttached::~QQmlComponentAttached()
{
if (prev) *prev = next;
if (next) next->prev = prev;
prev = 0;
next = 0;
}
/*!
\internal
*/
QQmlComponentAttached *QQmlComponent::qmlAttachedProperties(QObject *obj)
{
QQmlComponentAttached *a = new QQmlComponentAttached(obj);
QQmlEngine *engine = qmlEngine(obj);
if (!engine)
return a;
if (QQmlEnginePrivate::get(engine)->activeVME) { // XXX should only be allowed during begin
QQmlEnginePrivate *p = QQmlEnginePrivate::get(engine);
a->add(&p->activeVME->componentAttached);
} else {
QQmlData *d = QQmlData::get(obj);
Q_ASSERT(d);
Q_ASSERT(d->context);
a->add(&d->context->componentAttached);
}
return a;
}
void QQmlComponent::create(QQmlIncubator &i, QQmlContext *context,
QQmlContext *forContext)
{
Q_D(QQmlComponent);
if (!context)
context = d->engine->rootContext();
QQmlContextData *contextData = QQmlContextData::get(context);
QQmlContextData *forContextData = contextData;
if (forContext) forContextData = QQmlContextData::get(forContext);
if (!contextData->isValid()) {
qWarning("QQmlComponent: Cannot create a component in an invalid context");
return;
}
if (contextData->engine != d->engine) {
qWarning("QQmlComponent: Must create component in context from the same QQmlEngine");
return;
}
if (!isReady()) {
qWarning("QQmlComponent: Component is not ready");
return;
}
i.clear();
QQmlIncubatorPrivate *p = i.d;
QQmlEnginePrivate *enginePriv = QQmlEnginePrivate::get(d->engine);
p->component = d->cc; p->component->addref();
p->vme.init(contextData, d->cc, d->start, d->creationContext);
enginePriv->incubate(i, forContextData);
}
class QV8IncubatorResource : public QV8ObjectResource,
public QQmlIncubator
{
V8_RESOURCE_TYPE(IncubatorType)
public:
QV8IncubatorResource(QV8Engine *engine, IncubationMode = Asynchronous);
static v8::Handle<v8::Value> StatusChangedGetter(v8::Local<v8::String>,
const v8::AccessorInfo& info);
static v8::Handle<v8::Value> StatusGetter(v8::Local<v8::String>,
const v8::AccessorInfo& info);
static v8::Handle<v8::Value> ObjectGetter(v8::Local<v8::String>,
const v8::AccessorInfo& info);
static v8::Handle<v8::Value> ForceCompletionGetter(v8::Local<v8::String>,
const v8::AccessorInfo& info);
static v8::Handle<v8::Value> ForceCompletion(const v8::Arguments &args);
static void StatusChangedSetter(v8::Local<v8::String>, v8::Local<v8::Value> value,
const v8::AccessorInfo& info);
void dispose();