Fix lookups of enums in singletons
[qt:qtdeclarative.git] / tests / auto / qml / qqmlecmascript / testtypes.h
1 /****************************************************************************
2 **
3 ** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
4 ** Contact: http://www.qt-project.org/legal
5 **
6 ** This file is part of the test suite of the Qt Toolkit.
7 **
8 ** $QT_BEGIN_LICENSE:LGPL$
9 ** Commercial License Usage
10 ** Licensees holding valid commercial Qt licenses may use this file in
11 ** accordance with the commercial license agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and Digia.  For licensing terms and
14 ** conditions see http://qt.digia.com/licensing.  For further information
15 ** use the contact form at http://qt.digia.com/contact-us.
16 **
17 ** GNU Lesser General Public License Usage
18 ** Alternatively, this file may be used under the terms of the GNU Lesser
19 ** General Public License version 2.1 as published by the Free Software
20 ** Foundation and appearing in the file LICENSE.LGPL included in the
21 ** packaging of this file.  Please review the following information to
22 ** ensure the GNU Lesser General Public License version 2.1 requirements
23 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
24 **
25 ** In addition, as a special exception, Digia gives you certain additional
26 ** rights.  These rights are described in the Digia Qt LGPL Exception
27 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
28 **
29 ** GNU General Public License Usage
30 ** Alternatively, this file may be used under the terms of the GNU
31 ** General Public License version 3.0 as published by the Free Software
32 ** Foundation and appearing in the file LICENSE.GPL included in the
33 ** packaging of this file.  Please review the following information to
34 ** ensure the GNU General Public License version 3.0 requirements will be
35 ** met: http://www.gnu.org/copyleft/gpl.html.
36 **
37 **
38 ** $QT_END_LICENSE$
39 **
40 ****************************************************************************/
41 #ifndef TESTTYPES_H
42 #define TESTTYPES_H
43
44 #include <QtCore/qobject.h>
45 #include <QtQml/qqml.h>
46 #include <QtQml/qqmlexpression.h>
47 #include <QtCore/qpoint.h>
48 #include <QtCore/qsize.h>
49 #include <QtQml/qqmllist.h>
50 #include <QtCore/qrect.h>
51 #include <QtGui/qmatrix.h>
52 #include <QtGui/qcolor.h>
53 #include <QtGui/qvector3d.h>
54 #include <QtGui/QFont>
55 #include <QtGui/QPixmap>
56 #include <QtCore/qdatetime.h>
57 #include <QtCore/qjsonarray.h>
58 #include <QtCore/qjsonobject.h>
59 #include <QtCore/qjsonvalue.h>
60 #include <QtQml/qjsvalue.h>
61 #include <QtQml/qqmlscriptstring.h>
62 #include <QtQml/qqmlcomponent.h>
63
64 #include <private/qqmlengine_p.h>
65 #include <private/qv8engine_p.h>
66 #include <private/qv4qobjectwrapper_p.h>
67
68 class MyQmlAttachedObject : public QObject
69 {
70     Q_OBJECT
71     Q_PROPERTY(int value READ value CONSTANT)
72     Q_PROPERTY(int value2 READ value2 WRITE setValue2 NOTIFY value2Changed)
73 public:
74     MyQmlAttachedObject(QObject *parent) : QObject(parent), m_value2(0) {}
75
76     int value() const { return 19; }
77     int value2() const { return m_value2; }
78     void setValue2(int v) { if (m_value2 == v) return; m_value2 = v; emit value2Changed(); }
79
80     void emitMySignal() { emit mySignal(); }
81
82 signals:
83     void value2Changed();
84     void mySignal();
85
86 private:
87     int m_value2;
88 };
89
90 class MyEnumContainer : public QObject
91 {
92     Q_OBJECT
93     Q_ENUMS(RelatedEnum)
94
95 public:
96     enum RelatedEnum { RelatedInvalid = -1, RelatedValue = 42, MultiplyDefined = 666 };
97 };
98
99 class MyQmlObject : public QObject
100 {
101     Q_OBJECT
102     Q_ENUMS(MyEnum)
103     Q_ENUMS(MyEnum2)
104     Q_ENUMS(MyEnum3)
105     Q_ENUMS(MyEnumContainer::RelatedEnum)
106     Q_PROPERTY(int deleteOnSet READ deleteOnSet WRITE setDeleteOnSet)
107     Q_PROPERTY(bool trueProperty READ trueProperty CONSTANT)
108     Q_PROPERTY(bool falseProperty READ falseProperty CONSTANT)
109     Q_PROPERTY(int value READ value WRITE setValue)
110     Q_PROPERTY(int console READ console CONSTANT)
111     Q_PROPERTY(QString stringProperty READ stringProperty WRITE setStringProperty NOTIFY stringChanged)
112     Q_PROPERTY(QUrl urlProperty READ urlProperty WRITE setUrlProperty NOTIFY urlChanged)
113     Q_PROPERTY(QObject *objectProperty READ objectProperty WRITE setObjectProperty NOTIFY objectChanged)
114     Q_PROPERTY(QQmlListProperty<QObject> objectListProperty READ objectListProperty CONSTANT)
115     Q_PROPERTY(int resettableProperty READ resettableProperty WRITE setResettableProperty RESET resetProperty)
116     Q_PROPERTY(QRegExp regExp READ regExp WRITE setRegExp)
117     Q_PROPERTY(int nonscriptable READ nonscriptable WRITE setNonscriptable SCRIPTABLE false)
118     Q_PROPERTY(int intProperty READ intProperty WRITE setIntProperty NOTIFY intChanged)
119     Q_PROPERTY(QJSValue qjsvalue READ qjsvalue WRITE setQJSValue NOTIFY qjsvalueChanged)
120     Q_PROPERTY(QJSValue qjsvalueWithReset READ qjsvalue WRITE setQJSValue RESET resetQJSValue NOTIFY qjsvalueChanged)
121     Q_PROPERTY(MyEnum enumProperty READ enumProperty WRITE setEnumProperty)
122     Q_PROPERTY(MyEnumContainer::RelatedEnum relatedEnumProperty READ relatedEnumProperty WRITE setRelatedEnumProperty)
123     Q_PROPERTY(MyEnumContainer::RelatedEnum unrelatedEnumProperty READ unrelatedEnumProperty WRITE setUnrelatedEnumProperty)
124     Q_PROPERTY(MyEnum qtEnumProperty READ qtEnumProperty WRITE setQtEnumProperty)
125
126 public:
127     MyQmlObject(): myinvokableObject(0), m_methodCalled(false), m_methodIntCalled(false), m_object(0), m_value(0), m_resetProperty(13), m_intProperty(0), m_buttons(0) {}
128
129     enum MyEnum { EnumValue1 = 0, EnumValue2 = 1 };
130     enum MyEnum2 { EnumValue3 = 2, EnumValue4 = 3, EnumValue5 = -1 };
131     enum MyEnum3 { MultiplyDefined = 333 };
132
133     bool trueProperty() const { return true; }
134     bool falseProperty() const { return false; }
135
136     QString stringProperty() const { return m_string; }
137     void setStringProperty(const QString &s)
138     {
139         if (s == m_string)
140             return;
141         m_string = s;
142         emit stringChanged();
143     }
144
145     QUrl urlProperty() const { return m_url; }
146     void setUrlProperty(const QUrl &url)
147     {
148         if (url == m_url)
149             return;
150         m_url = url;
151         emit urlChanged();
152     }
153
154     QObject *objectProperty() const { return m_object; }
155     void setObjectProperty(QObject *obj) { 
156         if (obj == m_object)
157             return;
158         m_object = obj;
159         emit objectChanged();
160     }
161
162     QQmlListProperty<QObject> objectListProperty() { return QQmlListProperty<QObject>(this, m_objectQList); }
163
164     bool methodCalled() const { return m_methodCalled; }
165     bool methodIntCalled() const { return m_methodIntCalled; }
166
167     QString string() const { return m_string; }
168
169     static MyQmlAttachedObject *qmlAttachedProperties(QObject *o) {
170         return new MyQmlAttachedObject(o);
171     }
172
173     int deleteOnSet() const { return 1; }
174     void setDeleteOnSet(int v) { if(v) delete this; }
175
176     int value() const { return m_value; }
177     void setValue(int v) { m_value = v; }
178
179     int resettableProperty() const { return m_resetProperty; }
180     void setResettableProperty(int v) { m_resetProperty = v; }
181     void resetProperty() { m_resetProperty = 13; }
182
183     QRegExp regExp() { return m_regExp; }
184     void setRegExp(const QRegExp &regExp) { m_regExp = regExp; }
185
186     int console() const { return 11; }
187
188     int nonscriptable() const { return 0; }
189     void setNonscriptable(int) {}
190
191     MyQmlObject *myinvokableObject;
192     Q_INVOKABLE MyQmlObject *returnme() { return this; }
193
194     struct MyType {
195         int value;
196     };
197     struct MyOtherType {
198         int value;
199     };
200     QVariant variant() const { return m_variant; }
201     QJSValue qjsvalue() const { return m_qjsvalue; }
202     void setQJSValue(const QJSValue &value) { m_qjsvalue = value; emit qjsvalueChanged(); }
203     void resetQJSValue() { m_qjsvalue = QJSValue(QLatin1String("Reset!")); emit qjsvalueChanged(); }
204
205     Qt::MouseButtons buttons() const { return m_buttons; }
206
207     int intProperty() const { return m_intProperty; }
208     void setIntProperty(int i) { m_intProperty = i; emit intChanged(); }
209     
210     Q_INVOKABLE MyEnum2 getEnumValue() const { return EnumValue4; }
211
212     MyEnum enumPropertyValue;
213     MyEnum enumProperty() const {
214         return enumPropertyValue;
215     }
216     void setEnumProperty(MyEnum v) {
217         enumPropertyValue = v;
218     }
219
220     MyEnumContainer::RelatedEnum relatedEnumPropertyValue;
221     MyEnumContainer::RelatedEnum relatedEnumProperty() const {
222         return relatedEnumPropertyValue;
223     }
224     void setRelatedEnumProperty(MyEnumContainer::RelatedEnum v) {
225         relatedEnumPropertyValue = v;
226     }
227
228     MyEnumContainer::RelatedEnum unrelatedEnumPropertyValue;
229     MyEnumContainer::RelatedEnum unrelatedEnumProperty() const {
230         return unrelatedEnumPropertyValue;
231     }
232     void setUnrelatedEnumProperty(MyEnumContainer::RelatedEnum v) {
233         unrelatedEnumPropertyValue = v;
234     }
235
236     MyEnum qtEnumPropertyValue;
237     MyEnum qtEnumProperty() const {
238         return qtEnumPropertyValue;
239     }
240     void setQtEnumProperty(MyEnum v) {
241         qtEnumPropertyValue = v;
242     }
243
244 signals:
245     void basicSignal();
246     void argumentSignal(int a, QString b, qreal c, MyEnum2 d, Qt::MouseButtons e);
247     void unnamedArgumentSignal(int a, qreal, QString c);
248     void stringChanged();
249     void urlChanged();
250     void objectChanged();
251     void anotherBasicSignal();
252     void thirdBasicSignal();
253     void signalWithUnknownType(const MyQmlObject::MyType &arg);
254     void signalWithCompletelyUnknownType(const MyQmlObject::MyOtherType &arg);
255     void signalWithVariant(const QVariant &arg);
256     void signalWithQJSValue(const QJSValue &arg);
257     void signalWithGlobalName(int parseInt);
258     void intChanged();
259     void qjsvalueChanged();
260
261 public slots:
262     void deleteMe() { delete this; }
263     void methodNoArgs() { m_methodCalled = true; }
264     void method(int a) { if(a == 163) m_methodIntCalled = true; }
265     void setString(const QString &s) { m_string = s; }
266     void myinvokable(MyQmlObject *o) { myinvokableObject = o; }
267     void variantMethod(const QVariant &v) { m_variant = v; }
268     void qjsvalueMethod(const QJSValue &v) { m_qjsvalue = v; }
269     void v8function(QQmlV4Function*);
270     void registeredFlagMethod(Qt::MouseButtons v) { m_buttons = v; }
271     QString slotWithReturnValue(const QString &arg) { return arg; }
272
273 private:
274     friend class tst_qqmlecmascript;
275     bool m_methodCalled;
276     bool m_methodIntCalled;
277
278     QObject *m_object;
279     QString m_string;
280     QUrl m_url;
281     QList<QObject *> m_objectQList;
282     int m_value;
283     int m_resetProperty;
284     QRegExp m_regExp;
285     QVariant m_variant;
286     QJSValue m_qjsvalue;
287     int m_intProperty;
288     Qt::MouseButtons m_buttons;
289 };
290 Q_DECLARE_METATYPE(QQmlListProperty<MyQmlObject>)
291
292 QML_DECLARE_TYPEINFO(MyQmlObject, QML_HAS_ATTACHED_PROPERTIES)
293
294 class MyInheritedQmlObject : public MyQmlObject
295 {
296     Q_OBJECT
297     Q_PROPERTY(MyInheritedQmlObject *myInheritedQmlObjectProperty READ myInheritedQmlObject WRITE setMyInheritedQmlObject)
298     Q_PROPERTY(MyQmlObject *myQmlObjectProperty READ myQmlObject WRITE setMyQmlObject)
299     Q_PROPERTY(QObject *qobjectProperty READ qobject WRITE setQObject)
300 public:
301     MyInheritedQmlObject() : m_myInheritedQmlObject(0), m_myQmlObject(0), m_qobject(0) {}
302
303     MyInheritedQmlObject *myInheritedQmlObject() const { return m_myInheritedQmlObject; }
304     void setMyInheritedQmlObject(MyInheritedQmlObject * o) { m_myInheritedQmlObject = o; }
305
306     MyQmlObject *myQmlObject() const { return m_myQmlObject; }
307     void setMyQmlObject(MyQmlObject * o) { m_myQmlObject = o; }
308
309     QObject *qobject() const { return m_qobject; }
310     void setQObject(QObject * o) { m_qobject = o; }
311
312     Q_INVOKABLE bool isItYouQObject(QObject *o);
313     Q_INVOKABLE bool isItYouMyQmlObject(MyQmlObject *o);
314     Q_INVOKABLE bool isItYouMyInheritedQmlObject(MyInheritedQmlObject *o);
315 private:
316     MyInheritedQmlObject *m_myInheritedQmlObject;
317     MyQmlObject *m_myQmlObject;
318     QObject *m_qobject;
319 };
320 QML_DECLARE_TYPE(MyInheritedQmlObject)
321
322 class MyQmlContainer : public QObject
323 {
324     Q_OBJECT
325     Q_PROPERTY(QQmlListProperty<MyQmlObject> children READ children CONSTANT)
326 public:
327     MyQmlContainer() {}
328
329     QQmlListProperty<MyQmlObject> children() { return QQmlListProperty<MyQmlObject>(this, m_children); }
330
331 private:
332     QList<MyQmlObject*> m_children;
333 };
334
335
336 class MyExpression : public QQmlExpression
337 {
338     Q_OBJECT
339 public:
340     MyExpression(QQmlContext *ctxt, const QString &expr)
341         : QQmlExpression(ctxt, 0, expr), changed(false)
342     {
343         QObject::connect(this, SIGNAL(valueChanged()), this, SLOT(expressionValueChanged()));
344         setNotifyOnValueChanged(true);
345     }
346
347     bool changed;
348
349 public slots:
350     void expressionValueChanged() {
351         changed = true;
352     }
353 };
354
355
356 class MyDefaultObject1 : public QObject
357 {
358     Q_OBJECT
359     Q_PROPERTY(int horseLegs READ horseLegs CONSTANT)
360     Q_PROPERTY(int antLegs READ antLegs CONSTANT)
361     Q_PROPERTY(int emuLegs READ emuLegs CONSTANT)
362 public:
363     int horseLegs() const { return 4; }
364     int antLegs() const { return 6; }
365     int emuLegs() const { return 2; }
366 };
367
368 class MyDefaultObject3 : public QObject
369 {
370     Q_OBJECT
371     Q_PROPERTY(int antLegs READ antLegs CONSTANT)
372     Q_PROPERTY(int humanLegs READ humanLegs CONSTANT)
373 public:
374     int antLegs() const { return 7; } // Mutant
375     int humanLegs() const { return 2; }
376     int millipedeLegs() const { return 1000; }
377 };
378
379 class MyDeferredObject : public QObject
380 {
381     Q_OBJECT
382     Q_PROPERTY(int value READ value WRITE setValue NOTIFY valueChanged)
383     Q_PROPERTY(QObject *objectProperty READ objectProperty WRITE setObjectProperty)
384     Q_PROPERTY(QObject *objectProperty2 READ objectProperty2 WRITE setObjectProperty2)
385     Q_CLASSINFO("DeferredPropertyNames", "value,objectProperty,objectProperty2")
386
387 public:
388     MyDeferredObject() : m_value(0), m_object(0), m_object2(0) {}
389
390     int value() const { return m_value; }
391     void setValue(int v) { m_value = v; emit valueChanged(); }
392
393     QObject *objectProperty() const { return m_object; }
394     void setObjectProperty(QObject *obj) { m_object = obj; }
395
396     QObject *objectProperty2() const { return m_object2; }
397     void setObjectProperty2(QObject *obj) { m_object2 = obj; }
398
399 signals:
400     void valueChanged();
401
402 private:
403     int m_value;
404     QObject *m_object;
405     QObject *m_object2;
406 };
407
408 class MyVeryDeferredObject : public QObject
409 {
410     Q_OBJECT
411     //For inDestruction test
412     Q_PROPERTY(int value READ value WRITE setValue NOTIFY valueChanged)
413     Q_PROPERTY(QObject *objectProperty READ objectProperty WRITE setObjectProperty)
414     Q_CLASSINFO("DeferredPropertyNames", "objectProperty")
415
416 public:
417     MyVeryDeferredObject() : m_value(0), m_object(0) {}
418     ~MyVeryDeferredObject() {
419         qmlExecuteDeferred(this); //Not a realistic case, see QTBUG-33112 to see how this could happen in practice
420     }
421
422     int value() const { return m_value; }
423     void setValue(int v) { m_value = v; emit valueChanged(); }
424
425     QObject *objectProperty() const { return m_object; }
426     void setObjectProperty(QObject *obj) { m_object = obj; }
427
428 signals:
429     void valueChanged();
430
431 private:
432     int m_value;
433     QObject *m_object;
434 };
435
436 class MyBaseExtendedObject : public QObject
437 {
438 Q_OBJECT
439 Q_PROPERTY(int baseProperty READ baseProperty WRITE setBaseProperty)
440 public:
441     MyBaseExtendedObject() : m_value(0) {}
442
443     int baseProperty() const { return m_value; }
444     void setBaseProperty(int v) { m_value = v; }
445
446 private:
447     int m_value;
448 };
449
450 class MyExtendedObject : public MyBaseExtendedObject
451 {
452 Q_OBJECT
453 Q_PROPERTY(int coreProperty READ coreProperty WRITE setCoreProperty)
454 public:
455     MyExtendedObject() : m_value(0) {}
456
457     int coreProperty() const { return m_value; }
458     void setCoreProperty(int v) { m_value = v; }
459
460 private:
461     int m_value;
462 };
463
464 class MyTypeObject : public QObject
465 {
466     Q_OBJECT
467     Q_ENUMS(MyEnum)
468     Q_ENUMS(MyEnumContainer::RelatedEnum)
469     Q_FLAGS(MyFlags)
470
471     Q_PROPERTY(QString id READ id WRITE setId)
472     Q_PROPERTY(QObject *objectProperty READ objectProperty WRITE setObjectProperty)
473     Q_PROPERTY(QQmlComponent *componentProperty READ componentProperty WRITE setComponentProperty)
474     Q_PROPERTY(MyFlags flagProperty READ flagProperty WRITE setFlagProperty)
475     Q_PROPERTY(MyEnum enumProperty READ enumProperty WRITE setEnumProperty)
476     Q_PROPERTY(MyEnumContainer::RelatedEnum relatedEnumProperty READ relatedEnumProperty WRITE setRelatedEnumProperty)
477     Q_PROPERTY(QString stringProperty READ stringProperty WRITE setStringProperty)
478     Q_PROPERTY(uint uintProperty READ uintProperty WRITE setUintProperty)
479     Q_PROPERTY(int intProperty READ intProperty WRITE setIntProperty)
480     Q_PROPERTY(qreal realProperty READ realProperty WRITE setRealProperty)
481     Q_PROPERTY(double doubleProperty READ doubleProperty WRITE setDoubleProperty)
482     Q_PROPERTY(float floatProperty READ floatProperty WRITE setFloatProperty)
483     Q_PROPERTY(QColor colorProperty READ colorProperty WRITE setColorProperty)
484     Q_PROPERTY(QDate dateProperty READ dateProperty WRITE setDateProperty)
485     Q_PROPERTY(QTime timeProperty READ timeProperty WRITE setTimeProperty)
486     Q_PROPERTY(QDateTime dateTimeProperty READ dateTimeProperty WRITE setDateTimeProperty)
487     Q_PROPERTY(QDateTime dateTimeProperty2 READ dateTimeProperty2 WRITE setDateTimeProperty2)
488     Q_PROPERTY(QPoint pointProperty READ pointProperty WRITE setPointProperty)
489     Q_PROPERTY(QPointF pointFProperty READ pointFProperty WRITE setPointFProperty)
490     Q_PROPERTY(QSize sizeProperty READ sizeProperty WRITE setSizeProperty)
491     Q_PROPERTY(QSizeF sizeFProperty READ sizeFProperty WRITE setSizeFProperty)
492     Q_PROPERTY(QRect rectProperty READ rectProperty WRITE setRectProperty NOTIFY rectPropertyChanged)
493     Q_PROPERTY(QRect rectProperty2 READ rectProperty2 WRITE setRectProperty2)
494     Q_PROPERTY(QRectF rectFProperty READ rectFProperty WRITE setRectFProperty)
495     Q_PROPERTY(bool boolProperty READ boolProperty WRITE setBoolProperty)
496     Q_PROPERTY(QVariant variantProperty READ variantProperty WRITE setVariantProperty)
497     Q_PROPERTY(QVector3D vectorProperty READ vectorProperty WRITE setVectorProperty)
498     Q_PROPERTY(QUrl urlProperty READ urlProperty WRITE setUrlProperty)
499
500     Q_PROPERTY(QQmlScriptString scriptProperty READ scriptProperty WRITE setScriptProperty)
501
502 public:
503     MyTypeObject()
504         : objectPropertyValue(0), componentPropertyValue(0) {}
505
506     QString idValue;
507     QString id() const {
508         return idValue;
509     }
510     void setId(const QString &v) {
511         idValue = v;
512     }
513
514     QObject *objectPropertyValue;
515     QObject *objectProperty() const {
516         return objectPropertyValue;
517     }
518     void setObjectProperty(QObject *v) {
519         objectPropertyValue = v;
520     }
521
522     QQmlComponent *componentPropertyValue;
523     QQmlComponent *componentProperty() const {
524         return componentPropertyValue;
525     }
526     void setComponentProperty(QQmlComponent *v) {
527         componentPropertyValue = v;
528     }
529
530     enum MyFlag { FlagVal1 = 0x01, FlagVal2 = 0x02, FlagVal3 = 0x04 };
531     Q_DECLARE_FLAGS(MyFlags, MyFlag)
532     MyFlags flagPropertyValue;
533     MyFlags flagProperty() const {
534         return flagPropertyValue;
535     }
536     void setFlagProperty(MyFlags v) {
537         flagPropertyValue = v;
538     }
539
540     enum MyEnum { EnumVal1, EnumVal2 };
541     MyEnum enumPropertyValue;
542     MyEnum enumProperty() const {
543         return enumPropertyValue;
544     }
545     void setEnumProperty(MyEnum v) {
546         enumPropertyValue = v;
547     }
548
549     MyEnumContainer::RelatedEnum relatedEnumPropertyValue;
550     MyEnumContainer::RelatedEnum relatedEnumProperty() const {
551         return relatedEnumPropertyValue;
552     }
553     void setRelatedEnumProperty(MyEnumContainer::RelatedEnum v) {
554         relatedEnumPropertyValue = v;
555     }
556
557     QString stringPropertyValue;
558     QString stringProperty() const {
559        return stringPropertyValue;
560     }
561     void setStringProperty(const QString &v) {
562         stringPropertyValue = v;
563     }
564
565     uint uintPropertyValue;
566     uint uintProperty() const {
567        return uintPropertyValue;
568     }
569     void setUintProperty(const uint &v) {
570         uintPropertyValue = v;
571     }
572
573     int intPropertyValue;
574     int intProperty() const {
575        return intPropertyValue;
576     }
577     void setIntProperty(const int &v) {
578         intPropertyValue = v;
579     }
580
581     qreal realPropertyValue;
582     qreal realProperty() const {
583        return realPropertyValue;
584     }
585     void setRealProperty(const qreal &v) {
586         realPropertyValue = v;
587     }
588
589     double doublePropertyValue;
590     double doubleProperty() const {
591        return doublePropertyValue;
592     }
593     void setDoubleProperty(const double &v) {
594         doublePropertyValue = v;
595     }
596
597     float floatPropertyValue;
598     float floatProperty() const {
599        return floatPropertyValue;
600     }
601     void setFloatProperty(const float &v) {
602         floatPropertyValue = v;
603     }
604
605     QColor colorPropertyValue;
606     QColor colorProperty() const {
607        return colorPropertyValue;
608     }
609     void setColorProperty(const QColor &v) {
610         colorPropertyValue = v;
611     }
612
613     QDate datePropertyValue;
614     QDate dateProperty() const {
615        return datePropertyValue;
616     }
617     void setDateProperty(const QDate &v) {
618         datePropertyValue = v;
619     }
620
621     QTime timePropertyValue;
622     QTime timeProperty() const {
623        return timePropertyValue;
624     }
625     void setTimeProperty(const QTime &v) {
626         timePropertyValue = v;
627     }
628
629     QDateTime dateTimePropertyValue;
630     QDateTime dateTimeProperty() const {
631        return dateTimePropertyValue;
632     }
633     void setDateTimeProperty(const QDateTime &v) {
634         dateTimePropertyValue = v;
635     }
636
637     QDateTime dateTimePropertyValue2;
638     QDateTime dateTimeProperty2() const {
639        return dateTimePropertyValue2;
640     }
641     void setDateTimeProperty2(const QDateTime &v) {
642         dateTimePropertyValue2 = v;
643     }
644
645     QPoint pointPropertyValue;
646     QPoint pointProperty() const {
647        return pointPropertyValue;
648     }
649     void setPointProperty(const QPoint &v) {
650         pointPropertyValue = v;
651     }
652
653     QPointF pointFPropertyValue;
654     QPointF pointFProperty() const {
655        return pointFPropertyValue;
656     }
657     void setPointFProperty(const QPointF &v) {
658         pointFPropertyValue = v;
659     }
660
661     QSize sizePropertyValue;
662     QSize sizeProperty() const {
663        return sizePropertyValue;
664     }
665     void setSizeProperty(const QSize &v) {
666         sizePropertyValue = v;
667     }
668
669     QSizeF sizeFPropertyValue;
670     QSizeF sizeFProperty() const {
671        return sizeFPropertyValue;
672     }
673     void setSizeFProperty(const QSizeF &v) {
674         sizeFPropertyValue = v;
675     }
676
677     QRect rectPropertyValue;
678     QRect rectProperty() const {
679        return rectPropertyValue;
680     }
681     void setRectProperty(const QRect &v) {
682         rectPropertyValue = v;
683         emit rectPropertyChanged();
684     }
685
686     QRect rectPropertyValue2;
687     QRect rectProperty2() const {
688        return rectPropertyValue2;
689     }
690     void setRectProperty2(const QRect &v) {
691         rectPropertyValue2 = v;
692     }
693
694     QRectF rectFPropertyValue;
695     QRectF rectFProperty() const {
696        return rectFPropertyValue;
697     }
698     void setRectFProperty(const QRectF &v) {
699         rectFPropertyValue = v;
700     }
701
702     bool boolPropertyValue;
703     bool boolProperty() const {
704        return boolPropertyValue;
705     }
706     void setBoolProperty(const bool &v) {
707         boolPropertyValue = v;
708     }
709
710     QVariant variantPropertyValue;
711     QVariant variantProperty() const {
712        return variantPropertyValue;
713     }
714     void setVariantProperty(const QVariant &v) {
715         variantPropertyValue = v;
716     }
717
718     QVector3D vectorPropertyValue;
719     QVector3D vectorProperty() const {
720         return vectorPropertyValue;
721     }
722     void setVectorProperty(const QVector3D &v) {
723         vectorPropertyValue = v;
724     }
725
726     QUrl urlPropertyValue;
727     QUrl urlProperty() const {
728         return urlPropertyValue;
729     }
730     void setUrlProperty(const QUrl &v) {
731         urlPropertyValue = v;
732     }
733
734     QQmlScriptString scriptPropertyValue;
735     QQmlScriptString scriptProperty() const {
736         return scriptPropertyValue;
737     }
738     void setScriptProperty(const QQmlScriptString &v) {
739         scriptPropertyValue = v;
740     }
741
742     void doAction() { emit action(); }
743 signals:
744     void action();
745     void rectPropertyChanged();
746 };
747 Q_DECLARE_OPERATORS_FOR_FLAGS(MyTypeObject::MyFlags)
748
749 class MyDerivedObject : public MyTypeObject
750 {
751     Q_OBJECT
752 public:
753     Q_INVOKABLE bool intProperty() const {
754         return true;
755     }
756 };
757
758 class MyInvokableBaseObject : public QObject
759 {
760     Q_OBJECT
761 public:
762     inline ~MyInvokableBaseObject() = 0;
763
764     Q_INVOKABLE inline void method_inherited(int a);
765     Q_INVOKABLE inline void method_overload();
766 };
767
768 struct NonRegisteredType
769 {
770
771 };
772
773 class MyInvokableObject : public MyInvokableBaseObject
774 {
775     Q_OBJECT
776     Q_ENUMS(TestEnum)
777 public:
778     enum TestEnum { EnumValue1, EnumValue2 };
779     MyInvokableObject() { reset(); }
780
781     int invoked() const { return m_invoked; }
782     bool error() const { return m_invokedError; }
783     const QVariantList &actuals() const { return m_actuals; }
784     void reset() { m_invoked = -1; m_invokedError = false; m_actuals.clear(); }
785
786     Q_INVOKABLE QPointF method_get_QPointF() { return QPointF(99.3, -10.2); }
787     Q_INVOKABLE QPoint method_get_QPoint() { return QPoint(9, 12); }
788
789     Q_INVOKABLE void method_NoArgs() { invoke(0); }
790     Q_INVOKABLE int method_NoArgs_int() { invoke(1); return 6; }
791     Q_INVOKABLE qreal method_NoArgs_real() { invoke(2); return 19.75; }
792     Q_INVOKABLE QPointF method_NoArgs_QPointF() { invoke(3); return QPointF(123, 4.5); }
793     Q_INVOKABLE QObject *method_NoArgs_QObject() { invoke(4); return this; }
794     Q_INVOKABLE MyInvokableObject *method_NoArgs_unknown() { invoke(5); return this; }
795     Q_INVOKABLE QJSValue method_NoArgs_QScriptValue() { invoke(6); return QJSValue("Hello world"); }
796     Q_INVOKABLE QVariant method_NoArgs_QVariant() { invoke(7); return QVariant("QML rocks"); }
797
798     Q_INVOKABLE void method_int(int a) { invoke(8); m_actuals << a; }
799     Q_INVOKABLE void method_intint(int a, int b) { invoke(9); m_actuals << a << b; }
800     Q_INVOKABLE void method_real(qreal a) { invoke(10); m_actuals << a; }
801     Q_INVOKABLE void method_QString(QString a) { invoke(11); m_actuals << a; }
802     Q_INVOKABLE void method_QPointF(QPointF a) { invoke(12); m_actuals << a; }
803     Q_INVOKABLE void method_QObject(QObject *a) { invoke(13); m_actuals << qVariantFromValue(a); }
804     Q_INVOKABLE void method_QScriptValue(QJSValue a) { invoke(14); m_actuals << qVariantFromValue(a); }
805     Q_INVOKABLE void method_intQScriptValue(int a, QJSValue b) { invoke(15); m_actuals << a << qVariantFromValue(b); }
806     
807     Q_INVOKABLE void method_overload(int a) { invoke(16); m_actuals << a; }
808     Q_INVOKABLE void method_overload(int a, int b) { invoke(17); m_actuals << a << b; }
809     Q_INVOKABLE void method_overload(QString a) { invoke(18); m_actuals << a; }
810
811     Q_INVOKABLE void method_with_enum(TestEnum e) { invoke(19); m_actuals << (int)e; }
812
813     Q_INVOKABLE int method_default(int a, int b = 19) { invoke(20); m_actuals << a << b; return b; }
814
815     Q_INVOKABLE void method_QVariant(QVariant a, QVariant b = QVariant()) { invoke(21); m_actuals << a << b; }
816
817     Q_INVOKABLE void method_QJsonObject(const QJsonObject &a) { invoke(22); m_actuals << QVariant::fromValue(a); }
818     Q_INVOKABLE void method_QJsonArray(const QJsonArray &a) { invoke(23); m_actuals << QVariant::fromValue(a); }
819     Q_INVOKABLE void method_QJsonValue(const QJsonValue &a) { invoke(24); m_actuals << QVariant::fromValue(a); }
820
821     Q_INVOKABLE void method_overload(const QJsonObject &a) { invoke(25); m_actuals << QVariant::fromValue(a); }
822     Q_INVOKABLE void method_overload(const QJsonArray &a) { invoke(26); m_actuals << QVariant::fromValue(a); }
823     Q_INVOKABLE void method_overload(const QJsonValue &a) { invoke(27); m_actuals << QVariant::fromValue(a); }
824
825     Q_INVOKABLE void method_unknown(NonRegisteredType) { invoke(28); }
826
827 private:
828     friend class MyInvokableBaseObject;
829     void invoke(int idx) { if (m_invoked != -1) m_invokedError = true; m_invoked = idx;}
830     int m_invoked;
831     bool m_invokedError;
832     QVariantList m_actuals;
833 };
834
835 MyInvokableBaseObject::~MyInvokableBaseObject() {}
836
837 void MyInvokableBaseObject::method_inherited(int a)
838 {
839     static_cast<MyInvokableObject *>(this)->invoke(-3);
840     static_cast<MyInvokableObject *>(this)->m_actuals << a;
841 }
842
843 // This is a hidden overload of the MyInvokableObject::method_overload() method
844 void MyInvokableBaseObject::method_overload()
845 {
846     static_cast<MyInvokableObject *>(this)->invoke(-2);
847 }
848
849 class NumberAssignment : public QObject
850 {
851     Q_OBJECT
852 public:
853     Q_PROPERTY(qreal test1 READ test1 WRITE setTest1)
854     qreal _test1;
855     qreal test1() const { return _test1; }
856     void setTest1(qreal v) { _test1 = v; }
857
858     Q_PROPERTY(qreal test2 READ test2 WRITE setTest2)
859     qreal _test2;
860     qreal test2() const { return _test2; }
861     void setTest2(qreal v) { _test2 = v; }
862
863     Q_PROPERTY(qreal test3 READ test3 WRITE setTest3)
864     qreal _test3;
865     qreal test3() const { return _test3; }
866     void setTest3(qreal v) { _test3 = v; }
867
868     Q_PROPERTY(qreal test4 READ test4 WRITE setTest4)
869     qreal _test4;
870     qreal test4() const { return _test4; }
871     void setTest4(qreal v) { _test4 = v; }
872
873     Q_PROPERTY(int test5 READ test5 WRITE setTest5)
874     int _test5;
875     int test5() const { return _test5; }
876     void setTest5(int v) { _test5 = v; }
877
878     Q_PROPERTY(int test6 READ test6 WRITE setTest6)
879     int _test6;
880     int test6() const { return _test6; }
881     void setTest6(int v) { _test6 = v; }
882
883     Q_PROPERTY(int test7 READ test7 WRITE setTest7)
884     int _test7;
885     int test7() const { return _test7; }
886     void setTest7(int v) { _test7 = v; }
887
888     Q_PROPERTY(int test8 READ test8 WRITE setTest8)
889     int _test8;
890     int test8() const { return _test8; }
891     void setTest8(int v) { _test8 = v; }
892
893     Q_PROPERTY(unsigned int test9 READ test9 WRITE setTest9)
894     unsigned int _test9;
895     unsigned int test9() const { return _test9; }
896     void setTest9(unsigned int v) { _test9 = v; }
897
898     Q_PROPERTY(unsigned int test10 READ test10 WRITE setTest10)
899     unsigned int _test10;
900     unsigned int test10() const { return _test10; }
901     void setTest10(unsigned int v) { _test10 = v; }
902
903     Q_PROPERTY(unsigned int test11 READ test11 WRITE setTest11)
904     unsigned int _test11;
905     unsigned int test11() const { return _test11; }
906     void setTest11(unsigned int v) { _test11 = v; }
907
908     Q_PROPERTY(unsigned int test12 READ test12 WRITE setTest12)
909     unsigned int _test12;
910     unsigned int test12() const { return _test12; }
911     void setTest12(unsigned int v) { _test12 = v; }
912 };
913
914 class DefaultPropertyExtendedObject : public QObject
915 {
916     Q_OBJECT
917     Q_PROPERTY(QObject *firstProperty READ firstProperty WRITE setFirstProperty)
918     Q_PROPERTY(QObject *secondProperty READ secondProperty WRITE setSecondProperty)
919 public:
920     DefaultPropertyExtendedObject(QObject *parent = 0) : QObject(parent), m_firstProperty(0), m_secondProperty(0) {}
921
922     QObject *firstProperty() const { return m_firstProperty; }
923     QObject *secondProperty() const { return m_secondProperty; }
924     void setFirstProperty(QObject *property) { m_firstProperty = property; }
925     void setSecondProperty(QObject *property) { m_secondProperty = property; }
926 private:
927     QObject* m_firstProperty;
928     QObject* m_secondProperty;
929 };
930
931 class OverrideDefaultPropertyObject : public DefaultPropertyExtendedObject
932 {
933     Q_OBJECT
934     Q_CLASSINFO("DefaultProperty", "secondProperty")
935 public:
936     OverrideDefaultPropertyObject() {}
937 };
938
939 class MyRevisionedBaseClassRegistered : public QObject
940 {
941 Q_OBJECT
942     Q_PROPERTY(qreal propA READ propA WRITE setPropA NOTIFY propAChanged)
943     Q_PROPERTY(qreal propB READ propB WRITE setPropB NOTIFY propBChanged REVISION 1)
944
945 public:
946     MyRevisionedBaseClassRegistered() : m_pa(1), m_pb(2) {}
947
948     qreal propA() const { return m_pa; }
949     void setPropA(qreal p) {
950         if (p != m_pa) {
951             m_pa = p;
952             emit propAChanged();
953         }
954     }
955     qreal propB() const { return m_pb; }
956     void setPropB(qreal p) {
957         if (p != m_pb) {
958             m_pb = p;
959             emit propBChanged();
960         }
961     }
962
963     Q_INVOKABLE void methodA() { }
964     Q_INVOKABLE Q_REVISION(1) void methodB() { }
965
966 signals:
967     void propAChanged();
968     void propBChanged();
969
970     void signalA();
971     Q_REVISION(1) void signalB();
972
973 protected:
974     qreal m_pa;
975     qreal m_pb;
976 };
977
978 class MyRevisionedBaseClassUnregistered : public MyRevisionedBaseClassRegistered
979 {
980 Q_OBJECT
981     Q_PROPERTY(qreal propC READ propC WRITE setPropC NOTIFY propCChanged)
982     Q_PROPERTY(qreal propD READ propD WRITE setPropD NOTIFY propDChanged REVISION 1)
983
984 public:
985     MyRevisionedBaseClassUnregistered() : m_pc(1), m_pd(2) {}
986
987     qreal propC() const { return m_pc; }
988     void setPropC(qreal p) {
989         if (p != m_pc) {
990             m_pc = p;
991             emit propCChanged();
992         }
993     }
994     qreal propD() const { return m_pd; }
995     void setPropD(qreal p) {
996         if (p != m_pd) {
997             m_pd = p;
998             emit propDChanged();
999         }
1000     }
1001
1002     Q_INVOKABLE void methodC() { }
1003     Q_INVOKABLE Q_REVISION(1) void methodD() { }
1004
1005 signals:
1006     void propCChanged();
1007     void propDChanged();
1008
1009     void signalC();
1010     Q_REVISION(1) void signalD();
1011
1012 protected:
1013     qreal m_pc;
1014     qreal m_pd;
1015 };
1016
1017 class MyRevisionedClass : public MyRevisionedBaseClassUnregistered
1018 {
1019     Q_OBJECT
1020     Q_PROPERTY(qreal prop1 READ prop1 WRITE setProp1 NOTIFY prop1Changed)
1021     Q_PROPERTY(qreal prop2 READ prop2 WRITE setProp2 NOTIFY prop2Changed REVISION 1)
1022
1023 public:
1024     MyRevisionedClass() : m_p1(0), m_p2(0) {}
1025
1026     qreal prop1() const { return m_p1; }
1027     void setProp1(qreal p) {
1028         if (p != m_p1) {
1029             m_p1 = p;
1030             emit prop1Changed();
1031         }
1032     }
1033     qreal prop2() const { return m_p2; }
1034     void setProp2(qreal p) {
1035         if (p != m_p2) {
1036             m_p2 = p;
1037             emit prop2Changed();
1038         }
1039     }
1040
1041     Q_INVOKABLE void method1() { }
1042     Q_INVOKABLE Q_REVISION(1) void method2() { }
1043
1044 signals:
1045     void prop1Changed();
1046     void prop2Changed();
1047
1048     void signal1();
1049     Q_REVISION(1) void signal2();
1050
1051 protected:
1052     qreal m_p1;
1053     qreal m_p2;
1054 };
1055
1056 class MyRevisionedSubclass : public MyRevisionedClass
1057 {
1058     Q_OBJECT
1059     Q_PROPERTY(qreal prop3 READ prop3 WRITE setProp3 NOTIFY prop3Changed)
1060     Q_PROPERTY(qreal prop4 READ prop4 WRITE setProp4 NOTIFY prop4Changed REVISION 1)
1061
1062 public:
1063     MyRevisionedSubclass() : m_p3(3), m_p4(4) {}
1064
1065     qreal prop3() const { return m_p3; }
1066     void setProp3(qreal p) {
1067         if (p != m_p3) {
1068             m_p3 = p;
1069             emit prop3Changed();
1070         }
1071     }
1072     qreal prop4() const { return m_p4; }
1073     void setProp4(qreal p) {
1074         if (p != m_p4) {
1075             m_p4 = p;
1076             emit prop4Changed();
1077         }
1078     }
1079
1080     Q_INVOKABLE void method3() { }
1081     Q_INVOKABLE Q_REVISION(1) void method4() { }
1082
1083 signals:
1084     void prop3Changed();
1085     void prop4Changed();
1086
1087     void signal3();
1088     Q_REVISION(1) void signal4();
1089
1090 protected:
1091     qreal m_p3;
1092     qreal m_p4;
1093 };
1094
1095 QML_DECLARE_TYPE(MyRevisionedBaseClassRegistered)
1096 QML_DECLARE_TYPE(MyRevisionedBaseClassUnregistered)
1097 QML_DECLARE_TYPE(MyRevisionedClass)
1098 QML_DECLARE_TYPE(MyRevisionedSubclass)
1099 Q_DECLARE_METATYPE(MyQmlObject::MyType)
1100
1101
1102 class ScarceResourceObject : public QObject
1103 {
1104     Q_OBJECT
1105     Q_PROPERTY(QPixmap scarceResource READ scarceResource WRITE setScarceResource NOTIFY scarceResourceChanged)
1106 public:
1107     ScarceResourceObject(QObject *parent = 0) : QObject(parent), m_value(100, 100) { m_value.fill(Qt::blue); }
1108     ~ScarceResourceObject() {}
1109
1110     QPixmap scarceResource() const { return m_value; }
1111     void setScarceResource(QPixmap v) { m_value = v; emit scarceResourceChanged(); }
1112
1113     bool scarceResourceIsDetached() const { return m_value.isDetached(); }
1114
1115     // this particular one returns a new one each time
1116     // this means that every Scarce Resource Copy will
1117     // consume resources (so that we can track disposal
1118     // of v8 handles with circular references).
1119     Q_INVOKABLE QPixmap newScarceResource() const
1120     {
1121         QPixmap retn(800, 600);
1122         retn.fill(QColor(100, 110, 120, 45));
1123         return retn;
1124     }
1125
1126 signals:
1127     void scarceResourceChanged();
1128
1129 private:
1130     QPixmap m_value;
1131 };
1132 QML_DECLARE_TYPE(ScarceResourceObject)
1133
1134 class testQObjectApi : public QObject
1135 {
1136     Q_OBJECT
1137     Q_ENUMS(MyEnum)
1138     Q_PROPERTY (int qobjectTestProperty READ qobjectTestProperty NOTIFY qobjectTestPropertyChanged)
1139     Q_PROPERTY (int qobjectTestWritableProperty READ qobjectTestWritableProperty WRITE setQObjectTestWritableProperty NOTIFY qobjectTestWritablePropertyChanged)
1140     Q_PROPERTY (int qobjectTestWritableFinalProperty READ qobjectTestWritableFinalProperty WRITE setQObjectTestWritableFinalProperty NOTIFY qobjectTestWritableFinalPropertyChanged FINAL)
1141
1142 public:
1143     testQObjectApi(QObject* parent = 0)
1144         : QObject(parent), m_testProperty(0), m_testWritableProperty(0), m_testWritableFinalProperty(0), m_methodCallCount(0), m_trackedObject(0)
1145     {
1146     }
1147
1148     ~testQObjectApi() {}
1149
1150     enum MyEnum { EnumValue1 = 25, EnumValue2 = 42 };
1151     Q_INVOKABLE int qobjectEnumTestMethod(MyEnum val) { return (static_cast<int>(val) + 5); }
1152     Q_INVOKABLE int qobjectTestMethod(int increment = 1) { m_methodCallCount += increment; return m_methodCallCount; }
1153
1154     Q_INVOKABLE void trackObject(QObject *obj) { m_trackedObject = obj; }
1155     Q_INVOKABLE QObject *trackedObject() const { return m_trackedObject; }
1156     Q_INVOKABLE void setTrackedObjectProperty(const QString &propName) const { m_trackedObject->setProperty(qPrintable(propName), QVariant(5)); }
1157     Q_INVOKABLE QVariant trackedObjectProperty(const QString &propName) const { return m_trackedObject->property(qPrintable(propName)); }
1158
1159     Q_INVOKABLE void setSpecificProperty(QObject *obj, const QString & propName, const QVariant & v) const { obj->setProperty(qPrintable(propName), v); }
1160     Q_INVOKABLE void changeQObjectParent(QObject *obj) { obj->setParent(this); }
1161
1162     int qobjectTestProperty() const { return m_testProperty; }
1163     void setQObjectTestProperty(int tp) { m_testProperty = tp; emit qobjectTestPropertyChanged(tp); }
1164
1165     int qobjectTestWritableProperty() const { return m_testWritableProperty; }
1166     void setQObjectTestWritableProperty(int tp) { m_testWritableProperty = tp; emit qobjectTestWritablePropertyChanged(tp); }
1167
1168     int qobjectTestWritableFinalProperty() const { return m_testWritableFinalProperty; }
1169     void setQObjectTestWritableFinalProperty(int tp) { m_testWritableFinalProperty = tp; emit qobjectTestWritableFinalPropertyChanged(); }
1170
1171     Q_INVOKABLE bool trackedObjectHasJsOwnership() {
1172         QObject * object = m_trackedObject;
1173
1174         if (!object)
1175             return false;
1176
1177         QQmlData *ddata = QQmlData::get(object, false);
1178         if (!ddata)
1179             return false;
1180         else
1181             return ddata->indestructible?false:true;
1182     }
1183
1184     Q_INVOKABLE void deleteQObject(QObject *obj) { delete obj; }
1185
1186 signals:
1187     void qobjectTestPropertyChanged(int testProperty);
1188     void qobjectTestWritablePropertyChanged(int testWritableProperty);
1189     void qobjectTestWritableFinalPropertyChanged();
1190
1191 private:
1192     int m_testProperty;
1193     int m_testWritableProperty;
1194     int m_testWritableFinalProperty;
1195     int m_methodCallCount;
1196     QObject *m_trackedObject;
1197 };
1198
1199 class testQObjectApiTwo : public QObject
1200 {
1201     Q_OBJECT
1202     Q_PROPERTY(int twoTestProperty READ twoTestProperty WRITE setTwoTestProperty NOTIFY twoTestPropertyChanged)
1203
1204 public:
1205     testQObjectApiTwo(QObject *parent = 0) : QObject(parent), m_ttp(42) {}
1206     ~testQObjectApiTwo() {}
1207
1208     void setTwoTestProperty(int v) { m_ttp = v; emit twoTestPropertyChanged(); }
1209     int twoTestProperty() const { return m_ttp; }
1210
1211 signals:
1212     void twoTestPropertyChanged();
1213
1214 private:
1215     int m_ttp;
1216 };
1217
1218 class testImportOrderApi : public QObject
1219 {
1220     Q_OBJECT
1221
1222 public:
1223     testImportOrderApi(int value, QObject *parent = 0) : QObject(parent), m_value(value) {}
1224
1225     Q_PROPERTY(int value READ value)
1226
1227     int value() const { return m_value; }
1228
1229 private:
1230     int m_value;
1231 };
1232
1233 class CircularReferenceObject : public QObject
1234 {
1235     Q_OBJECT
1236
1237 public:
1238     CircularReferenceObject(QObject *parent = 0)
1239         : QObject(parent), m_dtorCount(0)
1240     {
1241     }
1242
1243     ~CircularReferenceObject()
1244     {
1245         if (m_dtorCount) *m_dtorCount = *m_dtorCount + 1;
1246     }
1247
1248     Q_INVOKABLE void setDtorCount(int *dtorCount)
1249     {
1250         m_dtorCount = dtorCount;
1251     }
1252
1253     Q_INVOKABLE CircularReferenceObject *generate(QObject *parent = 0)
1254     {
1255         CircularReferenceObject *retn = new CircularReferenceObject(parent);
1256         retn->m_dtorCount = m_dtorCount;
1257         retn->m_engine = m_engine;
1258         return retn;
1259     }
1260
1261     Q_INVOKABLE void addReference(QObject *other)
1262     {
1263         QQmlData *ddata = QQmlData::get(this);
1264         assert(ddata);
1265         QV4::ExecutionEngine *v4 = ddata->jsWrapper.engine();
1266         Q_ASSERT(v4);
1267         QV4::Scope scope(v4);
1268         QV4::Scoped<QV4::QObjectWrapper> thisObject(scope, ddata->jsWrapper.value());
1269         Q_ASSERT(thisObject);
1270
1271         QQmlData *otherDData = QQmlData::get(other);
1272         Q_ASSERT(otherDData);
1273
1274         QV4::ScopedValue v(scope, otherDData->jsWrapper.value());
1275         thisObject->defineDefaultProperty(QStringLiteral("autoTestStrongRef"), v);
1276     }
1277
1278     void setEngine(QQmlEngine* declarativeEngine)
1279     {
1280         m_engine = QQmlEnginePrivate::get(declarativeEngine)->v8engine();
1281     }
1282
1283 private:
1284     int *m_dtorCount;
1285     QV8Engine* m_engine;
1286 };
1287 Q_DECLARE_METATYPE(CircularReferenceObject*)
1288
1289 class MyDynamicCreationDestructionObject : public QObject
1290 {
1291     Q_OBJECT
1292     Q_PROPERTY (int intProperty READ intProperty WRITE setIntProperty NOTIFY intPropertyChanged)
1293
1294 public:
1295     MyDynamicCreationDestructionObject(QObject *parent = 0) : QObject(parent), m_intProperty(0), m_dtorCount(0)
1296     {
1297     }
1298
1299     ~MyDynamicCreationDestructionObject()
1300     {
1301         if (m_dtorCount) {
1302             (*m_dtorCount)++;
1303         }
1304     }
1305
1306     int intProperty() const { return m_intProperty; }
1307     void setIntProperty(int val) { m_intProperty = val; emit intPropertyChanged(); }
1308
1309     Q_INVOKABLE MyDynamicCreationDestructionObject *createNew()
1310     {
1311         // no parent == ownership transfers to JS; same dtor counter.
1312         MyDynamicCreationDestructionObject *retn = new MyDynamicCreationDestructionObject;
1313         retn->setDtorCount(m_dtorCount);
1314         return retn;
1315     }
1316
1317     void setDtorCount(int *dtorCount)
1318     {
1319         m_dtorCount = dtorCount;
1320     }
1321
1322 signals:
1323     void intPropertyChanged();
1324
1325 private:
1326     int m_intProperty;
1327     int *m_dtorCount;
1328 };
1329
1330 class WriteCounter : public QObject
1331 {
1332     Q_OBJECT
1333     Q_PROPERTY(int value READ value WRITE setValue);
1334 public:
1335     WriteCounter() : m_value(0), m_count(0) {}
1336
1337     int value() const { return m_value; }
1338     void setValue(int v) { m_value = v; ++m_count; }
1339
1340     int count() const { return m_count; }
1341
1342 private:
1343     int m_value;
1344     int m_count;
1345 };
1346
1347 class MySequenceConversionObject : public QObject
1348 {
1349     Q_OBJECT
1350
1351     Q_PROPERTY (QList<int> intListProperty READ intListProperty WRITE setIntListProperty NOTIFY intListPropertyChanged)
1352     Q_PROPERTY (QList<int> intListProperty2 READ intListProperty2 WRITE setIntListProperty2 NOTIFY intListProperty2Changed)
1353     Q_PROPERTY (QList<qreal> qrealListProperty READ qrealListProperty WRITE setQrealListProperty NOTIFY qrealListPropertyChanged)
1354     Q_PROPERTY (QList<bool> boolListProperty READ boolListProperty WRITE setBoolListProperty NOTIFY boolListPropertyChanged)
1355     Q_PROPERTY (QList<QString> stringListProperty READ stringListProperty WRITE setStringListProperty NOTIFY stringListPropertyChanged)
1356     Q_PROPERTY (QList<QUrl> urlListProperty READ urlListProperty WRITE setUrlListProperty NOTIFY urlListPropertyChanged)
1357     Q_PROPERTY (QStringList qstringListProperty READ qstringListProperty WRITE setQStringListProperty NOTIFY qstringListPropertyChanged)
1358
1359     Q_PROPERTY (QList<QPoint> pointListProperty READ pointListProperty WRITE setPointListProperty NOTIFY pointListPropertyChanged)
1360     Q_PROPERTY (QList<NonRegisteredType> typeListProperty READ typeListProperty WRITE setTypeListProperty NOTIFY typeListPropertyChanged)
1361     Q_PROPERTY (QList<QVariant> variantListProperty READ variantListProperty WRITE setVariantListProperty NOTIFY variantListPropertyChanged)
1362
1363     Q_PROPERTY (qint32 maxIndex READ maxIndex CONSTANT)
1364     Q_PROPERTY (quint32 tooBigIndex READ tooBigIndex CONSTANT)
1365     Q_PROPERTY (qint32 negativeIndex READ negativeIndex CONSTANT)
1366
1367 public:
1368     MySequenceConversionObject()
1369     {
1370         m_intList << 1 << 2 << 3 << 4;
1371         m_intList2 << 1 << 2 << 3 << 4;
1372         m_qrealList << 1.1 << 2.2 << 3.3 << 4.4;
1373         m_boolList << true << false << true << false;
1374         m_stringList << QLatin1String("first") << QLatin1String("second") << QLatin1String("third") << QLatin1String("fourth");
1375         m_urlList << QUrl("http://www.example1.com") << QUrl("http://www.example2.com") << QUrl("http://www.example3.com");
1376         m_qstringList << QLatin1String("first") << QLatin1String("second") << QLatin1String("third") << QLatin1String("fourth");
1377
1378         m_pointList << QPoint(1, 2) << QPoint(3, 4) << QPoint(5, 6);
1379         m_variantList << QVariant(QLatin1String("one")) << QVariant(true) << QVariant(3);
1380     }
1381
1382     ~MySequenceConversionObject() {}
1383
1384     qint32 maxIndex() const
1385     {
1386         return INT_MAX;
1387     }
1388     quint32 tooBigIndex() const
1389     {
1390         quint32 retn = 7;
1391         retn += INT_MAX;
1392         return retn;
1393     }
1394     qint32 negativeIndex() const
1395     {
1396         return -5;
1397     }
1398
1399     QList<int> intListProperty() const { return m_intList; }
1400     void setIntListProperty(const QList<int> &list) { m_intList = list; emit intListPropertyChanged(); }
1401     QList<int> intListProperty2() const { return m_intList2; }
1402     void setIntListProperty2(const QList<int> &list) { m_intList2 = list; emit intListProperty2Changed(); }
1403     QList<qreal> qrealListProperty() const { return m_qrealList; }
1404     void setQrealListProperty(const QList<qreal> &list) { m_qrealList = list; emit qrealListPropertyChanged(); }
1405     QList<bool> boolListProperty() const { return m_boolList; }
1406     void setBoolListProperty(const QList<bool> &list) { m_boolList = list; emit boolListPropertyChanged(); }
1407     QList<QString> stringListProperty() const { return m_stringList; }
1408     void setStringListProperty(const QList<QString> &list) { m_stringList = list; emit stringListPropertyChanged(); }
1409     QList<QUrl> urlListProperty() const { return m_urlList; }
1410     void setUrlListProperty(const QList<QUrl> &list) { m_urlList = list; emit urlListPropertyChanged(); }
1411     QStringList qstringListProperty() const { return m_qstringList; }
1412     void setQStringListProperty(const QStringList &list) { m_qstringList = list; emit qstringListPropertyChanged(); }
1413     QList<QPoint> pointListProperty() const { return m_pointList; }
1414     void setPointListProperty(const QList<QPoint> &list) { m_pointList = list; emit pointListPropertyChanged(); }
1415     QList<NonRegisteredType> typeListProperty() const { return m_typeList; }
1416     void setTypeListProperty(const QList<NonRegisteredType> &list) { m_typeList = list; emit typeListPropertyChanged(); }
1417     QList<QVariant> variantListProperty() const { return m_variantList; }
1418     void setVariantListProperty(const QList<QVariant> &list) { m_variantList = list; emit variantListPropertyChanged(); }
1419
1420     // now for "copy resource" sequences:
1421     Q_INVOKABLE QList<int> generateIntSequence() const { QList<int> retn; retn << 1 << 2 << 3; return retn; }
1422     Q_INVOKABLE QList<qreal> generateQrealSequence() const { QList<qreal> retn; retn << 1.1 << 2.2 << 3.3; return retn; }
1423     Q_INVOKABLE QList<bool> generateBoolSequence() const { QList<bool> retn; retn << true << false << true; return retn; }
1424     Q_INVOKABLE QList<QString> generateStringSequence() const { QList<QString> retn; retn << "one" << "two" << "three"; return retn; }
1425     Q_INVOKABLE QList<QUrl> generateUrlSequence() const { QList<QUrl> retn; retn << QUrl("http://www.example1.com") << QUrl("http://www.example2.com") << QUrl("http://www.example3.com"); return retn; }
1426     Q_INVOKABLE QStringList generateQStringSequence() const { QStringList retn; retn << "one" << "two" << "three"; return retn; }
1427     Q_INVOKABLE bool parameterEqualsGeneratedIntSequence(const QList<int>& param) const { return (param == generateIntSequence()); }
1428
1429     // "reference resource" underlying qobject deletion test:
1430     Q_INVOKABLE MySequenceConversionObject *generateTestObject() const { return new MySequenceConversionObject; }
1431     Q_INVOKABLE void deleteTestObject(QObject *object) const { delete object; }
1432
1433 signals:
1434     void intListPropertyChanged();
1435     void intListProperty2Changed();
1436     void qrealListPropertyChanged();
1437     void boolListPropertyChanged();
1438     void stringListPropertyChanged();
1439     void urlListPropertyChanged();
1440     void qstringListPropertyChanged();
1441     void pointListPropertyChanged();
1442     void typeListPropertyChanged();
1443     void variantListPropertyChanged();
1444
1445 private:
1446     QList<int> m_intList;
1447     QList<int> m_intList2;
1448     QList<qreal> m_qrealList;
1449     QList<bool> m_boolList;
1450     QList<QString> m_stringList;
1451     QList<QUrl> m_urlList;
1452     QStringList m_qstringList;
1453
1454     QList<QPoint> m_pointList;
1455     QList<NonRegisteredType> m_typeList; // not a supported sequence type
1456     QList<QVariant> m_variantList; // not a supported sequence type, but QVariantList support is hardcoded.
1457 };
1458
1459 class MyDeleteObject : public QObject
1460 {
1461     Q_OBJECT
1462     Q_PROPERTY(QObject *nestedObject READ nestedObject NOTIFY nestedObjectChanged)
1463     Q_PROPERTY(int deleteNestedObject READ deleteNestedObject NOTIFY deleteNestedObjectChanged)
1464     Q_PROPERTY(QObject *object2 READ object2 NOTIFY object2Changed)
1465
1466 public:
1467     MyDeleteObject() : m_nestedObject(new MyQmlObject), m_object1(0), m_object2(0) {}
1468
1469     Q_INVOKABLE QObject *object1() const { return m_object1; }
1470     Q_INVOKABLE QObject *object2() const { return m_object2; }
1471     void setObject1(QObject *object) { m_object1 = object; }
1472     void setObject2(QObject *object) { m_object2 = object; emit object2Changed(); }
1473     QObject *nestedObject() const { return m_nestedObject; }
1474     int deleteNestedObject() { delete m_nestedObject; m_nestedObject = 0; return 1; }
1475
1476 signals:
1477     void nestedObjectChanged();
1478     void deleteNestedObjectChanged();
1479     void object2Changed();
1480
1481 private:
1482     MyQmlObject *m_nestedObject;
1483     QObject *m_object1;
1484     QObject *m_object2;
1485 };
1486
1487 class DateTimeExporter : public QObject
1488 {
1489     Q_OBJECT
1490
1491 public:
1492     DateTimeExporter(const QDateTime &dt) : m_datetime(dt), m_offset(0), m_timespec("UTC")
1493     {
1494         switch (m_datetime.timeSpec()) {
1495         case Qt::LocalTime:
1496             {
1497             QDateTime utc(m_datetime.toUTC());
1498             utc.setTimeSpec(Qt::LocalTime);
1499             m_offset = m_datetime.secsTo(utc) / 60;
1500             m_timespec = "LocalTime";
1501             }
1502             break;
1503         case Qt::OffsetFromUTC:
1504             m_offset = m_datetime.utcOffset() / 60;
1505             m_timespec = QString("%1%2:%3").arg(m_offset < 0 ? '-' : '+')
1506                                            .arg(abs(m_offset) / 60)
1507                                            .arg(abs(m_offset) % 60);
1508         default:
1509             break;
1510         }
1511     }
1512
1513     Q_INVOKABLE QDate getDate() const { return m_datetime.date(); }
1514     Q_INVOKABLE QDateTime getDateTime() const { return m_datetime; }
1515     Q_INVOKABLE int getDateTimeOffset() const { return m_offset; }
1516     Q_INVOKABLE QString getTimeSpec() const { return m_timespec; }
1517
1518 private:
1519     QDateTime m_datetime;
1520     int m_offset;
1521     QString m_timespec;
1522 };
1523
1524 class MyWorkerObject : public QObject
1525 {
1526     Q_OBJECT
1527
1528 public Q_SLOTS:
1529     void doIt();
1530
1531 Q_SIGNALS:
1532     void done(const QString &result);
1533 };
1534
1535 class MyUnregisteredEnumTypeObject : public QObject
1536 {
1537     Q_OBJECT
1538     Q_PROPERTY(MyEnum enumProperty READ enumProperty WRITE setEnumProperty)
1539
1540 public:
1541     MyUnregisteredEnumTypeObject() : QObject(), m_ev(FirstValue) {}
1542     ~MyUnregisteredEnumTypeObject() {}
1543
1544     enum MyEnum {
1545         FirstValue = 1,
1546         SecondValue = 2
1547     };
1548
1549     MyEnum enumProperty() const { return m_ev; }
1550     void setEnumProperty(MyEnum v) { m_ev = v; }
1551
1552 private:
1553     MyEnum m_ev;
1554 };
1555
1556 class FallbackBindingsObject : public QObject
1557 {
1558     Q_OBJECT
1559     Q_PROPERTY (int test READ test NOTIFY testChanged)
1560 public:
1561     FallbackBindingsObject(QObject* parent = 0)
1562         : QObject(parent), m_test(100)
1563     {
1564     }
1565
1566     int test() const { return m_test; }
1567
1568 Q_SIGNALS:
1569     void testChanged();
1570
1571 private:
1572     int m_test;
1573 };
1574
1575 class FallbackBindingsDerived : public FallbackBindingsObject
1576 {
1577     Q_OBJECT
1578     Q_PROPERTY (QString test READ test NOTIFY testChanged)
1579 public:
1580     FallbackBindingsDerived(QObject* parent = 0)
1581         : FallbackBindingsObject(parent), m_test("hello")
1582     {
1583     }
1584
1585     QString test() const { return m_test; }
1586
1587 Q_SIGNALS:
1588     void testChanged();
1589
1590 private:
1591     QString m_test;
1592 };
1593
1594 class FallbackBindingsAttachedObject : public QObject
1595 {
1596     Q_OBJECT
1597     Q_PROPERTY (int test READ test NOTIFY testChanged)
1598 public:
1599     FallbackBindingsAttachedObject(QObject *parent) : QObject(parent), m_test(100) {}
1600
1601     int test() const { return m_test; }
1602
1603 Q_SIGNALS:
1604     void testChanged();
1605
1606 private:
1607     int m_test;
1608 };
1609
1610 class FallbackBindingsAttachedDerived : public FallbackBindingsAttachedObject
1611 {
1612     Q_OBJECT
1613     Q_PROPERTY (QString test READ test NOTIFY testChanged)
1614 public:
1615     FallbackBindingsAttachedDerived(QObject* parent = 0)
1616         : FallbackBindingsAttachedObject(parent), m_test("hello")
1617     {
1618     }
1619
1620     QString test() const { return m_test; }
1621
1622 Q_SIGNALS:
1623     void testChanged();
1624
1625 private:
1626     QString m_test;
1627 };
1628
1629 class FallbackBindingsTypeObject : public QObject
1630 {
1631     Q_OBJECT
1632 public:
1633     FallbackBindingsTypeObject() : QObject() {}
1634
1635     static FallbackBindingsAttachedObject *qmlAttachedProperties(QObject *o) {
1636         return new FallbackBindingsAttachedObject(o);
1637     }
1638 };
1639
1640 class FallbackBindingsTypeDerived : public QObject
1641 {
1642     Q_OBJECT
1643 public:
1644     FallbackBindingsTypeDerived() : QObject() {}
1645
1646     static FallbackBindingsAttachedObject *qmlAttachedProperties(QObject *o) {
1647         return new FallbackBindingsAttachedDerived(o);
1648     }
1649 };
1650
1651 QML_DECLARE_TYPEINFO(FallbackBindingsTypeObject, QML_HAS_ATTACHED_PROPERTIES)
1652 QML_DECLARE_TYPEINFO(FallbackBindingsTypeDerived, QML_HAS_ATTACHED_PROPERTIES)
1653
1654 class SingletonWithEnum : public QObject
1655 {
1656     Q_OBJECT
1657     Q_ENUMS(TestEnum)
1658 public:
1659     enum TestEnum {
1660         TestValue = 42
1661     };
1662 };
1663
1664 void registerTypes();
1665
1666 #endif // TESTTYPES_H
1667