src/qml/qml/qqmlglobal.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
   4 ** Contact: http://www.qt-project.org/legal
   5 **
   6 ** This file is part of the QtQml module 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
  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 QQmlValueTypeProvider::~QQmlValueTypeProvider()
  56 {
  57 }
  58
  59 QQmlValueType *QQmlValueTypeProvider::createValueType(int type)
  60 {
  61     QQmlValueType *value = 0;
  62
  63     QQmlValueTypeProvider *p = this;
  64     do {
  65         if (p->create(type, value))
  66             return value;
  67     } while ((p = p->next));
  68
  69     return 0;
  70 }
  71
  72 bool QQmlValueTypeProvider::initValueType(int type, void *data, size_t n)
  73 {
  74     Q_ASSERT(data);
  75
  76     QQmlValueTypeProvider *p = this;
  77     do {
  78         if (p->init(type, data, n))
  79             return true;
  80     } while ((p = p->next));
  81
  82     return false;
  83 }
  84
  85 bool QQmlValueTypeProvider::destroyValueType(int type, void *data, size_t n)
  86 {
  87     Q_ASSERT(data);
  88
  89     QQmlValueTypeProvider *p = this;
  90     do {
  91         if (p->destroy(type, data, n))
  92             return true;
  93     } while ((p = p->next));
  94
  95     return false;
  96 }
  97
  98 bool QQmlValueTypeProvider::copyValueType(int type, const void *src, void *dst, size_t n)
  99 {
 100     Q_ASSERT(src);
 101     Q_ASSERT(dst);
 102
 103     QQmlValueTypeProvider *p = this;
 104     do {
 105         if (p->copy(type, src, dst, n))
 106             return true;
 107     } while ((p = p->next));
 108
 109     return false;
 110 }
 111
 112 QVariant QQmlValueTypeProvider::createValueType(int type, int argc, const void *argv[])
 113 {
 114     QVariant v;
 115
 116     QQmlValueTypeProvider *p = this;
 117     do {
 118         if (p->create(type, argc, argv, &v))
 119             return v;
 120     } while ((p = p->next));
 121
 122     return QVariant();
 123 }
 124
 125 bool QQmlValueTypeProvider::createValueFromString(int type, const QString &s, void *data, size_t n)
 126 {
 127     Q_ASSERT(data);
 128
 129     QQmlValueTypeProvider *p = this;
 130     do {
 131         if (p->createFromString(type, s, data, n))
 132             return true;
 133     } while ((p = p->next));
 134
 135     return false;
 136 }
 137
 138 bool QQmlValueTypeProvider::createStringFromValue(int type, const void *data, QString *s)
 139 {
 140     Q_ASSERT(data);
 141     Q_ASSERT(s);
 142
 143     QQmlValueTypeProvider *p = this;
 144     do {
 145         if (p->createStringFrom(type, data, s))
 146             return true;
 147     } while ((p = p->next));
 148
 149     return false;
 150 }
 151
 152 QVariant QQmlValueTypeProvider::createVariantFromString(const QString &s)
 153 {
 154     QVariant v;
 155
 156     QQmlValueTypeProvider *p = this;
 157     do {
 158         if (p->variantFromString(s, &v))
 159             return v;
 160     } while ((p = p->next));
 161
 162     // Return a variant containing the string itself
 163     return QVariant(s);
 164 }
 165
 166 QVariant QQmlValueTypeProvider::createVariantFromString(int type, const QString &s, bool *ok)
 167 {
 168     QVariant v;
 169
 170     QQmlValueTypeProvider *p = this;
 171     do {
 172         if (p->variantFromString(type, s, &v)) {
 173             if (ok) *ok = true;
 174             return v;
 175         }
 176     } while ((p = p->next));
 177
 178     if (ok) *ok = false;
 179     return QVariant();
 180 }
 181
 182 QVariant QQmlValueTypeProvider::createVariantFromJsObject(int type, QQmlV8Handle obj, QV8Engine *e, bool *ok)
 183 {
 184     QVariant v;
 185
 186     QQmlValueTypeProvider *p = this;
 187     do {
 188         if (p->variantFromJsObject(type, obj, e, &v)) {
 189             if (ok) *ok = true;
 190             return v;
 191         }
 192     } while ((p = p->next));
 193
 194     if (ok) *ok = false;
 195     return QVariant();
 196 }
 197
 198 bool QQmlValueTypeProvider::equalValueType(int type, const void *lhs, const void *rhs, size_t rhsSize)
 199 {
 200     Q_ASSERT(lhs);
 201     Q_ASSERT(rhs);
 202
 203     QQmlValueTypeProvider *p = this;
 204     do {
 205         if (p->equal(type, lhs, rhs, rhsSize))
 206             return true;
 207     } while ((p = p->next));
 208
 209     return false;
 210 }
 211
 212 bool QQmlValueTypeProvider::storeValueType(int type, const void *src, void *dst, size_t dstSize)
 213 {
 214     Q_ASSERT(src);
 215     Q_ASSERT(dst);
 216
 217     QQmlValueTypeProvider *p = this;
 218     do {
 219         if (p->store(type, src, dst, dstSize))
 220             return true;
 221     } while ((p = p->next));
 222
 223     return false;
 224 }
 225
 226 bool QQmlValueTypeProvider::readValueType(int srcType, const void *src, size_t srcSize, int dstType, void *dst)
 227 {
 228     Q_ASSERT(src);
 229     Q_ASSERT(dst);
 230
 231     QQmlValueTypeProvider *p = this;
 232     do {
 233         if (p->read(srcType, src, srcSize, dstType, dst))
 234             return true;
 235     } while ((p = p->next));
 236
 237     return false;
 238 }
 239
 240 bool QQmlValueTypeProvider::writeValueType(int type, const void *src, void *dst, size_t n)
 241 {
 242     Q_ASSERT(src);
 243     Q_ASSERT(dst);
 244
 245     QQmlValueTypeProvider *p = this;
 246     do {
 247         if (p->write(type, src, dst, n))
 248             return true;
 249     } while ((p = p->next));
 250
 251     return false;
 252 }
 253
 254 bool QQmlValueTypeProvider::create(int, QQmlValueType *&) { return false; }
 255 bool QQmlValueTypeProvider::init(int, void *, size_t) { return false; }
 256 bool QQmlValueTypeProvider::destroy(int, void *, size_t) { return false; }
 257 bool QQmlValueTypeProvider::copy(int, const void *, void *, size_t) { return false; }
 258 bool QQmlValueTypeProvider::create(int, int, const void *[], QVariant *) { return false; }
 259 bool QQmlValueTypeProvider::createFromString(int, const QString &, void *, size_t) { return false; }
 260 bool QQmlValueTypeProvider::createStringFrom(int, const void *, QString *) { return false; }
 261 bool QQmlValueTypeProvider::variantFromString(const QString &, QVariant *) { return false; }
 262 bool QQmlValueTypeProvider::variantFromString(int, const QString &, QVariant *) { return false; }
 263 bool QQmlValueTypeProvider::variantFromJsObject(int, QQmlV8Handle, QV8Engine *, QVariant *) { return false; }
 264 bool QQmlValueTypeProvider::equal(int, const void *, const void *, size_t) { return false; }
 265 bool QQmlValueTypeProvider::store(int, const void *, void *, size_t) { return false; }
 266 bool QQmlValueTypeProvider::read(int, const void *, size_t, int, void *) { return false; }
 267 bool QQmlValueTypeProvider::write(int, const void *, void *, size_t) { return false; }
 268
 269 static QQmlValueTypeProvider *valueTypeProvider = 0;
 270
 271 static QQmlValueTypeProvider **getValueTypeProvider(void)
 272 {
 273     if (valueTypeProvider == 0) {
 274         static QQmlValueTypeProvider nullValueTypeProvider;
 275         valueTypeProvider = &nullValueTypeProvider;
 276     }
 277
 278     return &valueTypeProvider;
 279 }
 280
 281 Q_QML_PRIVATE_EXPORT void QQml_addValueTypeProvider(QQmlValueTypeProvider *newProvider)
 282 {
 283     static QQmlValueTypeProvider **providerPtr = getValueTypeProvider();
 284     newProvider->next = *providerPtr;
 285     *providerPtr = newProvider;
 286 }
 287
 288 Q_AUTOTEST_EXPORT QQmlValueTypeProvider *QQml_valueTypeProvider(void)
 289 {
 290     static QQmlValueTypeProvider **providerPtr = getValueTypeProvider();
 291     return *providerPtr;
 292 }
 293
 294 QQmlColorProvider::~QQmlColorProvider() {}
 295 QVariant QQmlColorProvider::colorFromString(const QString &, bool *ok) { if (ok) *ok = false; return QVariant(); }
 296 unsigned QQmlColorProvider::rgbaFromString(const QString &, bool *ok) { if (ok) *ok = false; return 0; }
 297 QVariant QQmlColorProvider::fromRgbF(double, double, double, double) { return QVariant(); }
 298 QVariant QQmlColorProvider::fromHslF(double, double, double, double) { return QVariant(); }
 299 QVariant QQmlColorProvider::lighter(const QVariant &, qreal) { return QVariant(); }
 300 QVariant QQmlColorProvider::darker(const QVariant &, qreal) { return QVariant(); }
 301 QVariant QQmlColorProvider::tint(const QVariant &, const QVariant &) { return QVariant(); }
 302
 303 static QQmlColorProvider *colorProvider = 0;
 304
 305 Q_QML_PRIVATE_EXPORT QQmlColorProvider *QQml_setColorProvider(QQmlColorProvider *newProvider)
 306 {
 307     QQmlColorProvider *old = colorProvider;
 308     colorProvider = newProvider;
 309     return old;
 310 }
 311
 312 static QQmlColorProvider **getColorProvider(void)
 313 {
 314     if (colorProvider == 0) {
 315         qWarning() << "Warning: QQml_colorProvider: no color provider has been set!";
 316         static QQmlColorProvider nullColorProvider;
 317         colorProvider = &nullColorProvider;
 318     }
 319
 320     return &colorProvider;
 321 }
 322
 323 Q_AUTOTEST_EXPORT QQmlColorProvider *QQml_colorProvider(void)
 324 {
 325     static QQmlColorProvider **providerPtr = getColorProvider();
 326     return *providerPtr;
 327 }
 328
 329
 330 QQmlGuiProvider::~QQmlGuiProvider() {}
 331 QObject *QQmlGuiProvider::application(QObject *) { return 0; }
 332 QStringList QQmlGuiProvider::fontFamilies() { return QStringList(); }
 333 bool QQmlGuiProvider::openUrlExternally(QUrl &) { return false; }
 334
 335 QObject *QQmlGuiProvider::inputMethod()
 336 {
 337     // We don't have any input method code by default
 338     QObject *o = new QObject();
 339     o->setObjectName(QString::fromLatin1("No inputMethod available"));
 340     return o;
 341 }
 342
 343 static QQmlGuiProvider *guiProvider = 0;
 344
 345 Q_QML_PRIVATE_EXPORT QQmlGuiProvider *QQml_setGuiProvider(QQmlGuiProvider *newProvider)
 346 {
 347     QQmlGuiProvider *old = guiProvider;
 348     guiProvider = newProvider;
 349     return old;
 350 }
 351
 352 static QQmlGuiProvider **getGuiProvider(void)
 353 {
 354     if (guiProvider == 0) {
 355         qWarning() << "Warning: QQml_guiProvider: no GUI provider has been set!";
 356         static QQmlGuiProvider nullGuiProvider;
 357         guiProvider = &nullGuiProvider;
 358     }
 359
 360     return &guiProvider;
 361 }
 362
 363 Q_AUTOTEST_EXPORT QQmlGuiProvider *QQml_guiProvider(void)
 364 {
 365     static QQmlGuiProvider **providerPtr = getGuiProvider();
 366     return *providerPtr;
 367 }
 368
 369 QT_END_NAMESPACE