prop.value = expr->expression();
QObject *scope = expr->scopeObject();
if (scope) {
- QString methodName = QString::fromLatin1(scope->metaObject()->method(signal->index()).name());
- QString sig = QString::fromLatin1(scope->metaObject()->method(signalHandler->index()).signature());
- int lparen = sig.indexOf(QLatin1Char('('));
- if (lparen >= 0) {
- QString methodName = sig.mid(0, lparen);
++ QString methodName = QString::fromLatin1(scope->metaObject()->method(signalHandler->index()).name());
+ if (!methodName.isEmpty()) {
prop.name = QLatin1String("on") + methodName[0].toUpper()
+ methodName.mid(1);
}
}
bool enabled;
+
+ private:
+ void init(const QMetaMethod &signal, QQmlExpression *expression)
+ {
+ QQmlProfilerService *service = QQmlProfilerService::instance;
+ service->startRange(QQmlProfilerService::HandlingSignal);
+ service->rangeData(QQmlProfilerService::HandlingSignal,
- QLatin1String(signal.signature()) + QLatin1String(": ")
++ QString::fromLatin1(signal.methodSignature()) + QLatin1String(": ")
+ + expression->expression());
+ service->rangeLocation(QQmlProfilerService::HandlingSignal,
+ expression->sourceFile(), expression->lineNumber(),
+ expression->columnNumber());
+ }
};
struct QQmlObjectCreatingProfiler {
prop.setWritable(false);
} else {
QByteArray propType = type;
- if ((QMetaType::typeFlags(t) & QMetaType::IsEnumeration) == QMetaType::IsEnumeration) {
+ QMetaType::TypeFlags flags = QMetaType::typeFlags(t);
+ if (flags & QMetaType::IsEnumeration) {
t = QVariant::Int;
propType = "int";
- } else if (t == QMetaType::UnknownType) {
- } else if (t == QVariant::Invalid ||
- (t >= QVariant::UserType && !(flags & QMetaType::PointerToQObject) &&
++ } else if (t == QMetaType::UnknownType ||
++ (t >= int(QMetaType::User) && !(flags & QMetaType::PointerToQObject) &&
+ t != qMetaTypeId<QJSValue>())) {
+ //the UserType clause is to catch registered QFlags
QByteArray scope;
QByteArray name;
int scopeIdx = propType.lastIndexOf("::");
}
}
+ ////////////////////////////////////////////////////////////////////////
+
+ QQmlBoundSignalNoParams::QQmlBoundSignalNoParams(QObject *scope, const QMetaMethod &signal,
+ QObject *owner)
+ : m_expression(0), m_owner(owner), m_index(signal.methodIndex()), m_isEvaluating(false)
+ {
+ callback = &subscriptionCallback;
+ QQmlNotifierEndpoint::connect(scope, m_index);
+ }
+
+ QQmlBoundSignalNoParams::~QQmlBoundSignalNoParams()
+ {
+ delete m_expression;
+ m_expression = 0;
+ }
+
+ int QQmlBoundSignalNoParams::index() const
+ {
+ return m_index;
+ }
+
+ /*!
+ Returns the signal expression.
+ */
+ QQmlExpression *QQmlBoundSignalNoParams::expression() const
+ {
+ return m_expression;
+ }
+
+ /*!
+ Sets the signal expression to \a e. Returns the current signal expression,
+ or null if there is no signal expression.
+
+ The QQmlBoundSignalNoParams instance takes ownership of \a e. The caller is
+ assumes ownership of the returned QQmlExpression.
+ */
+ QQmlExpression *QQmlBoundSignalNoParams::setExpression(QQmlExpression *e)
+ {
+ QQmlExpression *rv = m_expression;
+ m_expression = e;
+ if (m_expression) m_expression->setNotifyOnValueChanged(false);
+ return rv;
+ }
+
+ void QQmlBoundSignalNoParams::subscriptionCallback(QQmlNotifierEndpoint *e)
+ {
+ QQmlBoundSignalNoParams *s = static_cast<QQmlBoundSignalNoParams*>(e);
+ if (!s->m_expression)
+ return;
+
+ if (QQmlDebugService::isDebuggingEnabled())
- QV8DebugService::instance()->signalEmitted(QString::fromAscii(s->m_owner->metaObject()->method(s->m_index).signature()));
++ QV8DebugService::instance()->signalEmitted(QString::fromAscii(s->m_owner->metaObject()->method(s->m_index).methodSignature()));
+
+ QQmlHandlingSignalProfiler prof(s->m_owner, s->m_index, s->m_expression);
+
+ s->m_isEvaluating = true;
+
+ if (s->m_expression && s->m_expression->engine()) {
+ QQmlExpressionPrivate::get(s->m_expression)->value();
+ if (s->m_expression && s->m_expression->hasError())
+ QQmlEnginePrivate::warning(s->m_expression->engine(), s->m_expression->error());
+ }
+ s->m_isEvaluating = false;
+ }
+
QT_END_NAMESPACE
#include <qqmlboundsignal.moc>
const QMetaObject *metaObject = object->metaObject();
QMetaMethod m = metaObject->method(index);
- QList<QByteArray> argTypeNames = m.parameterTypes();
- A *args = static_cast<A *>(malloc(sizeof(A) + (argTypeNames.count() + 1) * sizeof(int)));
- args->arguments[0] = argTypeNames.count();
+ int argc = m.parameterCount();
+ A *args = static_cast<A *>(malloc(sizeof(A) + (argc + 1) * sizeof(int)));
+ args->arguments[0] = argc;
+ QList<QByteArray> argTypeNames; // Only loaded if needed
- for (int ii = 0; ii < argTypeNames.count(); ++ii) {
- int type = QMetaType::type(argTypeNames.at(ii));
+ for (int ii = 0; ii < argc; ++ii) {
+ int type = m.parameterType(ii);
- if ((QMetaType::typeFlags(type) & QMetaType::IsEnumeration) == QMetaType::IsEnumeration)
+ QMetaType::TypeFlags flags = QMetaType::typeFlags(type);
+ if (flags & QMetaType::IsEnumeration)
type = QVariant::Int;
- else if (type == QMetaType::UnknownType) {
- else if (type == QVariant::Invalid ||
++ else if (type == QMetaType::UnknownType ||
+ (type >= (int)QVariant::UserType && !(flags & QMetaType::PointerToQObject) &&
- type != qMetaTypeId<QJSValue>()))
++ type != qMetaTypeId<QJSValue>())) {
+ //the UserType clause is to catch registered QFlags
+ if (argTypeNames.isEmpty())
+ argTypeNames = m.parameterTypes();
- type = EnumType(object->metaObject(), argTypeNames.at(ii));
+ type = EnumType(object->metaObject(), argTypeNames.at(ii), type);
- if (type == QVariant::Invalid) {
+ }
+ if (type == QMetaType::UnknownType) {
if (unknownTypeError) *unknownTypeError = argTypeNames.at(ii);
free(args);
return 0;
} else {
QMetaMethod m = object->metaObject()->method(index);
- QList<QByteArray> argTypeNames = m.parameterTypes();
- dummy.resize(argTypeNames.count() + 1);
- dummy[0] = argTypeNames.count();
+ int argc = m.parameterCount();
+ dummy.resize(argc + 1);
+ dummy[0] = argc;
+ QList<QByteArray> argTypeNames; // Only loaded if needed
- for (int ii = 0; ii < argTypeNames.count(); ++ii) {
- int type = QMetaType::type(argTypeNames.at(ii));
+ for (int ii = 0; ii < argc; ++ii) {
+ int type = m.parameterType(ii);
- if ((QMetaType::typeFlags(type) & QMetaType::IsEnumeration) == QMetaType::IsEnumeration)
+ QMetaType::TypeFlags flags = QMetaType::typeFlags(type);
+ if (flags & QMetaType::IsEnumeration)
type = QVariant::Int;
- else if (type == QMetaType::UnknownType) {
- else if (type == QVariant::Invalid ||
++ else if (type == QMetaType::UnknownType ||
+ (type >= (int)QVariant::UserType && !(flags & QMetaType::PointerToQObject) &&
- type != qMetaTypeId<QJSValue>()))
++ type != qMetaTypeId<QJSValue>())) {
+ //the UserType clause is to catch registered QFlags)
+ if (argTypeNames.isEmpty())
+ argTypeNames = m.parameterTypes();
- type = EnumType(object->metaObject(), argTypeNames.at(ii));
+ type = EnumType(object->metaObject(), argTypeNames.at(ii), type);
- if (type == QVariant::Invalid) {
+ }
+ if (type == QMetaType::UnknownType) {
if (unknownTypeError) *unknownTypeError = argTypeNames.at(ii);
return 0;
}
/*!
- \class QQmlImageProvider
+ \class QQuickImageProvider
- \since 4.7
+ \since 5.0
- \inmodule QtQml
- \brief The QQmlImageProvider class provides an interface for supporting pixmaps and threaded image requests in QML.
++ \inmodule QtQuick
+ \brief The QQuickImageProvider class provides an interface for supporting pixmaps and threaded image requests in QML.
- QQmlImageProvider is used to provide advanced image loading features
+ QQuickImageProvider is used to provide advanced image loading features
in QML applications. It allows images in QML to be:
\list