src/qml/qml/qqmlglobal.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
   4 ** Contact: http://www.qt-project.org/
   5 **
   6 ** This file is part of the QtQml module of the Qt Toolkit.
   7 **
   8 ** $QT_BEGIN_LICENSE:LGPL$
   9 ** GNU Lesser General Public License Usage
  10 ** This file may be used under the terms of the GNU Lesser General Public
  11 ** License version 2.1 as published by the Free Software Foundation and
  12 ** appearing in the file LICENSE.LGPL included in the packaging of this
  13 ** file. Please review the following information to ensure the GNU Lesser
  14 ** General Public License version 2.1 requirements will be met:
  15 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  16 **
  17 ** In addition, as a special exception, Nokia gives you certain additional
  18 ** rights. These rights are described in the Nokia Qt LGPL Exception
  19 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  20 **
  21 ** GNU General Public License Usage
  22 ** Alternatively, this file may be used under the terms of the GNU General
  23 ** Public License version 3.0 as published by the Free Software Foundation
  24 ** and appearing in the file LICENSE.GPL included in the packaging of this
  25 ** file. Please review the following information to ensure the GNU General
  26 ** Public License version 3.0 requirements will be met:
  27 ** http://www.gnu.org/copyleft/gpl.html.
  28 **
  29 ** Other Usage
  30 ** Alternatively, this file may be used in accordance with the terms and
  31 ** conditions contained in a signed written agreement between you and Nokia.
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include <private/qqmlglobal_p.h>
  43
  44 #include <QtCore/qvariant.h>
  45 #include <QtCore/qstringlist.h>
  46 #include <QtCore/qdebug.h>
  47
  48 QT_BEGIN_NAMESPACE
  49
  50 QQmlValueTypeProvider::QQmlValueTypeProvider()
  51     : next(0)
  52 {
  53 }
  54
  55 QQmlValueType *QQmlValueTypeProvider::createValueType(int type)
  56 {
  57     QQmlValueType *value = 0;
  58
  59     QQmlValueTypeProvider *p = this;
  60     do {
  61         if (p->create(type, value))
  62             return value;
  63     } while ((p = p->next));
  64
  65     return 0;
  66 }
  67
  68 bool QQmlValueTypeProvider::initValueType(int type, void *data, size_t n)
  69 {
  70     Q_ASSERT(data);
  71
  72     QQmlValueTypeProvider *p = this;
  73     do {
  74         if (p->init(type, data, n))
  75             return true;
  76     } while ((p = p->next));
  77
  78     return false;
  79 }
  80
  81 bool QQmlValueTypeProvider::destroyValueType(int type, void *data, size_t n)
  82 {
  83     Q_ASSERT(data);
  84
  85     QQmlValueTypeProvider *p = this;
  86     do {
  87         if (p->destroy(type, data, n))
  88             return true;
  89     } while ((p = p->next));
  90
  91     return false;
  92 }
  93
  94 bool QQmlValueTypeProvider::copyValueType(int type, const void *src, void *dst, size_t n)
  95 {
  96     Q_ASSERT(src);
  97     Q_ASSERT(dst);
  98
  99     QQmlValueTypeProvider *p = this;
 100     do {
 101         if (p->copy(type, src, dst, n))
 102             return true;
 103     } while ((p = p->next));
 104
 105     return false;
 106 }
 107
 108 QVariant QQmlValueTypeProvider::createValueType(int type, int argc, const void *argv[])
 109 {
 110     QVariant v;
 111
 112     QQmlValueTypeProvider *p = this;
 113     do {
 114         if (p->create(type, argc, argv, &v))
 115             return v;
 116     } while ((p = p->next));
 117
 118     return QVariant();
 119 }
 120
 121 bool QQmlValueTypeProvider::createValueFromString(int type, const QString &s, void *data, size_t n)
 122 {
 123     Q_ASSERT(data);
 124
 125     QQmlValueTypeProvider *p = this;
 126     do {
 127         if (p->createFromString(type, s, data, n))
 128             return true;
 129     } while ((p = p->next));
 130
 131     return false;
 132 }
 133
 134 bool QQmlValueTypeProvider::createStringFromValue(int type, const void *data, QString *s)
 135 {
 136     Q_ASSERT(data);
 137     Q_ASSERT(s);
 138
 139     QQmlValueTypeProvider *p = this;
 140     do {
 141         if (p->createStringFrom(type, data, s))
 142             return true;
 143     } while ((p = p->next));
 144
 145     return false;
 146 }
 147
 148 QVariant QQmlValueTypeProvider::createVariantFromString(const QString &s)
 149 {
 150     QVariant v;
 151
 152     QQmlValueTypeProvider *p = this;
 153     do {
 154         if (p->variantFromString(s, &v))
 155             return v;
 156     } while ((p = p->next));
 157
 158     // Return a variant containing the string itself
 159     return QVariant(s);
 160 }
 161
 162 QVariant QQmlValueTypeProvider::createVariantFromString(int type, const QString &s, bool *ok)
 163 {
 164     QVariant v;
 165
 166     QQmlValueTypeProvider *p = this;
 167     do {
 168         if (p->variantFromString(type, s, &v)) {
 169             if (ok) *ok = true;
 170             return v;
 171         }
 172     } while ((p = p->next));
 173
 174     if (ok) *ok = false;
 175     return QVariant();
 176 }
 177
 178 QVariant QQmlValueTypeProvider::createVariantFromJsObject(int type, QQmlV8Handle obj, QV8Engine *e, bool *ok)
 179 {
 180     QVariant v;
 181
 182     QQmlValueTypeProvider *p = this;
 183     do {
 184         if (p->variantFromJsObject(type, obj, e, &v)) {
 185             if (ok) *ok = true;
 186             return v;
 187         }
 188     } while ((p = p->next));
 189
 190     if (ok) *ok = false;
 191     return QVariant();
 192 }
 193
 194 bool QQmlValueTypeProvider::equalValueType(int type, const void *lhs, const void *rhs, size_t rhsSize)
 195 {
 196     Q_ASSERT(lhs);
 197     Q_ASSERT(rhs);
 198
 199     QQmlValueTypeProvider *p = this;
 200     do {
 201         if (p->equal(type, lhs, rhs, rhsSize))
 202             return true;
 203     } while ((p = p->next));
 204
 205     return false;
 206 }
 207
 208 bool QQmlValueTypeProvider::storeValueType(int type, const void *src, void *dst, size_t dstSize)
 209 {
 210     Q_ASSERT(src);
 211     Q_ASSERT(dst);
 212
 213     QQmlValueTypeProvider *p = this;
 214     do {
 215         if (p->store(type, src, dst, dstSize))
 216             return true;
 217     } while ((p = p->next));
 218
 219     return false;
 220 }
 221
 222 bool QQmlValueTypeProvider::readValueType(int srcType, const void *src, size_t srcSize, int dstType, void *dst)
 223 {
 224     Q_ASSERT(src);
 225     Q_ASSERT(dst);
 226
 227     QQmlValueTypeProvider *p = this;
 228     do {
 229         if (p->read(srcType, src, srcSize, dstType, dst))
 230             return true;
 231     } while ((p = p->next));
 232
 233     return false;
 234 }
 235
 236 bool QQmlValueTypeProvider::writeValueType(int type, const void *src, void *dst, size_t n)
 237 {
 238     Q_ASSERT(src);
 239     Q_ASSERT(dst);
 240
 241     QQmlValueTypeProvider *p = this;
 242     do {
 243         if (p->write(type, src, dst, n))
 244             return true;
 245     } while ((p = p->next));
 246
 247     return false;
 248 }
 249
 250 bool QQmlValueTypeProvider::create(int, QQmlValueType *&) { return false; }
 251 bool QQmlValueTypeProvider::init(int, void *, size_t) { return false; }
 252 bool QQmlValueTypeProvider::destroy(int, void *, size_t) { return false; }
 253 bool QQmlValueTypeProvider::copy(int, const void *, void *, size_t) { return false; }
 254 bool QQmlValueTypeProvider::create(int, int, const void *[], QVariant *) { return false; }
 255 bool QQmlValueTypeProvider::createFromString(int, const QString &, void *, size_t) { return false; }
 256 bool QQmlValueTypeProvider::createStringFrom(int, const void *, QString *) { return false; }
 257 bool QQmlValueTypeProvider::variantFromString(const QString &, QVariant *) { return false; }
 258 bool QQmlValueTypeProvider::variantFromString(int, const QString &, QVariant *) { return false; }
 259 bool QQmlValueTypeProvider::variantFromJsObject(int, QQmlV8Handle, QV8Engine *, QVariant *) { return false; }
 260 bool QQmlValueTypeProvider::equal(int, const void *, const void *, size_t) { return false; }
 261 bool QQmlValueTypeProvider::store(int, const void *, void *, size_t) { return false; }
 262 bool QQmlValueTypeProvider::read(int, const void *, size_t, int, void *) { return false; }
 263 bool QQmlValueTypeProvider::write(int, const void *, void *, size_t) { return false; }
 264
 265 static QQmlValueTypeProvider *valueTypeProvider = 0;
 266
 267 static QQmlValueTypeProvider **getValueTypeProvider(void)
 268 {
 269     if (valueTypeProvider == 0) {
 270         static QQmlValueTypeProvider nullValueTypeProvider;
 271         valueTypeProvider = &nullValueTypeProvider;
 272     }
 273
 274     return &valueTypeProvider;
 275 }
 276
 277 Q_QML_PRIVATE_EXPORT void QQml_addValueTypeProvider(QQmlValueTypeProvider *newProvider)
 278 {
 279     static QQmlValueTypeProvider **providerPtr = getValueTypeProvider();
 280     newProvider->next = *providerPtr;
 281     *providerPtr = newProvider;
 282 }
 283
 284 Q_AUTOTEST_EXPORT QQmlValueTypeProvider *QQml_valueTypeProvider(void)
 285 {
 286     static QQmlValueTypeProvider **providerPtr = getValueTypeProvider();
 287     return *providerPtr;
 288 }
 289
 290
 291 QVariant QQmlColorProvider::colorFromString(const QString &, bool *ok) { if (ok) *ok = false; return QVariant(); }
 292 unsigned QQmlColorProvider::rgbaFromString(const QString &, bool *ok) { if (ok) *ok = false; return 0; }
 293 QVariant QQmlColorProvider::fromRgbF(double, double, double, double) { return QVariant(); }
 294 QVariant QQmlColorProvider::fromHslF(double, double, double, double) { return QVariant(); }
 295 QVariant QQmlColorProvider::lighter(const QVariant &, qreal) { return QVariant(); }
 296 QVariant QQmlColorProvider::darker(const QVariant &, qreal) { return QVariant(); }
 297 QVariant QQmlColorProvider::tint(const QVariant &, const QVariant &) { return QVariant(); }
 298
 299 static QQmlColorProvider *colorProvider = 0;
 300
 301 Q_QML_PRIVATE_EXPORT QQmlColorProvider *QQml_setColorProvider(QQmlColorProvider *newProvider)
 302 {
 303     QQmlColorProvider *old = colorProvider;
 304     colorProvider = newProvider;
 305     return old;
 306 }
 307
 308 static QQmlColorProvider **getColorProvider(void)
 309 {
 310     if (colorProvider == 0) {
 311         qWarning() << "Warning: QQml_colorProvider: no color provider has been set!";
 312         static QQmlColorProvider nullColorProvider;
 313         colorProvider = &nullColorProvider;
 314     }
 315
 316     return &colorProvider;
 317 }
 318
 319 Q_AUTOTEST_EXPORT QQmlColorProvider *QQml_colorProvider(void)
 320 {
 321     static QQmlColorProvider **providerPtr = getColorProvider();
 322     return *providerPtr;
 323 }
 324
 325
 326 QObject *QQmlGuiProvider::application(QObject *) { return 0; }
 327 QStringList QQmlGuiProvider::fontFamilies() { return QStringList(); }
 328 bool QQmlGuiProvider::openUrlExternally(QUrl &) { return false; }
 329
 330 QObject *QQmlGuiProvider::inputMethod()
 331 {
 332     // We don't have any input method code by default
 333     QObject *o = new QObject();
 334     o->setObjectName(QString::fromLatin1("No inputMethod available"));
 335     return o;
 336 }
 337
 338 static QQmlGuiProvider *guiProvider = 0;
 339
 340 Q_QML_PRIVATE_EXPORT QQmlGuiProvider *QQml_setGuiProvider(QQmlGuiProvider *newProvider)
 341 {
 342     QQmlGuiProvider *old = guiProvider;
 343     guiProvider = newProvider;
 344     return old;
 345 }
 346
 347 static QQmlGuiProvider **getGuiProvider(void)
 348 {
 349     if (guiProvider == 0) {
 350         qWarning() << "Warning: QQml_guiProvider: no GUI provider has been set!";
 351         static QQmlGuiProvider nullGuiProvider;
 352         guiProvider = &nullGuiProvider;
 353     }
 354
 355     return &guiProvider;
 356 }
 357
 358 Q_AUTOTEST_EXPORT QQmlGuiProvider *QQml_guiProvider(void)
 359 {
 360     static QQmlGuiProvider **providerPtr = getGuiProvider();
 361     return *providerPtr;
 362 }
 363
 364 QT_END_NAMESPACE