tests/benchmarks/declarative/holistic/testtypes.h

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: http://www.qt-project.org/
   6 **
   7 ** This file is part of the test suite of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** GNU Lesser General Public License Usage
  11 ** This file may be used under the terms of the GNU Lesser General Public
  12 ** License version 2.1 as published by the Free Software Foundation and
  13 ** appearing in the file LICENSE.LGPL included in the packaging of this
  14 ** file. Please review the following information to ensure the GNU Lesser
  15 ** General Public License version 2.1 requirements will be met:
  16 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  17 **
  18 ** In addition, as a special exception, Nokia gives you certain additional
  19 ** rights. These rights are described in the Nokia Qt LGPL Exception
  20 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  21 **
  22 ** GNU General Public License Usage
  23 ** Alternatively, this file may be used under the terms of the GNU General
  24 ** Public License version 3.0 as published by the Free Software Foundation
  25 ** and appearing in the file LICENSE.GPL included in the packaging of this
  26 ** file. Please review the following information to ensure the GNU General
  27 ** Public License version 3.0 requirements will be met:
  28 ** http://www.gnu.org/copyleft/gpl.html.
  29 **
  30 ** Other Usage
  31 ** Alternatively, this file may be used in accordance with the terms and
  32 ** conditions contained in a signed written agreement between you and Nokia.
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41 #ifndef TESTTYPES_H
  42 #define TESTTYPES_H
  43
  44 #include <QtCore/qobject.h>
  45 #include <QtDeclarative/qdeclarative.h>
  46 #include <QtDeclarative/qdeclarativeexpression.h>
  47 #include <QtCore/qpoint.h>
  48 #include <QtCore/qsize.h>
  49 #include <QtDeclarative/qdeclarativelist.h>
  50 #include <QtCore/qrect.h>
  51 #include <QtGui/qmatrix.h>
  52 #include <QtGui/qcolor.h>
  53 #include <QtGui/qpixmap.h>
  54 #include <QtGui/qvector3d.h>
  55 #include <QtCore/qdatetime.h>
  56 #include <QtScript/qjsvalue.h>
  57 #include <QtDeclarative/qdeclarativescriptstring.h>
  58 #include <QtDeclarative/qdeclarativecomponent.h>
  59
  60 class MyQmlAttachedObject : public QObject
  61 {
  62     Q_OBJECT
  63     Q_PROPERTY(int value READ value CONSTANT)
  64     Q_PROPERTY(int value2 READ value2 WRITE setValue2)
  65 public:
  66     MyQmlAttachedObject(QObject *parent) : QObject(parent), m_value2(0) {}
  67
  68     int value() const { return 19; }
  69     int value2() const { return m_value2; }
  70     void setValue2(int v) { m_value2 = v; }
  71
  72     void emitMySignal() { emit mySignal(); }
  73
  74 signals:
  75     void mySignal();
  76
  77 private:
  78     int m_value2;
  79 };
  80
  81 class MyQmlObject : public QObject
  82 {
  83     Q_OBJECT
  84     Q_ENUMS(MyEnum)
  85     Q_ENUMS(MyEnum2)
  86     Q_PROPERTY(int deleteOnSet READ deleteOnSet WRITE setDeleteOnSet)
  87     Q_PROPERTY(bool trueProperty READ trueProperty CONSTANT)
  88     Q_PROPERTY(bool falseProperty READ falseProperty CONSTANT)
  89     Q_PROPERTY(int value READ value WRITE setValue)
  90     Q_PROPERTY(int console READ console CONSTANT)
  91     Q_PROPERTY(QString stringProperty READ stringProperty WRITE setStringProperty NOTIFY stringChanged)
  92     Q_PROPERTY(QObject *objectProperty READ objectProperty WRITE setObjectProperty NOTIFY objectChanged)
  93     Q_PROPERTY(QDeclarativeListProperty<QObject> objectListProperty READ objectListProperty CONSTANT)
  94     Q_PROPERTY(int resettableProperty READ resettableProperty WRITE setResettableProperty RESET resetProperty)
  95     Q_PROPERTY(QRegExp regExp READ regExp WRITE setRegExp)
  96     Q_PROPERTY(int nonscriptable READ nonscriptable WRITE setNonscriptable SCRIPTABLE false)
  97
  98 public:
  99     MyQmlObject(): myinvokableObject(0), m_methodCalled(false), m_methodIntCalled(false), m_object(0), m_value(0), m_resetProperty(13) {}
 100
 101     enum MyEnum { EnumValue1 = 0, EnumValue2 = 1 };
 102     enum MyEnum2 { EnumValue3 = 2, EnumValue4 = 3 };
 103
 104     bool trueProperty() const { return true; }
 105     bool falseProperty() const { return false; }
 106
 107     QString stringProperty() const { return m_string; }
 108     void setStringProperty(const QString &s)
 109     {
 110         if (s == m_string)
 111             return;
 112         m_string = s;
 113         emit stringChanged();
 114     }
 115
 116     QObject *objectProperty() const { return m_object; }
 117     void setObjectProperty(QObject *obj) {
 118         if (obj == m_object)
 119             return;
 120         m_object = obj;
 121         emit objectChanged();
 122     }
 123
 124     QDeclarativeListProperty<QObject> objectListProperty() { return QDeclarativeListProperty<QObject>(this, m_objectQList); }
 125
 126     bool methodCalled() const { return m_methodCalled; }
 127     bool methodIntCalled() const { return m_methodIntCalled; }
 128
 129     QString string() const { return m_string; }
 130
 131     static MyQmlAttachedObject *qmlAttachedProperties(QObject *o) {
 132         return new MyQmlAttachedObject(o);
 133     }
 134
 135     int deleteOnSet() const { return 1; }
 136     void setDeleteOnSet(int v) { if(v) delete this; }
 137
 138     int value() const { return m_value; }
 139     void setValue(int v) { m_value = v; }
 140
 141     int resettableProperty() const { return m_resetProperty; }
 142     void setResettableProperty(int v) { m_resetProperty = v; }
 143     void resetProperty() { m_resetProperty = 13; }
 144
 145     QRegExp regExp() { return m_regExp; }
 146     void setRegExp(const QRegExp &regExp) { m_regExp = regExp; }
 147
 148     int console() const { return 11; }
 149
 150     int nonscriptable() const { return 0; }
 151     void setNonscriptable(int) {}
 152
 153     MyQmlObject *myinvokableObject;
 154     Q_INVOKABLE MyQmlObject *returnme() { return this; }
 155
 156     struct MyType {
 157         int value;
 158     };
 159     QVariant variant() const { return m_variant; }
 160
 161 signals:
 162     void basicSignal();
 163     void argumentSignal(int a, QString b, qreal c);
 164     void stringChanged();
 165     void objectChanged();
 166     void anotherBasicSignal();
 167     void thirdBasicSignal();
 168     void signalWithUnknownType(const MyQmlObject::MyType &arg);
 169
 170 public slots:
 171     void deleteMe() { delete this; }
 172     void methodNoArgs() { m_methodCalled = true; }
 173     void method(int a) { if(a == 163) m_methodIntCalled = true; }
 174     void setString(const QString &s) { m_string = s; }
 175     void myinvokable(MyQmlObject *o) { myinvokableObject = o; }
 176     void variantMethod(const QVariant &v) { m_variant = v; }
 177
 178 private:
 179     friend class tst_qdeclarativeecmascript;
 180     bool m_methodCalled;
 181     bool m_methodIntCalled;
 182
 183     QObject *m_object;
 184     QString m_string;
 185     QList<QObject *> m_objectQList;
 186     int m_value;
 187     int m_resetProperty;
 188     QRegExp m_regExp;
 189     QVariant m_variant;
 190 };
 191
 192 QML_DECLARE_TYPEINFO(MyQmlObject, QML_HAS_ATTACHED_PROPERTIES)
 193 Q_DECLARE_METATYPE(MyQmlObject::MyType)
 194
 195 class testQObjectApi : public QObject
 196 {
 197     Q_OBJECT
 198     Q_PROPERTY (int qobjectTestProperty READ qobjectTestProperty NOTIFY qobjectTestPropertyChanged)
 199
 200 public:
 201     testQObjectApi(QObject* parent = 0)
 202         : QObject(parent), m_testProperty(0)
 203     {
 204     }
 205
 206     ~testQObjectApi() {}
 207
 208     int qobjectTestProperty() const { return m_testProperty; }
 209     void setQObjectTestProperty(int tp) { m_testProperty = tp; emit qobjectTestPropertyChanged(tp); }
 210
 211 signals:
 212     void qobjectTestPropertyChanged(int testProperty);
 213
 214 private:
 215     int m_testProperty;
 216 };
 217
 218 class ArbitraryVariantProvider : public QObject
 219 {
 220     Q_OBJECT
 221     Q_PROPERTY(QVariant arbitraryVariant READ arbitraryVariant WRITE setArbitraryVariant NOTIFY arbitraryVariantChanged)
 222
 223 public:
 224     ArbitraryVariantProvider(QObject *parent = 0)
 225         : QObject(parent), m_value(QVariant(QString(QLatin1String("random string value")))), m_count(1)
 226     {
 227     }
 228
 229     ~ArbitraryVariantProvider() {}
 230
 231     // the variant provided by the provider
 232     QVariant arbitraryVariant() const { return m_value; }
 233     void setArbitraryVariant(const QVariant& value) { m_value = value; emit arbitraryVariantChanged(); }
 234     Q_INVOKABLE int changeVariant()
 235     {
 236         QPixmap pv(150, 150);
 237         pv.fill(Qt::green);
 238         int choice = qrand() % 4;
 239         switch (choice) {
 240             case 0: setArbitraryVariant(QVariant(QString(QLatin1String("string variant value")))); break;
 241             case 1: setArbitraryVariant(QVariant(QColor(110, 120, 130))); break;
 242             case 2: setArbitraryVariant(QVariant(55)); break;
 243             default: setArbitraryVariant(QVariant(pv)); break;
 244         }
 245
 246         m_count += 1;
 247         return m_count;
 248     }
 249     Q_INVOKABLE QVariant setVariantToFilledPixmap(int width, int height, int r, int g, int b)
 250     {
 251         QPixmap pv(width % 300, height % 300);
 252         pv.fill(QColor(r % 256, g % 256, b % 256));
 253         m_value = pv;
 254         m_count += 1;
 255         return m_value;
 256     }
 257     Q_INVOKABLE QVariant setVariantAddCount(int addToCount, const QVariant& newValue)
 258     {
 259         m_value = newValue;
 260         m_count += addToCount;
 261         return m_value;
 262     }
 263     Q_INVOKABLE QVariant possibleVariant(int randomFactorOne, int randomFactorTwo, int randomFactorThree) const
 264     {
 265         QVariant retn;
 266         QPixmap pv(randomFactorOne % 300, randomFactorTwo % 300);
 267         pv.fill(QColor(randomFactorOne % 256, randomFactorTwo % 256, randomFactorThree % 256));
 268         int choice = qrand() % 4;
 269         switch (choice) {
 270             case 0: retn = QVariant(QString(QLatin1String("string variant value"))); break;
 271             case 1: retn = QVariant(QColor(randomFactorThree % 256, randomFactorTwo % 256, randomFactorOne % 256)); break;
 272             case 2: retn = QVariant((55 + randomFactorThree)); break;
 273             default: retn = QVariant(pv); break;
 274         }
 275         return retn;
 276     }
 277
 278     // the following functions cover permutations of return value and arguments.
 279     // functions with no return value:
 280     Q_INVOKABLE void doNothing() const { /* does nothing */ }                      // no args, const
 281     Q_INVOKABLE void incrementVariantChangeCount() { m_count = m_count + 1; }      // no args, nonconst
 282     Q_INVOKABLE void doNothing(int) const { /* does nothing. */ }                  // arg, const
 283     Q_INVOKABLE void setVariantChangeCount(int newCount) { m_count = newCount; }   // arg, nonconst
 284     // functions with return value:
 285     Q_INVOKABLE int variantChangeCount() const { return m_count; }                 // no args, const
 286     Q_INVOKABLE int modifyVariantChangeCount() { m_count += 3; return m_count; }   // no args, nonconst
 287     Q_INVOKABLE int countPlus(int value) const { return m_count + value; }         // arg, const
 288     Q_INVOKABLE int modifyVariantChangeCount(int modifier) { m_count += modifier; return m_count; } // arg, nonconst.
 289
 290 signals:
 291     void arbitraryVariantChanged();
 292
 293 private:
 294     QVariant m_value;
 295     int m_count;
 296 };
 297
 298 class ScarceResourceProvider : public QObject
 299 {
 300     Q_OBJECT
 301     Q_PROPERTY(QPixmap smallScarceResource READ smallScarceResource WRITE setSmallScarceResource NOTIFY smallScarceResourceChanged)
 302     Q_PROPERTY(QPixmap largeScarceResource READ largeScarceResource WRITE setLargeScarceResource NOTIFY largeScarceResourceChanged)
 303
 304 public:
 305     ScarceResourceProvider(QObject *parent = 0)
 306         : QObject(parent), m_small(100, 100), m_large(1000, 1000), m_colour(1)
 307     {
 308         m_small.fill(Qt::blue);
 309         m_large.fill(Qt::blue);
 310     }
 311
 312     ~ScarceResourceProvider() {}
 313
 314     QPixmap smallScarceResource() const { return m_small; }
 315     void setSmallScarceResource(QPixmap v) { m_small = v; emit smallScarceResourceChanged(); }
 316     bool smallScarceResourceIsDetached() const { return m_small.isDetached(); }
 317
 318     QPixmap largeScarceResource() const { return m_large; }
 319     void setLargeScarceResource(QPixmap v) { m_large = v; emit largeScarceResourceChanged(); }
 320     bool largeScarceResourceIsDetached() const { return m_large.isDetached(); }
 321
 322     Q_INVOKABLE void changeResources()
 323     {
 324         QPixmap newSmall(100, 100);
 325         QPixmap newLarge(1000, 1000);
 326
 327         if (m_colour == 1) {
 328             m_colour = 2;
 329             newSmall.fill(Qt::red);
 330             newLarge.fill(Qt::red);
 331         } else {
 332             m_colour = 1;
 333             newSmall.fill(Qt::blue);
 334             newLarge.fill(Qt::blue);
 335         }
 336
 337         setSmallScarceResource(newSmall);
 338         setLargeScarceResource(newLarge);
 339     }
 340
 341 signals:
 342     void smallScarceResourceChanged();
 343     void largeScarceResourceChanged();
 344
 345 private:
 346     QPixmap m_small;
 347     QPixmap m_large;
 348
 349     int m_colour;
 350 };
 351
 352 void registerTypes();
 353
 354 #endif // TESTTYPES_H
 355