bool QQmlPropertyCacheCreator::createMetaObject(int objectIndex, const QmlIR::Object *obj, QQmlPropertyCache *baseTypeCache)
{
- QQmlPropertyCache *cache = baseTypeCache->copyAndReserve(QQmlEnginePrivate::get(enginePrivate),
- obj->propertyCount(),
+ QQmlPropertyCache *cache = baseTypeCache->copyAndReserve(obj->propertyCount(),
obj->functionCount() + obj->propertyCount() + obj->signalCount(),
obj->signalCount() + obj->propertyCount());
propertyCaches[objectIndex] = cache;
return rv;
} else {
QQmlPropertyCache *super = cache(mo->superClass());
- QQmlPropertyCache *rv = super->copyAndAppend(q, mo);
+ QQmlPropertyCache *rv = super->copyAndAppend(mo);
propertyCache.insert(mo, rv);
return rv;
}
QQmlOpenMetaObject *omo = *it;
*static_cast<QMetaObject *>(omo) = *d->mem;
if (d->cache)
- d->cache->update(d->engine, omo);
+ d->cache->update(omo);
++it;
}
return fastFlagsForProperty(p) | flagsForPropertyType(p.userType(), engine);
}
-void QQmlPropertyData::lazyLoad(const QMetaProperty &p, QQmlEngine *engine)
+void QQmlPropertyData::lazyLoad(const QMetaProperty &p)
{
- Q_UNUSED(engine);
-
coreIndex = p.propertyIndex();
notifyIndex = QMetaObjectPrivate::signalIndex(p.notifySignal());
Q_ASSERT(p.revision() <= Q_INT16_MAX);
Q_ASSERT(engine);
Q_ASSERT(metaObject);
- update(engine, metaObject);
+ update(metaObject);
}
QQmlPropertyCache::~QQmlPropertyCache()
void QQmlPropertyCache::destroy()
{
- Q_ASSERT(engine);
delete this;
}
return copy(0);
}
-QQmlPropertyCache *QQmlPropertyCache::copyAndReserve(QQmlEngine *, int propertyCount, int methodCount,
+QQmlPropertyCache *QQmlPropertyCache::copyAndReserve(int propertyCount, int methodCount,
int signalCount)
{
QQmlPropertyCache *rv = copy(propertyCount + methodCount + signalCount);
}
QQmlPropertyCache *
-QQmlPropertyCache::copyAndAppend(QQmlEngine *engine, const QMetaObject *metaObject,
+QQmlPropertyCache::copyAndAppend(const QMetaObject *metaObject,
QQmlPropertyData::Flag propertyFlags,
QQmlPropertyData::Flag methodFlags,
QQmlPropertyData::Flag signalFlags)
{
- return copyAndAppend(engine, metaObject, -1, propertyFlags, methodFlags, signalFlags);
+ return copyAndAppend(metaObject, -1, propertyFlags, methodFlags, signalFlags);
}
QQmlPropertyCache *
-QQmlPropertyCache::copyAndAppend(QQmlEngine *engine, const QMetaObject *metaObject,
+QQmlPropertyCache::copyAndAppend(const QMetaObject *metaObject,
int revision,
QQmlPropertyData::Flag propertyFlags,
QQmlPropertyData::Flag methodFlags,
QMetaObjectPrivate::get(metaObject)->signalCount +
QMetaObjectPrivate::get(metaObject)->propertyCount);
- rv->append(engine, metaObject, revision, propertyFlags, methodFlags, signalFlags);
+ rv->append(metaObject, revision, propertyFlags, methodFlags, signalFlags);
return rv;
}
-void QQmlPropertyCache::append(QQmlEngine *engine, const QMetaObject *metaObject,
+void QQmlPropertyCache::append(const QMetaObject *metaObject,
int revision,
QQmlPropertyData::Flag propertyFlags,
QQmlPropertyData::Flag methodFlags,
QQmlPropertyData *data = &propertyIndexCache[ii - propertyIndexCacheStart];
- data->lazyLoad(p, engine);
+ data->lazyLoad(p);
data->flags |= propertyFlags;
if (!dynamicMetaObject)
data->flags &= ~QQmlPropertyData::NotFullyResolved;
}
-void QQmlPropertyCache::updateRecur(QQmlEngine *engine, const QMetaObject *metaObject)
+void QQmlPropertyCache::updateRecur(const QMetaObject *metaObject)
{
if (!metaObject)
return;
- updateRecur(engine, metaObject->superClass());
+ updateRecur(metaObject->superClass());
- append(engine, metaObject, -1);
+ append(metaObject, -1);
}
-void QQmlPropertyCache::update(QQmlEngine *engine, const QMetaObject *metaObject)
+void QQmlPropertyCache::update(const QMetaObject *metaObject)
{
- Q_ASSERT(engine);
Q_ASSERT(metaObject);
Q_ASSERT(stringCache.isEmpty());
// cached in a parent cache.
stringCache.reserve(pc + mc + sc);
- updateRecur(engine,metaObject);
+ updateRecur(metaObject);
}
/*! \internal
invalidates and updates the PropertyCache if the QMetaObject has changed.
This function is used in the tooling to update dynamic properties.
*/
-void QQmlPropertyCache::invalidate(QQmlEngine *engine, const QMetaObject *metaObject)
+void QQmlPropertyCache::invalidate(const QMetaObject *metaObject)
{
stringCache.clear();
propertyIndexCache.clear();
methodIndexCacheStart = parent()->methodIndexCache.count() + parent()->methodIndexCacheStart;
signalHandlerIndexCacheStart = parent()->signalHandlerIndexCache.count() + parent()->signalHandlerIndexCacheStart;
stringCache.linkAndReserve(parent()->stringCache, reserve);
- append(engine, metaObject, -1);
+ append(metaObject, -1);
} else {
propertyIndexCacheStart = 0;
methodIndexCacheStart = 0;
signalHandlerIndexCacheStart = 0;
- update(engine, metaObject);
+ update(metaObject);
}
}
private:
friend class QQmlPropertyCache;
- void lazyLoad(const QMetaProperty &, QQmlEngine *engine = 0);
+ void lazyLoad(const QMetaProperty &);
void lazyLoad(const QMetaMethod &);
bool notFullyResolved() const { return flags & NotFullyResolved; }
};
QQmlPropertyCache(QQmlEngine *, const QMetaObject *);
virtual ~QQmlPropertyCache();
- void update(QQmlEngine *, const QMetaObject *);
- void invalidate(QQmlEngine *, const QMetaObject *);
+ void update(const QMetaObject *);
+ void invalidate(const QMetaObject *);
QQmlPropertyCache *copy();
- QQmlPropertyCache *copyAndAppend(QQmlEngine *, const QMetaObject *,
+ QQmlPropertyCache *copyAndAppend(const QMetaObject *,
QQmlPropertyData::Flag propertyFlags = QQmlPropertyData::NoFlags,
QQmlPropertyData::Flag methodFlags = QQmlPropertyData::NoFlags,
QQmlPropertyData::Flag signalFlags = QQmlPropertyData::NoFlags);
- QQmlPropertyCache *copyAndAppend(QQmlEngine *, const QMetaObject *, int revision,
+ QQmlPropertyCache *copyAndAppend(const QMetaObject *, int revision,
QQmlPropertyData::Flag propertyFlags = QQmlPropertyData::NoFlags,
QQmlPropertyData::Flag methodFlags = QQmlPropertyData::NoFlags,
QQmlPropertyData::Flag signalFlags = QQmlPropertyData::NoFlags);
- QQmlPropertyCache *copyAndReserve(QQmlEngine *, int propertyCount,
+ QQmlPropertyCache *copyAndReserve(int propertyCount,
int methodCount, int signalCount);
void appendProperty(const QString &,
quint32 flags, int coreIndex, int propType, int notifyIndex);
inline QQmlPropertyData *overrideData(QQmlPropertyData *) const;
inline bool isAllowedInRevision(QQmlPropertyData *) const;
- inline QQmlEngine *qmlEngine() const;
static QQmlPropertyData *property(QQmlEngine *, QObject *, const QString &,
QQmlContextData *, QQmlPropertyData &);
static QQmlPropertyData *property(QQmlEngine *, QObject *, const QV4::String *,
inline QQmlPropertyCache *copy(int reserve);
- void append(QQmlEngine *, const QMetaObject *, int revision,
+ void append(const QMetaObject *, int revision,
QQmlPropertyData::Flag propertyFlags = QQmlPropertyData::NoFlags,
QQmlPropertyData::Flag methodFlags = QQmlPropertyData::NoFlags,
QQmlPropertyData::Flag signalFlags = QQmlPropertyData::NoFlags);
QQmlPropertyData *ensureResolved(QQmlPropertyData*) const;
void resolve(QQmlPropertyData *) const;
- void updateRecur(QQmlEngine *, const QMetaObject *);
+ void updateRecur(const QMetaObject *);
template<typename K>
QQmlPropertyData *findNamedProperty(const K &key)
_hasPropertyOverrides |= isOverride;
}
+ // Optional! Only used for calling flagsForPropertyType, in which it is also optional.
QQmlEngine *engine;
QQmlPropertyCache *_parent;
(allowedRevisionCache[data->metaObjectOffset] >= data->revision);
}
-QQmlEngine *QQmlPropertyCache::qmlEngine() const
-{
- return engine;
-}
-
int QQmlPropertyCache::propertyCount() const
{
return propertyIndexCacheStart + propertyIndexCache.count();
const QMetaObject *metaObject = object.metaObject();
QQmlRefPointer<QQmlPropertyCache> parentCache(new QQmlPropertyCache(&engine, &BaseObject::staticMetaObject));
- QQmlRefPointer<QQmlPropertyCache> cache(parentCache->copyAndAppend(&engine, object.metaObject()));
+ QQmlRefPointer<QQmlPropertyCache> cache(parentCache->copyAndAppend(object.metaObject()));
QQmlPropertyData *data;
QVERIFY(data = cacheProperty(cache, "propertyA"));
const QMetaObject *metaObject = object.metaObject();
QQmlRefPointer<QQmlPropertyCache> parentCache(new QQmlPropertyCache(&engine, &BaseObject::staticMetaObject));
- QQmlRefPointer<QQmlPropertyCache> cache(parentCache->copyAndAppend(&engine, object.metaObject()));
+ QQmlRefPointer<QQmlPropertyCache> cache(parentCache->copyAndAppend(object.metaObject()));
QQmlPropertyData *data;
QVERIFY(data = cacheProperty(cache, "slotA"));
const QMetaObject *metaObject = object.metaObject();
QQmlRefPointer<QQmlPropertyCache> parentCache(new QQmlPropertyCache(&engine, &BaseObject::staticMetaObject));
- QQmlRefPointer<QQmlPropertyCache> cache(parentCache->copyAndAppend(&engine, object.metaObject()));
+ QQmlRefPointer<QQmlPropertyCache> cache(parentCache->copyAndAppend(object.metaObject()));
QQmlPropertyData *data;
QVERIFY(data = cacheProperty(cache, "onSignalA"));