/****************************************************************************
**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
**
** This file is part of the QtDeclarative module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this
+** file. Please review the following information to ensure the GNU Lesser
+** General Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
+** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
**
**
**
****************************************************************************/
#include <QtDeclarative/qdeclarativeprivate.h>
-#include "private/qdeclarativemetatype_p.h"
+#include "qdeclarativemetatype_p.h"
-#include "private/qdeclarativeproxymetaobject_p.h"
-#include "private/qdeclarativecustomparser_p.h"
-#include "private/qdeclarativeguard_p.h"
+#include <private/qdeclarativeproxymetaobject_p.h>
+#include <private/qdeclarativecustomparser_p.h>
+#include <private/qdeclarativeguard_p.h>
+#include <private/qhashedstring_p.h>
#include <QtCore/qdebug.h>
#include <QtCore/qstringlist.h>
#include <QtCore/qmetaobject.h>
#include <QtCore/qbitarray.h>
#include <QtCore/qreadwritelock.h>
+#include <QtCore/private/qmetaobject_p.h>
+
#include <qmetatype.h>
#include <qobjectdefs.h>
-#include <qdatetime.h>
#include <qbytearray.h>
#include <qreadwritelock.h>
#include <qstring.h>
#include <qstringlist.h>
#include <qvector.h>
-#include <qlocale.h>
-#include <QtCore/qcryptographichash.h>
-#include <QtScript/qscriptvalue.h>
#include <ctype.h>
-#ifdef QT_BOOTSTRAPPED
-# ifndef QT_NO_GEOM_VARIANT
-# define QT_NO_GEOM_VARIANT
-# endif
-#else
-# include <qbitarray.h>
-# include <qurl.h>
-# include <qvariant.h>
-#endif
-
-#ifndef QT_NO_GEOM_VARIANT
-# include <qsize.h>
-# include <qpoint.h>
-# include <qrect.h>
-# include <qline.h>
-# include <qvector3d.h>
-#endif
-#define NS(x) QT_PREPEND_NAMESPACE(x)
-
QT_BEGIN_NAMESPACE
struct QDeclarativeMetaTypeData
QList<QDeclarativeType *> types;
typedef QHash<int, QDeclarativeType *> Ids;
Ids idToType;
- typedef QHash<QByteArray, QDeclarativeType *> Names;
+ typedef QHash<QString, QDeclarativeType *> Names;
Names nameToType;
typedef QHash<const QMetaObject *, QDeclarativeType *> MetaObjects;
MetaObjects metaObjectToType;
typedef QHash<int, QDeclarativeMetaType::StringConverter> StringConverters;
StringConverters stringConverters;
+
+ struct VersionedUri {
+ VersionedUri()
+ : majorVersion(0) {}
+ VersionedUri(const QString &uri, int majorVersion)
+ : uri(uri), majorVersion(majorVersion) {}
+ bool operator==(const VersionedUri &other) const {
+ return other.majorVersion == majorVersion && other.uri == uri;
+ }
+ QString uri;
+ int majorVersion;
+ };
+ typedef QHash<VersionedUri, QDeclarativeTypeModule *> TypeModules;
+ TypeModules uriToModule;
+
struct ModuleApiList {
ModuleApiList() : sorted(true) {}
QList<QDeclarativeMetaType::ModuleApi> moduleApis;
bool sorted;
};
- typedef QHash<QByteArray, ModuleApiList> ModuleApis;
+ typedef QHash<QString, ModuleApiList> ModuleApis;
ModuleApis moduleApis;
int moduleApiCount;
- struct ModuleInfo {
- ModuleInfo(int major, int minor)
- : vmajor_min(major), vminor_min(minor), vmajor_max(major), vminor_max(minor) {}
- ModuleInfo(int major_min, int minor_min, int major_max, int minor_max)
- : vmajor_min(major_min), vminor_min(minor_min), vmajor_max(major_max), vminor_max(minor_max) {}
- int vmajor_min, vminor_min;
- int vmajor_max, vminor_max;
- };
- typedef QHash<QByteArray, ModuleInfo> ModuleInfoHash;
- ModuleInfoHash modules;
-
QBitArray objects;
QBitArray interfaces;
QBitArray lists;
QList<QDeclarativePrivate::AutoParentFunction> parentFunctions;
};
+
+class QDeclarativeTypeModulePrivate
+{
+public:
+ QDeclarativeTypeModulePrivate()
+ : minMinorVersion(INT_MAX), maxMinorVersion(0) {}
+
+ QDeclarativeMetaTypeData::VersionedUri uri;
+
+ int minMinorVersion;
+ int maxMinorVersion;
+
+ void add(QDeclarativeType *);
+
+ QStringHash<QList<QDeclarativeType *> > typeHash;
+ QList<QDeclarativeType *> types;
+};
+
Q_GLOBAL_STATIC(QDeclarativeMetaTypeData, metaTypeData)
Q_GLOBAL_STATIC(QReadWriteLock, metaTypeDataLock)
+static uint qHash(const QDeclarativeMetaTypeData::VersionedUri &v)
+{
+ return qHash(v.uri) ^ qHash(v.majorVersion);
+}
+
QDeclarativeMetaTypeData::QDeclarativeMetaTypeData()
: moduleApiCount(0)
{
QDeclarativeTypePrivate();
void init() const;
+ void initEnums() const;
bool m_isInterface : 1;
const char *m_iid;
- QByteArray m_module;
- QByteArray m_name;
+ QString m_module;
+ QString m_name;
+ QString m_elementName;
int m_version_maj;
int m_version_min;
int m_typeId; int m_listId;
int m_index;
QDeclarativeCustomParser *m_customParser;
mutable volatile bool m_isSetup:1;
- mutable bool m_haveSuperType : 1;
+ mutable volatile bool m_isEnumSetup:1;
+ mutable bool m_haveSuperType:1;
mutable QList<QDeclarativeProxyMetaObject::ProxyData> m_metaObjects;
+ mutable QStringHash<int> m_enums;
static QHash<const QMetaObject *, int> m_attachedPropertyIds;
};
m_superType(0), m_allocationSize(0), m_newFunc(0), m_baseMetaObject(0), m_attachedPropertiesFunc(0),
m_attachedPropertiesType(0), m_parserStatusCast(-1), m_propertyValueSourceCast(-1),
m_propertyValueInterceptorCast(-1), m_extFunc(0), m_extMetaObject(0), m_index(-1), m_customParser(0),
- m_isSetup(false), m_haveSuperType(false)
+ m_isSetup(false), m_isEnumSetup(false), m_haveSuperType(false)
{
}
QDeclarativeType::QDeclarativeType(int index, const QDeclarativePrivate::RegisterType &type)
: d(new QDeclarativeTypePrivate)
{
- QByteArray name = type.uri;
- if (type.uri) name += '/';
- name += type.elementName;
+ QString name = QString::fromUtf8(type.uri);
+ if (type.uri) name += QLatin1Char('/');
+ name += QString::fromUtf8(type.elementName);
- d->m_module = type.uri;
+ d->m_module = QString::fromUtf8(type.uri);
d->m_name = name;
d->m_version_maj = type.versionMajor;
d->m_version_min = type.versionMinor;
delete d;
}
-QByteArray QDeclarativeType::module() const
+QString QDeclarativeType::module() const
{
return d->m_module;
}
bool QDeclarativeType::availableInVersion(int vmajor, int vminor) const
{
- return vmajor > d->m_version_maj || (vmajor == d->m_version_maj && vminor >= d->m_version_min);
+ Q_ASSERT(vmajor >= 0 && vminor >= 0);
+ return vmajor == d->m_version_maj && vminor >= d->m_version_min;
}
-bool QDeclarativeType::availableInVersion(const QByteArray &module, int vmajor, int vminor) const
+bool QDeclarativeType::availableInVersion(const QString &module, int vmajor, int vminor) const
{
- return module == d->m_module && (vmajor > d->m_version_maj || (vmajor == d->m_version_maj && vminor >= d->m_version_min));
+ Q_ASSERT(vmajor >= 0 && vminor >= 0);
+ return module == d->m_module && vmajor == d->m_version_maj && vminor >= d->m_version_min;
}
// returns the nearest _registered_ super class
static void clone(QMetaObjectBuilder &builder, const QMetaObject *mo,
const QMetaObject *ignoreStart, const QMetaObject *ignoreEnd)
{
+ // Set classname
+ builder.setClassName(ignoreEnd->className());
+
// Clone Q_CLASSINFO
for (int ii = mo->classInfoOffset(); ii < mo->classInfoCount(); ++ii) {
QMetaClassInfo info = mo->classInfo(ii);
}
}
+static bool isPropertyRevisioned(const QMetaObject *mo, int index)
+{
+ int i = index;
+ i -= mo->propertyOffset();
+ if (i < 0 && mo->d.superdata)
+ return isPropertyRevisioned(mo->d.superdata, index);
+
+ const QMetaObjectPrivate *mop = reinterpret_cast<const QMetaObjectPrivate*>(mo->d.data);
+ if (i >= 0 && i < mop->propertyCount) {
+ int handle = mop->propertyData + 3*i;
+ int flags = mo->d.data[handle + 2];
+
+ return (flags & Revisioned);
+ }
+
+ return false;
+}
+
void QDeclarativeTypePrivate::init() const
{
if (m_isSetup) return;
// XXX - very inefficient
const QMetaObject *mo = m_baseMetaObject;
if (m_extFunc) {
- QMetaObject *mmo = new QMetaObject;
- *mmo = *m_extMetaObject;
+ QMetaObjectBuilder builder;
+ clone(builder, m_extMetaObject, m_extMetaObject, m_extMetaObject);
+ builder.setFlags(QMetaObjectBuilder::DynamicMetaObject);
+ QMetaObject *mmo = builder.toMetaObject();
mmo->d.superdata = mo;
QDeclarativeProxyMetaObject::ProxyData data = { mmo, m_extFunc, 0, 0 };
m_metaObjects << data;
if (t->d->m_extFunc) {
QMetaObjectBuilder builder;
clone(builder, t->d->m_extMetaObject, t->d->m_baseMetaObject, m_baseMetaObject);
+ builder.setFlags(QMetaObjectBuilder::DynamicMetaObject);
QMetaObject *mmo = builder.toMetaObject();
mmo->d.superdata = m_baseMetaObject;
if (!m_metaObjects.isEmpty())
mo = m_metaObjects.first().metaObject;
for (int ii = 0; !m_containsRevisionedAttributes && ii < mo->propertyCount(); ++ii) {
- if (mo->property(ii).revision() != 0)
+ if (isPropertyRevisioned(mo, ii))
m_containsRevisionedAttributes = true;
}
lock.unlock();
}
+void QDeclarativeTypePrivate::initEnums() const
+{
+ if (m_isEnumSetup) return;
+
+ init();
+
+ QWriteLocker lock(metaTypeDataLock());
+ if (m_isEnumSetup) return;
+
+ const QMetaObject *metaObject = m_baseMetaObject;
+ for (int ii = 0; ii < metaObject->enumeratorCount(); ++ii) {
+
+ QMetaEnum e = metaObject->enumerator(ii);
+
+ for (int jj = 0; jj < e.keyCount(); ++jj)
+ m_enums.insert(QString::fromUtf8(e.key(jj)), e.value(jj));
+ }
+
+ m_isEnumSetup = true;
+}
+
QByteArray QDeclarativeType::typeName() const
{
if (d->m_baseMetaObject)
return QByteArray();
}
-QByteArray QDeclarativeType::qmlTypeName() const
+const QString &QDeclarativeType::elementName() const
+{
+ if (d->m_elementName.isEmpty()) {
+ QString n = qmlTypeName();
+ int idx = n.lastIndexOf(QLatin1Char('/'));
+ d->m_elementName = n.mid(idx + 1);
+ }
+ return d->m_elementName;
+}
+
+const QString &QDeclarativeType::qmlTypeName() const
{
return d->m_name;
}
return d->m_index;
}
+int QDeclarativeType::enumValue(const QHashedStringRef &name) const
+{
+ d->initEnums();
+
+ int *rv = d->m_enums.value(name);
+ return rv?*rv:-1;
+}
+
+int QDeclarativeType::enumValue(const QHashedV8String &name) const
+{
+ d->initEnums();
+
+ int *rv = d->m_enums.value(name);
+ return rv?*rv:-1;
+}
+
+QDeclarativeTypeModule::QDeclarativeTypeModule()
+: d(new QDeclarativeTypeModulePrivate)
+{
+}
+
+QDeclarativeTypeModule::~QDeclarativeTypeModule()
+{
+ delete d; d = 0;
+}
+
+QString QDeclarativeTypeModule::module() const
+{
+ return d->uri.uri;
+}
+
+int QDeclarativeTypeModule::majorVersion() const
+{
+ return d->uri.majorVersion;
+}
+
+int QDeclarativeTypeModule::minimumMinorVersion() const
+{
+ return d->minMinorVersion;
+}
+
+int QDeclarativeTypeModule::maximumMinorVersion() const
+{
+ return d->maxMinorVersion;
+}
+
+void QDeclarativeTypeModulePrivate::add(QDeclarativeType *type)
+{
+ types << type;
+
+ minMinorVersion = qMin(minMinorVersion, type->minorVersion());
+ maxMinorVersion = qMax(maxMinorVersion, type->minorVersion());
+
+ QList<QDeclarativeType *> &list = typeHash[type->elementName()];
+ for (int ii = 0; ii < list.count(); ++ii) {
+ if (list.at(ii)->minorVersion() < type->minorVersion()) {
+ list.insert(ii, type);
+ return;
+ }
+ }
+ list.append(type);
+}
+
+QList<QDeclarativeType *> QDeclarativeTypeModule::types()
+{
+ QList<QDeclarativeType *> rv;
+ QReadLocker lock(metaTypeDataLock());
+ rv = d->types;
+ return rv;
+}
+
+QList<QDeclarativeType *> QDeclarativeTypeModule::type(const QString &name)
+{
+ QReadLocker lock(metaTypeDataLock());
+ QList<QDeclarativeType *> rv;
+ for (int ii = 0; ii < d->types.count(); ++ii) {
+ if (d->types.at(ii)->elementName() == name)
+ rv << d->types.at(ii);
+ }
+ return rv;
+}
+
+QDeclarativeType *QDeclarativeTypeModule::type(const QHashedStringRef &name, int minor)
+{
+ QReadLocker lock(metaTypeDataLock());
+
+ QList<QDeclarativeType *> *types = d->typeHash.value(name);
+ if (!types) return 0;
+
+ for (int ii = 0; ii < types->count(); ++ii)
+ if (types->at(ii)->minorVersion() <= minor)
+ return types->at(ii);
+
+ return 0;
+}
+
+QDeclarativeType *QDeclarativeTypeModule::type(const QHashedV8String &name, int minor)
+{
+ QReadLocker lock(metaTypeDataLock());
+
+ QList<QDeclarativeType *> *types = d->typeHash.value(name);
+ if (!types) return 0;
+
+ for (int ii = 0; ii < types->count(); ++ii)
+ if (types->at(ii)->minorVersion() <= minor)
+ return types->at(ii);
+
+ return 0;
+}
+
+
+QDeclarativeTypeModuleVersion::QDeclarativeTypeModuleVersion()
+: m_module(0), m_minor(0)
+{
+}
+
+QDeclarativeTypeModuleVersion::QDeclarativeTypeModuleVersion(QDeclarativeTypeModule *module, int minor)
+: m_module(module), m_minor(minor)
+{
+ Q_ASSERT(m_module);
+ Q_ASSERT(m_minor >= 0);
+}
+
+QDeclarativeTypeModuleVersion::QDeclarativeTypeModuleVersion(const QDeclarativeTypeModuleVersion &o)
+: m_module(o.m_module), m_minor(o.m_minor)
+{
+}
+
+QDeclarativeTypeModuleVersion &QDeclarativeTypeModuleVersion::operator=(const QDeclarativeTypeModuleVersion &o)
+{
+ m_module = o.m_module;
+ m_minor = o.m_minor;
+ return *this;
+}
+
+QDeclarativeTypeModule *QDeclarativeTypeModuleVersion::module() const
+{
+ return m_module;
+}
+
+int QDeclarativeTypeModuleVersion::minorVersion() const
+{
+ return m_minor;
+}
+
+QDeclarativeType *QDeclarativeTypeModuleVersion::type(const QHashedStringRef &name) const
+{
+ if (m_module) return m_module->type(name, m_minor);
+ else return 0;
+}
+
+QDeclarativeType *QDeclarativeTypeModuleVersion::type(const QHashedV8String &name) const
+{
+ if (m_module) return m_module->type(name, m_minor);
+ else return 0;
+}
+
+
int registerAutoParentFunction(QDeclarativePrivate::RegisterAutoParent &autoparent)
{
QWriteLocker lock(metaTypeDataLock());
if (type.listId) data->lists.setBit(type.listId, true);
if (type.uri) {
- QByteArray mod(type.uri);
- QDeclarativeMetaTypeData::ModuleInfoHash::Iterator it = data->modules.find(mod);
- if (it == data->modules.end()) {
- // New module
- data->modules.insert(mod, QDeclarativeMetaTypeData::ModuleInfo(type.versionMajor,type.versionMinor));
- } else if ((*it).vmajor_max < type.versionMajor || ((*it).vmajor_max == type.versionMajor && (*it).vminor_max < type.versionMinor)) {
- // Newer module
- data->modules.insert(mod, QDeclarativeMetaTypeData::ModuleInfo((*it).vmajor_min, (*it).vminor_min, type.versionMajor, type.versionMinor));
- } else if ((*it).vmajor_min > type.versionMajor || ((*it).vmajor_min == type.versionMajor && (*it).vminor_min > type.versionMinor)) {
- // Older module
- data->modules.insert(mod, QDeclarativeMetaTypeData::ModuleInfo(type.versionMajor, type.versionMinor, (*it).vmajor_min, (*it).vminor_min));
+ QString mod = QString::fromUtf8(type.uri);
+
+ QDeclarativeMetaTypeData::VersionedUri versionedUri(mod, type.versionMajor);
+ QDeclarativeTypeModule *module = data->uriToModule.value(versionedUri);
+ if (!module) {
+ module = new QDeclarativeTypeModule;
+ module->d->uri = versionedUri;
+ data->uriToModule.insert(versionedUri, module);
}
+ module->d->add(dtype);
}
return index;
QWriteLocker lock(metaTypeDataLock());
QDeclarativeMetaTypeData *data = metaTypeData();
- QByteArray uri(api.uri);
+ QString uri = QString::fromUtf8(api.uri);
QDeclarativeMetaType::ModuleApi import;
import.major = api.versionMajor;
import.minor = api.versionMinor;
}
/*
+ Returns true if a module \a uri of any version is installed.
+*/
+bool QDeclarativeMetaType::isAnyModule(const QString &uri)
+{
+ QReadLocker lock(metaTypeDataLock());
+ QDeclarativeMetaTypeData *data = metaTypeData();
+
+ for (QDeclarativeMetaTypeData::TypeModules::ConstIterator iter = data->uriToModule.begin();
+ iter != data->uriToModule.end(); ++iter) {
+ if ((*iter)->module() == uri)
+ return true;
+ }
+
+ return false;
+}
+
+/*
Returns true if any type or API has been registered for the given \a module with at least
versionMajor.versionMinor, or if types have been registered for \a module with at most
versionMajor.versionMinor.
So if only 4.7 and 4.9 have been registered, 4.7,4.8, and 4.9 are valid, but not 4.6 nor 4.10.
-
- Passing -1 for both \a versionMajor \a versionMinor will return true if any version is installed.
*/
-bool QDeclarativeMetaType::isModule(const QByteArray &module, int versionMajor, int versionMinor)
+bool QDeclarativeMetaType::isModule(const QString &module, int versionMajor, int versionMinor)
{
+ Q_ASSERT(versionMajor >= 0 && versionMinor >= 0);
+ QReadLocker lock(metaTypeDataLock());
+
QDeclarativeMetaTypeData *data = metaTypeData();
// first, check Types
- QDeclarativeMetaTypeData::ModuleInfoHash::Iterator it = data->modules.find(module);
- if (it != data->modules.end()
- && ((versionMajor<0 && versionMinor<0) ||
- (((*it).vmajor_max > versionMajor ||
- ((*it).vmajor_max == versionMajor && (*it).vminor_max >= versionMinor))
- && ((*it).vmajor_min < versionMajor ||
- ((*it).vmajor_min == versionMajor && (*it).vminor_min <= versionMinor))))) {
+ QDeclarativeTypeModule *tm =
+ data->uriToModule.value(QDeclarativeMetaTypeData::VersionedUri(module, versionMajor));
+ if (tm && tm->minimumMinorVersion() <= versionMinor && tm->maximumMinorVersion() >= versionMinor)
return true;
- }
// then, check ModuleApis
foreach (const QDeclarativeMetaType::ModuleApi &mApi, data->moduleApis.value(module).moduleApis) {
- if ((versionMajor<0 && versionMinor<0)
- || (mApi.major == versionMajor && mApi.minor == versionMinor)) {
+ if (mApi.major == versionMajor && mApi.minor == versionMinor) // XXX is this correct?
return true;
- }
}
return false;
}
+QDeclarativeTypeModule *QDeclarativeMetaType::typeModule(const QString &uri, int majorVersion)
+{
+ QReadLocker lock(metaTypeDataLock());
+ QDeclarativeMetaTypeData *data = metaTypeData();
+ return data->uriToModule.value(QDeclarativeMetaTypeData::VersionedUri(uri, majorVersion));
+}
+
QList<QDeclarativePrivate::AutoParentFunction> QDeclarativeMetaType::parentFunctions()
{
QReadLocker lock(metaTypeDataLock());
}
QDeclarativeMetaType::ModuleApi
-QDeclarativeMetaType::moduleApi(const QByteArray &uri, int versionMajor, int versionMinor)
+QDeclarativeMetaType::moduleApi(const QString &uri, int versionMajor, int versionMinor)
{
QReadLocker lock(metaTypeDataLock());
QDeclarativeMetaTypeData *data = metaTypeData();
return ModuleApi();
}
+QHash<QString, QList<QDeclarativeMetaType::ModuleApi> > QDeclarativeMetaType::moduleApis()
+{
+ QReadLocker lock(metaTypeDataLock());
+ QDeclarativeMetaTypeData *data = metaTypeData();
+
+ QHash<QString, QList<ModuleApi> > moduleApis;
+ QHashIterator<QString, QDeclarativeMetaTypeData::ModuleApiList> it(data->moduleApis);
+ while (it.hasNext()) {
+ it.next();
+ moduleApis[it.key()] = it.value().moduleApis;
+ }
+
+ return moduleApis;
+}
+
QObject *QDeclarativeMetaType::toQObject(const QVariant &v, bool *ok)
{
if (!isQObject(v.userType())) {
Returns the type (if any) of URI-qualified named \a name in version specified
by \a version_major and \a version_minor.
*/
-QDeclarativeType *QDeclarativeMetaType::qmlType(const QByteArray &name, int version_major, int version_minor)
+QDeclarativeType *QDeclarativeMetaType::qmlType(const QString &name, int version_major, int version_minor)
{
+ Q_ASSERT(version_major >= 0 && version_minor >= 0);
QReadLocker lock(metaTypeDataLock());
QDeclarativeMetaTypeData *data = metaTypeData();
- QList<QDeclarativeType*> types = data->nameToType.values(name);
- foreach (QDeclarativeType *t, types) {
+ QDeclarativeMetaTypeData::Names::ConstIterator it = data->nameToType.find(name);
+ while (it != data->nameToType.end()) {
// XXX version_major<0 just a kludge for QDeclarativePropertyPrivate::initProperty
- if (version_major<0 || t->availableInVersion(version_major,version_minor))
- return t;
+ if (it.key() == name && (version_major<0 || (*it)->availableInVersion(version_major,version_minor)))
+ return (*it);
+ ++it;
}
+
return 0;
}
by \a version_major and \a version_minor in module specified by \a uri. Returns null if no
type is registered.
*/
-QDeclarativeType *QDeclarativeMetaType::qmlType(const QMetaObject *metaObject, const QByteArray &module, int version_major, int version_minor)
+QDeclarativeType *QDeclarativeMetaType::qmlType(const QMetaObject *metaObject, const QString &module, int version_major, int version_minor)
{
+ Q_ASSERT(version_major >= 0 && version_minor >= 0);
QReadLocker lock(metaTypeDataLock());
QDeclarativeMetaTypeData *data = metaTypeData();
/*!
Returns the list of registered QML type names.
*/
-QList<QByteArray> QDeclarativeMetaType::qmlTypeNames()
+QList<QString> QDeclarativeMetaType::qmlTypeNames()
{
QReadLocker lock(metaTypeDataLock());
QDeclarativeMetaTypeData *data = metaTypeData();
return data->nameToType.values();
}
-QT_END_NAMESPACE
-
-#include <QtGui/qfont.h>
-#include <QtGui/qpixmap.h>
-#include <QtGui/qbrush.h>
-#include <QtGui/qcolor.h>
-#include <QtGui/qpalette.h>
-#include <QtGui/qicon.h>
-#include <QtGui/qimage.h>
-#include <QtGui/qpolygon.h>
-#include <QtGui/qregion.h>
-#include <QtGui/qbitmap.h>
-#include <QtGui/qcursor.h>
-#include <QtGui/qsizepolicy.h>
-#include <QtGui/qkeysequence.h>
-#include <QtGui/qpen.h>
-
-//#include <QtGui/qtextlength.h>
-#include <QtGui/qtextformat.h>
-#include <QtGui/qmatrix.h>
-#include <QtGui/qtransform.h>
-#include <QtGui/qmatrix4x4.h>
-#include <QtGui/qvector2d.h>
-#include <QtGui/qvector3d.h>
-#include <QtGui/qvector4d.h>
-#include <QtGui/qquaternion.h>
-
-Q_DECLARE_METATYPE(QScriptValue);
-
-QT_BEGIN_NAMESPACE
-
-bool QDeclarativeMetaType::canCopy(int type)
-{
- switch(type) {
- case QMetaType::VoidStar:
- case QMetaType::QObjectStar:
- case QMetaType::QWidgetStar:
- case QMetaType::Long:
- case QMetaType::Int:
- case QMetaType::Short:
- case QMetaType::Char:
- case QMetaType::ULong:
- case QMetaType::UInt:
- case QMetaType::LongLong:
- case QMetaType::ULongLong:
- case QMetaType::UShort:
- case QMetaType::UChar:
- case QMetaType::Bool:
- case QMetaType::Float:
- case QMetaType::Double:
- case QMetaType::QChar:
- case QMetaType::QVariantMap:
- case QMetaType::QVariantHash:
- case QMetaType::QVariantList:
- case QMetaType::QByteArray:
- case QMetaType::QString:
- case QMetaType::QStringList:
- case QMetaType::QBitArray:
- case QMetaType::QDate:
- case QMetaType::QTime:
- case QMetaType::QDateTime:
- case QMetaType::QUrl:
- case QMetaType::QLocale:
- case QMetaType::QRect:
- case QMetaType::QRectF:
- case QMetaType::QSize:
- case QMetaType::QSizeF:
- case QMetaType::QLine:
- case QMetaType::QLineF:
- case QMetaType::QPoint:
- case QMetaType::QPointF:
- case QMetaType::QVector3D:
-#ifndef QT_NO_REGEXP
- case QMetaType::QRegExp:
-#endif
- case QMetaType::Void:
-#ifdef QT3_SUPPORT
- case QMetaType::QColorGroup:
-#endif
- case QMetaType::QFont:
- case QMetaType::QPixmap:
- case QMetaType::QBrush:
- case QMetaType::QColor:
- case QMetaType::QPalette:
- case QMetaType::QIcon:
- case QMetaType::QImage:
- case QMetaType::QPolygon:
- case QMetaType::QRegion:
- case QMetaType::QBitmap:
-#ifndef QT_NO_CURSOR
- case QMetaType::QCursor:
-#endif
- case QMetaType::QSizePolicy:
- case QMetaType::QKeySequence:
- case QMetaType::QPen:
- case QMetaType::QTextLength:
- case QMetaType::QTextFormat:
- case QMetaType::QMatrix:
- case QMetaType::QTransform:
- case QMetaType::QMatrix4x4:
- case QMetaType::QVector2D:
- case QMetaType::QVector4D:
- case QMetaType::QQuaternion:
- return true;
-
- default:
- if (type == qMetaTypeId<QVariant>() ||
- type == qMetaTypeId<QScriptValue>() ||
- typeCategory(type) != Unknown) {
- return true;
- }
- break;
+int QDeclarativeMetaType::QQuickAnchorLineMetaTypeId()
+{
+ static int id = 0;
+ if (!id) {
+ id = QMetaType::type("QQuickAnchorLine");
}
-
- return false;
+ return id;
}
-/*!
- Copies \a copy into \a data, assuming they both are of type \a type. If
- \a copy is zero, a default type is copied. Returns true if the copy was
- successful and false if not.
-
- \note This should move into QMetaType once complete
-
-*/
-bool QDeclarativeMetaType::copy(int type, void *data, const void *copy)
-{
- if (copy) {
- switch(type) {
- case QMetaType::VoidStar:
- case QMetaType::QObjectStar:
- case QMetaType::QWidgetStar:
- *static_cast<void **>(data) = *static_cast<void* const *>(copy);
- return true;
- case QMetaType::Long:
- *static_cast<long *>(data) = *static_cast<const long*>(copy);
- return true;
- case QMetaType::Int:
- *static_cast<int *>(data) = *static_cast<const int*>(copy);
- return true;
- case QMetaType::Short:
- *static_cast<short *>(data) = *static_cast<const short*>(copy);
- return true;
- case QMetaType::Char:
- *static_cast<char *>(data) = *static_cast<const char*>(copy);
- return true;
- case QMetaType::ULong:
- *static_cast<ulong *>(data) = *static_cast<const ulong*>(copy);
- return true;
- case QMetaType::UInt:
- *static_cast<uint *>(data) = *static_cast<const uint*>(copy);
- return true;
- case QMetaType::LongLong:
- *static_cast<qlonglong *>(data) = *static_cast<const qlonglong*>(copy);
- return true;
- case QMetaType::ULongLong:
- *static_cast<qulonglong *>(data) = *static_cast<const qulonglong*>(copy);
- return true;
- case QMetaType::UShort:
- *static_cast<ushort *>(data) = *static_cast<const ushort*>(copy);
- return true;
- case QMetaType::UChar:
- *static_cast<uchar *>(data) = *static_cast<const uchar*>(copy);
- return true;
- case QMetaType::Bool:
- *static_cast<bool *>(data) = *static_cast<const bool*>(copy);
- return true;
- case QMetaType::Float:
- *static_cast<float *>(data) = *static_cast<const float*>(copy);
- return true;
- case QMetaType::Double:
- *static_cast<double *>(data) = *static_cast<const double*>(copy);
- return true;
- case QMetaType::QChar:
- *static_cast<NS(QChar) *>(data) = *static_cast<const NS(QChar)*>(copy);
- return true;
- case QMetaType::QVariantMap:
- *static_cast<NS(QVariantMap) *>(data) = *static_cast<const NS(QVariantMap)*>(copy);
- return true;
- case QMetaType::QVariantHash:
- *static_cast<NS(QVariantHash) *>(data) = *static_cast<const NS(QVariantHash)*>(copy);
- return true;
- case QMetaType::QVariantList:
- *static_cast<NS(QVariantList) *>(data) = *static_cast<const NS(QVariantList)*>(copy);
- return true;
- case QMetaType::QByteArray:
- *static_cast<NS(QByteArray) *>(data) = *static_cast<const NS(QByteArray)*>(copy);
- return true;
- case QMetaType::QString:
- *static_cast<NS(QString) *>(data) = *static_cast<const NS(QString)*>(copy);
- return true;
- case QMetaType::QStringList:
- *static_cast<NS(QStringList) *>(data) = *static_cast<const NS(QStringList)*>(copy);
- return true;
- case QMetaType::QBitArray:
- *static_cast<NS(QBitArray) *>(data) = *static_cast<const NS(QBitArray)*>(copy);
- return true;
- case QMetaType::QDate:
- *static_cast<NS(QDate) *>(data) = *static_cast<const NS(QDate)*>(copy);
- return true;
- case QMetaType::QTime:
- *static_cast<NS(QTime) *>(data) = *static_cast<const NS(QTime)*>(copy);
- return true;
- case QMetaType::QDateTime:
- *static_cast<NS(QDateTime) *>(data) = *static_cast<const NS(QDateTime)*>(copy);
- return true;
- case QMetaType::QUrl:
- *static_cast<NS(QUrl) *>(data) = *static_cast<const NS(QUrl)*>(copy);
- return true;
- case QMetaType::QLocale:
- *static_cast<NS(QLocale) *>(data) = *static_cast<const NS(QLocale)*>(copy);
- return true;
- case QMetaType::QRect:
- *static_cast<NS(QRect) *>(data) = *static_cast<const NS(QRect)*>(copy);
- return true;
- case QMetaType::QRectF:
- *static_cast<NS(QRectF) *>(data) = *static_cast<const NS(QRectF)*>(copy);
- return true;
- case QMetaType::QSize:
- *static_cast<NS(QSize) *>(data) = *static_cast<const NS(QSize)*>(copy);
- return true;
- case QMetaType::QSizeF:
- *static_cast<NS(QSizeF) *>(data) = *static_cast<const NS(QSizeF)*>(copy);
- return true;
- case QMetaType::QLine:
- *static_cast<NS(QLine) *>(data) = *static_cast<const NS(QLine)*>(copy);
- return true;
- case QMetaType::QLineF:
- *static_cast<NS(QLineF) *>(data) = *static_cast<const NS(QLineF)*>(copy);
- return true;
- case QMetaType::QPoint:
- *static_cast<NS(QPoint) *>(data) = *static_cast<const NS(QPoint)*>(copy);
- return true;
- case QMetaType::QPointF:
- *static_cast<NS(QPointF) *>(data) = *static_cast<const NS(QPointF)*>(copy);
- return true;
- case QMetaType::QVector3D:
- *static_cast<NS(QVector3D) *>(data) = *static_cast<const NS(QVector3D)*>(copy);
- return true;
-#ifndef QT_NO_REGEXP
- case QMetaType::QRegExp:
- *static_cast<NS(QRegExp) *>(data) = *static_cast<const NS(QRegExp)*>(copy);
- return true;
-#endif
- case QMetaType::Void:
- return true;
-
-
-#ifdef QT3_SUPPORT
- case QMetaType::QColorGroup:
- *static_cast<NS(QColorGroup) *>(data) = *static_cast<const NS(QColorGroup)*>(copy);
- return true;
-#endif
+QDeclarativeMetaType::CompareFunction QDeclarativeMetaType::anchorLineCompareFunction = 0;
- case QMetaType::QFont:
- *static_cast<NS(QFont) *>(data) = *static_cast<const NS(QFont)*>(copy);
- return true;
- case QMetaType::QPixmap:
- *static_cast<NS(QPixmap) *>(data) = *static_cast<const NS(QPixmap)*>(copy);
- return true;
- case QMetaType::QBrush:
- *static_cast<NS(QBrush) *>(data) = *static_cast<const NS(QBrush)*>(copy);
- return true;
- case QMetaType::QColor:
- *static_cast<NS(QColor) *>(data) = *static_cast<const NS(QColor)*>(copy);
- return true;
- case QMetaType::QPalette:
- *static_cast<NS(QPalette) *>(data) = *static_cast<const NS(QPalette)*>(copy);
- return true;
- case QMetaType::QIcon:
- *static_cast<NS(QIcon) *>(data) = *static_cast<const NS(QIcon)*>(copy);
- return true;
- case QMetaType::QImage:
- *static_cast<NS(QImage) *>(data) = *static_cast<const NS(QImage)*>(copy);
- return true;
- case QMetaType::QPolygon:
- *static_cast<NS(QPolygon) *>(data) = *static_cast<const NS(QPolygon)*>(copy);
- return true;
- case QMetaType::QRegion:
- *static_cast<NS(QRegion) *>(data) = *static_cast<const NS(QRegion)*>(copy);
- return true;
- case QMetaType::QBitmap:
- *static_cast<NS(QBitmap) *>(data) = *static_cast<const NS(QBitmap)*>(copy);
- return true;
-#ifndef QT_NO_CURSOR
- case QMetaType::QCursor:
- *static_cast<NS(QCursor) *>(data) = *static_cast<const NS(QCursor)*>(copy);
- return true;
-#endif
- case QMetaType::QSizePolicy:
- *static_cast<NS(QSizePolicy) *>(data) = *static_cast<const NS(QSizePolicy)*>(copy);
- return true;
- case QMetaType::QKeySequence:
- *static_cast<NS(QKeySequence) *>(data) = *static_cast<const NS(QKeySequence)*>(copy);
- return true;
- case QMetaType::QPen:
- *static_cast<NS(QPen) *>(data) = *static_cast<const NS(QPen)*>(copy);
- return true;
- case QMetaType::QTextLength:
- *static_cast<NS(QTextLength) *>(data) = *static_cast<const NS(QTextLength)*>(copy);
- return true;
- case QMetaType::QTextFormat:
- *static_cast<NS(QTextFormat) *>(data) = *static_cast<const NS(QTextFormat)*>(copy);
- return true;
- case QMetaType::QMatrix:
- *static_cast<NS(QMatrix) *>(data) = *static_cast<const NS(QMatrix)*>(copy);
- return true;
- case QMetaType::QTransform:
- *static_cast<NS(QTransform) *>(data) = *static_cast<const NS(QTransform)*>(copy);
- return true;
- case QMetaType::QMatrix4x4:
- *static_cast<NS(QMatrix4x4) *>(data) = *static_cast<const NS(QMatrix4x4)*>(copy);
- return true;
- case QMetaType::QVector2D:
- *static_cast<NS(QVector2D) *>(data) = *static_cast<const NS(QVector2D)*>(copy);
- return true;
- case QMetaType::QVector4D:
- *static_cast<NS(QVector4D) *>(data) = *static_cast<const NS(QVector4D)*>(copy);
- return true;
- case QMetaType::QQuaternion:
- *static_cast<NS(QQuaternion) *>(data) = *static_cast<const NS(QQuaternion)*>(copy);
- return true;
-
- default:
- if (type == qMetaTypeId<QVariant>()) {
- *static_cast<NS(QVariant) *>(data) = *static_cast<const NS(QVariant)*>(copy);
- return true;
- } else if (type == qMetaTypeId<QScriptValue>()) {
- *static_cast<NS(QScriptValue) *>(data) = *static_cast<const NS(QScriptValue)*>(copy);
- return true;
- } else if (typeCategory(type) != Unknown) {
- *static_cast<void **>(data) = *static_cast<void* const *>(copy);
- return true;
- }
- break;
- }
- } else {
- switch(type) {
- case QMetaType::VoidStar:
- case QMetaType::QObjectStar:
- case QMetaType::QWidgetStar:
- *static_cast<void **>(data) = 0;
- return true;
- case QMetaType::Long:
- *static_cast<long *>(data) = long(0);
- return true;
- case QMetaType::Int:
- *static_cast<int *>(data) = int(0);
- return true;
- case QMetaType::Short:
- *static_cast<short *>(data) = short(0);
- return true;
- case QMetaType::Char:
- *static_cast<char *>(data) = char(0);
- return true;
- case QMetaType::ULong:
- *static_cast<ulong *>(data) = ulong(0);
- return true;
- case QMetaType::UInt:
- *static_cast<uint *>(data) = uint(0);
- return true;
- case QMetaType::LongLong:
- *static_cast<qlonglong *>(data) = qlonglong(0);
- return true;
- case QMetaType::ULongLong:
- *static_cast<qulonglong *>(data) = qulonglong(0);
- return true;
- case QMetaType::UShort:
- *static_cast<ushort *>(data) = ushort(0);
- return true;
- case QMetaType::UChar:
- *static_cast<uchar *>(data) = uchar(0);
- return true;
- case QMetaType::Bool:
- *static_cast<bool *>(data) = bool(false);
- return true;
- case QMetaType::Float:
- *static_cast<float *>(data) = float(0);
- return true;
- case QMetaType::Double:
- *static_cast<double *>(data) = double(0);
- return true;
- case QMetaType::QChar:
- *static_cast<NS(QChar) *>(data) = NS(QChar)();
- return true;
- case QMetaType::QVariantMap:
- *static_cast<NS(QVariantMap) *>(data) = NS(QVariantMap)();
- return true;
- case QMetaType::QVariantHash:
- *static_cast<NS(QVariantHash) *>(data) = NS(QVariantHash)();
- return true;
- case QMetaType::QVariantList:
- *static_cast<NS(QVariantList) *>(data) = NS(QVariantList)();
- return true;
- case QMetaType::QByteArray:
- *static_cast<NS(QByteArray) *>(data) = NS(QByteArray)();
- return true;
- case QMetaType::QString:
- *static_cast<NS(QString) *>(data) = NS(QString)();
- return true;
- case QMetaType::QStringList:
- *static_cast<NS(QStringList) *>(data) = NS(QStringList)();
- return true;
- case QMetaType::QBitArray:
- *static_cast<NS(QBitArray) *>(data) = NS(QBitArray)();
- return true;
- case QMetaType::QDate:
- *static_cast<NS(QDate) *>(data) = NS(QDate)();
- return true;
- case QMetaType::QTime:
- *static_cast<NS(QTime) *>(data) = NS(QTime)();
- return true;
- case QMetaType::QDateTime:
- *static_cast<NS(QDateTime) *>(data) = NS(QDateTime)();
- return true;
- case QMetaType::QUrl:
- *static_cast<NS(QUrl) *>(data) = NS(QUrl)();
- return true;
- case QMetaType::QLocale:
- *static_cast<NS(QLocale) *>(data) = NS(QLocale)();
- return true;
- case QMetaType::QRect:
- *static_cast<NS(QRect) *>(data) = NS(QRect)();
- return true;
- case QMetaType::QRectF:
- *static_cast<NS(QRectF) *>(data) = NS(QRectF)();
- return true;
- case QMetaType::QSize:
- *static_cast<NS(QSize) *>(data) = NS(QSize)();
- return true;
- case QMetaType::QSizeF:
- *static_cast<NS(QSizeF) *>(data) = NS(QSizeF)();
- return true;
- case QMetaType::QLine:
- *static_cast<NS(QLine) *>(data) = NS(QLine)();
- return true;
- case QMetaType::QLineF:
- *static_cast<NS(QLineF) *>(data) = NS(QLineF)();
- return true;
- case QMetaType::QPoint:
- *static_cast<NS(QPoint) *>(data) = NS(QPoint)();
- return true;
- case QMetaType::QPointF:
- *static_cast<NS(QPointF) *>(data) = NS(QPointF)();
- return true;
- case QMetaType::QVector3D:
- *static_cast<NS(QVector3D) *>(data) = NS(QVector3D)();
- return true;
-#ifndef QT_NO_REGEXP
- case QMetaType::QRegExp:
- *static_cast<NS(QRegExp) *>(data) = NS(QRegExp)();
- return true;
-#endif
- case QMetaType::Void:
- return true;
-
-#ifdef QT3_SUPPORT
- case QMetaType::QColorGroup:
- *static_cast<NS(QColorGroup) *>(data) = NS(QColorGroup)();
- return true;
-#endif
-
- case QMetaType::QFont:
- *static_cast<NS(QFont) *>(data) = NS(QFont)();
- return true;
- case QMetaType::QPixmap:
- *static_cast<NS(QPixmap) *>(data) = NS(QPixmap)();
- return true;
- case QMetaType::QBrush:
- *static_cast<NS(QBrush) *>(data) = NS(QBrush)();
- return true;
- case QMetaType::QColor:
- *static_cast<NS(QColor) *>(data) = NS(QColor)();
- return true;
- case QMetaType::QPalette:
- *static_cast<NS(QPalette) *>(data) = NS(QPalette)();
- return true;
- case QMetaType::QIcon:
- *static_cast<NS(QIcon) *>(data) = NS(QIcon)();
- return true;
- case QMetaType::QImage:
- *static_cast<NS(QImage) *>(data) = NS(QImage)();
- return true;
- case QMetaType::QPolygon:
- *static_cast<NS(QPolygon) *>(data) = NS(QPolygon)();
- return true;
- case QMetaType::QRegion:
- *static_cast<NS(QRegion) *>(data) = NS(QRegion)();
- return true;
- case QMetaType::QBitmap:
- *static_cast<NS(QBitmap) *>(data) = NS(QBitmap)();
- return true;
-#ifndef QT_NO_CURSOR
- case QMetaType::QCursor:
- *static_cast<NS(QCursor) *>(data) = NS(QCursor)();
- return true;
-#endif
- case QMetaType::QSizePolicy:
- *static_cast<NS(QSizePolicy) *>(data) = NS(QSizePolicy)();
- return true;
- case QMetaType::QKeySequence:
- *static_cast<NS(QKeySequence) *>(data) = NS(QKeySequence)();
- return true;
- case QMetaType::QPen:
- *static_cast<NS(QPen) *>(data) = NS(QPen)();
- return true;
- case QMetaType::QTextLength:
- *static_cast<NS(QTextLength) *>(data) = NS(QTextLength)();
- return true;
- case QMetaType::QTextFormat:
- *static_cast<NS(QTextFormat) *>(data) = NS(QTextFormat)();
- return true;
- case QMetaType::QMatrix:
- *static_cast<NS(QMatrix) *>(data) = NS(QMatrix)();
- return true;
- case QMetaType::QTransform:
- *static_cast<NS(QTransform) *>(data) = NS(QTransform)();
- return true;
- case QMetaType::QMatrix4x4:
- *static_cast<NS(QMatrix4x4) *>(data) = NS(QMatrix4x4)();
- return true;
- case QMetaType::QVector2D:
- *static_cast<NS(QVector2D) *>(data) = NS(QVector2D)();
- return true;
- case QMetaType::QVector4D:
- *static_cast<NS(QVector4D) *>(data) = NS(QVector4D)();
- return true;
- case QMetaType::QQuaternion:
- *static_cast<NS(QQuaternion) *>(data) = NS(QQuaternion)();
- return true;
- default:
- if (type == qMetaTypeId<QVariant>()) {
- *static_cast<NS(QVariant) *>(data) = NS(QVariant)();
- return true;
- } else if (type == qMetaTypeId<QScriptValue>()) {
- *static_cast<NS(QScriptValue) *>(data) = NS(QScriptValue)();
- return true;
- } else if (typeCategory(type) != Unknown) {
- *static_cast<void **>(data) = 0;
- return true;
- }
- break;
- }
- }
+void QDeclarativeMetaType::setQQuickAnchorLineCompareFunction(CompareFunction fun)
+{
+ anchorLineCompareFunction = fun;
+}
- return false;
+bool QDeclarativeMetaType::QQuickAnchorLineCompare(const void *p1, const void *p2)
+{
+ Q_ASSERT(anchorLineCompareFunction != 0);
+ return anchorLineCompareFunction(p1, p2);
}
QT_END_NAMESPACE
projects / profile / ivi / qtdeclarative.git / blobdiff