#include <qdeclarativeobjectscriptclass_p.h>

Inheritance diagram for QDeclarativeObjectMethodScriptClass:

Public Functions
QScriptValue	newMethod (QObject , const QDeclarativePropertyCache::Data )

	QDeclarativeObjectMethodScriptClass (QDeclarativeEngine *)

	~QDeclarativeObjectMethodScriptClass ()

Public Functions inherited from QScriptDeclarativeClass
virtual bool	compare (Object , Object )

QScriptContext *	context () const

PersistentIdentifier	createPersistentIdentifier (const QString &)

PersistentIdentifier	createPersistentIdentifier (const Identifier &)

QScriptEngine *	engine () const

virtual bool	isQObject () const

virtual QScriptValue::PropertyFlags	propertyFlags (Object *, const Identifier &)

virtual QStringList	propertyNames (Object *)

	QScriptDeclarativeClass (QScriptEngine *engine)

virtual void	setProperty (Object *, const Identifier &name, const QScriptValue &)

void	setSupportsCall (bool)

bool	startsWithUpper (const Identifier &)

bool	supportsCall () const

quint32	toArrayIndex (const Identifier &, bool *ok)

virtual QObject *	toQObject (Object , bool ok=0)

QString	toString (const Identifier &)

virtual QVariant	toVariant (Object , bool ok=0)

virtual	~QScriptDeclarativeClass ()

Protected Functions
virtual Value	call (Object , QScriptContext )

virtual Value	property (Object *, const Identifier &)

virtual QScriptClass::QueryFlags	queryProperty (Object *, const Identifier &, QScriptClass::QueryFlags flags)

Private Functions
Value	callMethod (QObject , int index, int returnType, int argCount, int argTypes, QScriptContext *ctxt)

Value	callOverloaded (MethodData , QScriptContext )
	Resolve the overloaded method to call. More...

Value	callPrecise (QObject , const QDeclarativePropertyCache::Data &, QScriptContext )

int	enumType (const QMetaObject *, const QString &)

int	matchScore (const QScriptValue &, int, const QByteArray &)
	Returns the match score for converting actual to be of type conversionType. More...

QDeclarativePropertyCache::Data *	relatedMethod (QObject , QDeclarativePropertyCache::Data current, QDeclarativePropertyCache::Data &dummy)
	Returns the next related method, if one, or 0. More...

Static Private Functions
static QScriptValue	connect (QScriptContext context, QScriptEngine engine)

static QScriptValue	disconnect (QScriptContext context, QScriptEngine engine)

Properties
QDeclarativeEngine *	engine

QScriptValue	m_connect

PersistentIdentifier	m_connectId

QScriptValue	m_disconnect

PersistentIdentifier	m_disconnectId

Additional Inherited Members
Public Types inherited from QScriptDeclarativeClass
typedef void *	Identifier

Static Public Functions inherited from QScriptDeclarativeClass
static QScriptValue	function (const QScriptValue &, const Identifier &)

static Value	functionValue (const QScriptValue &, const Identifier &)

static QScriptValue	newObject (QScriptEngine , QScriptDeclarativeClass , Object *)

static Value	newObjectValue (QScriptEngine , QScriptDeclarativeClass , Object *)

static QScriptValue	newStaticScopeObject (QScriptEngine , int propertyCount, const QString names, const QScriptValue values, const QScriptValue::PropertyFlags flags)
	Creates a scope object with a fixed set of undeletable properties. More...

static QScriptValue	newStaticScopeObject (QScriptEngine *)
	Creates a static scope object that's initially empty, but to which new properties can be added. More...

static Object *	object (const QScriptValue &)

static QScriptValue	property (const QScriptValue &, const Identifier &)

static Value	propertyValue (const QScriptValue &, const Identifier &)

static QScriptContext *	pushCleanContext (QScriptEngine *)
	Enters a new execution context and returns the associated QScriptContext object. More...

static QScriptValue	scopeChainValue (QScriptContext *, int index)

static QScriptDeclarativeClass *	scriptClass (const QScriptValue &)

Protected Variables inherited from QScriptDeclarativeClass
QScopedPointer< QScriptDeclarativeClassPrivate >	d_ptr

Detailed Description

Definition at line 70 of file qdeclarativeobjectscriptclass_p.h.

Constructors and Destructors

◆ QDeclarativeObjectMethodScriptClass()

QDeclarativeObjectMethodScriptClass::QDeclarativeObjectMethodScriptClass ( QDeclarativeEngine * bindEngine )

Definition at line 571 of file qdeclarativeobjectscriptclass.cpp.

 : QScriptDeclarativeClass(QDeclarativeEnginePrivate::getScriptEngine(bindEngine)),
   engine(bindEngine)
 {
     qRegisterMetaType<QList<QObject *> >("QList<QObject *>");
 
     setSupportsCall(true);
 
     QScriptEngine *scriptEngine = QDeclarativeEnginePrivate::getScriptEngine(engine);
 
     m_connect = scriptEngine->newFunction(connect);
     m_connectId = createPersistentIdentifier(QLatin1String("connect"));
     m_disconnect = scriptEngine->newFunction(disconnect);
     m_disconnectId = createPersistentIdentifier(QLatin1String("disconnect"));
 }

◆ ~QDeclarativeObjectMethodScriptClass()

QDeclarativeObjectMethodScriptClass::~QDeclarativeObjectMethodScriptClass ( )

Definition at line 587 of file qdeclarativeobjectscriptclass.cpp.

588 {

589 }

Functions

◆ call()

QDeclarativeObjectMethodScriptClass::Value QDeclarativeObjectMethodScriptClass::call	(	Object *	o,
		QScriptContext *	ctxt
	)

protectedvirtual

Reimplemented from QScriptDeclarativeClass.

Definition at line 917 of file qdeclarativeobjectscriptclass.cpp.

 {
     MethodData *method = static_cast<MethodData *>(o);
 
     if (method->data.relatedIndex == -1)
         return callPrecise(method->object, method->data, ctxt);
     else
         return callOverloaded(method, ctxt);
 }

◆ callMethod()

QDeclarativeObjectMethodScriptClass::Value QDeclarativeObjectMethodScriptClass::callMethod	(	QObject *	object,
		int	index,
		int	returnType,
		int	argCount,
		int *	argTypes,
		QScriptContext *	ctxt
	)

private

Definition at line 959 of file qdeclarativeobjectscriptclass.cpp.

Referenced by callPrecise().

 {
     if (argCount > 0) {
 
         QVarLengthArray<MetaCallArgument, 9> args(argCount + 1);
         args[0].initAsType(returnType, engine);
 
         for (int ii = 0; ii < argCount; ++ii)
             args[ii + 1].fromScriptValue(argTypes[ii], engine, ctxt->argument(ii));
 
         QVarLengthArray<void *, 9> argData(args.count());
         for (int ii = 0; ii < args.count(); ++ii)
             argData[ii] = args[ii].dataPtr();
 
         QMetaObject::metacall(object, QMetaObject::InvokeMetaMethod, index, argData.data());
 
         return args[0].toValue(engine);
 
     } else if (returnType != 0) {
         
         MetaCallArgument arg;
         arg.initAsType(returnType, engine);
 
         void *args[] = { arg.dataPtr() };
 
         QMetaObject::metacall(object, QMetaObject::InvokeMetaMethod, index, args);
 
         return arg.toValue(engine);
 
     } else {
 
         void *args[] = { 0 };
         QMetaObject::metacall(object, QMetaObject::InvokeMetaMethod, index, args);
         return Value();
 
     }
 }

◆ callOverloaded()

QDeclarativeObjectMethodScriptClass::Value QDeclarativeObjectMethodScriptClass::callOverloaded	(	MethodData *	method,
		QScriptContext *	ctxt
	)

private

Resolve the overloaded method to call.

The algorithm works conceptually like this:

Resolve the set of overloads it is possible to call. Impossible overloads include those that have too many parameters or have parameters of unknown type.
Filter the set of overloads to only contain those with the closest number of parameters. For example, if we are called with 3 parameters and there are 2 overloads that take 2 parameters and one that takes 3, eliminate the 2 parameter overloads.
Find the best remaining overload based on its match score. If two or more overloads have the same match score, call the last one. The match score is constructed by adding the matchScore() result for each of the parameters.

Definition at line 1013 of file qdeclarativeobjectscriptclass.cpp.

Referenced by call().

 {
     int argumentCount = ctxt->argumentCount();
 
     QDeclarativePropertyCache::Data *best = 0;
     int bestParameterScore = INT_MAX;
     int bestMatchScore = INT_MAX;
 
     QDeclarativePropertyCache::Data dummy;
     QDeclarativePropertyCache::Data *attempt = &method->data;
 
     do {
         QList<QByteArray> methodArgTypeNames;
 
         if (attempt->flags & QDeclarativePropertyCache::Data::HasArguments)
             methodArgTypeNames = method->object->metaObject()->method(attempt->coreIndex).parameterTypes();
 
         int methodArgumentCount = methodArgTypeNames.count();
 
         if (methodArgumentCount > argumentCount)
             continue; // We don't have sufficient arguments to call this method
 
         int methodParameterScore = argumentCount - methodArgumentCount;
         if (methodParameterScore > bestParameterScore)
             continue; // We already have a better option
 
         int methodMatchScore = 0;
         QVarLengthArray<int, 9> methodArgTypes(methodArgumentCount);
 
         bool unknownArgument = false;
         for (int ii = 0; ii < methodArgumentCount; ++ii) {
             methodArgTypes[ii] = QMetaType::type(methodArgTypeNames.at(ii));
             if (methodArgTypes[ii] == QVariant::Invalid) 
                 methodArgTypes[ii] = enumType(method->object->metaObject(), 
                                               QString::fromLatin1(methodArgTypeNames.at(ii)));
             if (methodArgTypes[ii] == QVariant::Invalid) {
                 unknownArgument = true;
                 break;
             }
             methodMatchScore += matchScore(ctxt->argument(ii), methodArgTypes[ii], methodArgTypeNames.at(ii));
         }
         if (unknownArgument)
             continue; // We don't understand all the parameters
 
         if (bestParameterScore > methodParameterScore || bestMatchScore > methodMatchScore) {
             best = attempt;
             bestParameterScore = methodParameterScore;
             bestMatchScore = methodMatchScore;
         }
 
         if (bestParameterScore == 0 && bestMatchScore == 0)
             break; // We can't get better than that
 
     } while((attempt = relatedMethod(method->object, attempt, dummy)) != 0);
 
     if (best) {
         return callPrecise(method->object, *best, ctxt);
     } else {
         QString error = QLatin1String("Unable to determine callable overload.  Candidates are:");
         QDeclarativePropertyCache::Data *candidate = &method->data;
         while (candidate) {
             error += QLatin1String("\n    ") + QString::fromUtf8(method->object->metaObject()->method(candidate->coreIndex).signature());
             candidate = relatedMethod(method->object, candidate, dummy);
         }
         return Value(ctxt, ctxt->throwError(error));
     }
 }

◆ callPrecise()

QDeclarativeObjectMethodScriptClass::Value QDeclarativeObjectMethodScriptClass::callPrecise	(	QObject *	object,
		const QDeclarativePropertyCache::Data &	data,
		QScriptContext *	ctxt
	)

private

Definition at line 928 of file qdeclarativeobjectscriptclass.cpp.

Referenced by call(), and callOverloaded().

 {
     if (data.flags & QDeclarativePropertyCache::Data::HasArguments) {
 
         QMetaMethod m = object->metaObject()->method(data.coreIndex);
         QList<QByteArray> argTypeNames = m.parameterTypes();
         QVarLengthArray<int, 9> argTypes(argTypeNames.count());
 
         // ### Cache
         for (int ii = 0; ii < argTypeNames.count(); ++ii) {
             argTypes[ii] = QMetaType::type(argTypeNames.at(ii));
             if (argTypes[ii] == QVariant::Invalid) 
                 argTypes[ii] = enumType(object->metaObject(), QString::fromLatin1(argTypeNames.at(ii)));
             if (argTypes[ii] == QVariant::Invalid) 
                 return Value(ctxt, ctxt->throwError(QString::fromLatin1("Unknown method parameter type: %1").arg(QLatin1String(argTypeNames.at(ii)))));
         }
 
         if (argTypes.count() > ctxt->argumentCount())
             return Value(ctxt, ctxt->throwError(QLatin1String("Insufficient arguments")));
 
         return callMethod(object, data.coreIndex, data.propType, argTypes.count(), argTypes.data(), ctxt);
 
     } else {
 
         return callMethod(object, data.coreIndex, data.propType, 0, 0, ctxt);
 
     }
 }

◆ connect()

QScriptValue QDeclarativeObjectMethodScriptClass::connect	(	QScriptContext *	context,
		QScriptEngine *	engine
	)

staticprivate

Definition at line 598 of file qdeclarativeobjectscriptclass.cpp.

Referenced by QDeclarativeObjectMethodScriptClass().

 {
     QDeclarativeEnginePrivate *p = QDeclarativeEnginePrivate::get(engine);
 
     QScriptValue that = context->thisObject();
     if (&p->objectClass->methods != scriptClass(that))
         return engine->undefinedValue();
 
     MethodData *data = (MethodData *)object(that);
 
     if (!data->object || context->argumentCount() == 0)
         return engine->undefinedValue();
 
     QByteArray signal("2");
     signal.append(data->object->metaObject()->method(data->data.coreIndex).signature());
 
     if (context->argumentCount() == 1) {
         qScriptConnect(data->object, signal.constData(), QScriptValue(), context->argument(0));
     } else {
         qScriptConnect(data->object, signal.constData(), context->argument(0), context->argument(1));
     }
 
     return engine->undefinedValue();
 }

◆ disconnect()

QScriptValue QDeclarativeObjectMethodScriptClass::disconnect	(	QScriptContext *	context,
		QScriptEngine *	engine
	)

staticprivate

Definition at line 623 of file qdeclarativeobjectscriptclass.cpp.

Referenced by QDeclarativeObjectMethodScriptClass().

 {
     QDeclarativeEnginePrivate *p = QDeclarativeEnginePrivate::get(engine);
 
     QScriptValue that = context->thisObject();
     if (&p->objectClass->methods != scriptClass(that))
         return engine->undefinedValue();
 
     MethodData *data = (MethodData *)object(that);
 
     if (!data->object || context->argumentCount() == 0)
         return engine->undefinedValue();
 
     QByteArray signal("2");
     signal.append(data->object->metaObject()->method(data->data.coreIndex).signature());
 
     if (context->argumentCount() == 1) {
         qScriptDisconnect(data->object, signal.constData(), QScriptValue(), context->argument(0));
     } else {
         qScriptDisconnect(data->object, signal.constData(), context->argument(0), context->argument(1));
     }
 
     return engine->undefinedValue();
 }

◆ enumType()

int QDeclarativeObjectMethodScriptClass::enumType	(	const QMetaObject *	meta,
		const QString &	strname
	)

private

Definition at line 897 of file qdeclarativeobjectscriptclass.cpp.

Referenced by callOverloaded(), and callPrecise().

 {
     QByteArray str = strname.toUtf8();
     QByteArray scope;
     QByteArray name;
     int scopeIdx = str.lastIndexOf("::");
     if (scopeIdx != -1) {
         scope = str.left(scopeIdx);
         name = str.mid(scopeIdx + 2);
     } else { 
         name = str;
     }
     for (int i = meta->enumeratorCount() - 1; i >= 0; --i) {
         QMetaEnum m = meta->enumerator(i);
         if ((m.name() == name) && (scope.isEmpty() || (m.scope() == scope)))
             return QVariant::Int;
     }
     return QVariant::Invalid;
 }

◆ matchScore()

int QDeclarativeObjectMethodScriptClass::matchScore	(	const QScriptValue &	actual,
		int	conversionType,
		const QByteArray &	conversionTypeName
	)

private

Returns the match score for converting actual to be of type conversionType.

A zero score means "perfect match" whereas a higher score is worse.

The conversion table is copied out of the QtScript callQtMethod() function.

Definition at line 1087 of file qdeclarativeobjectscriptclass.cpp.

Referenced by callOverloaded().

 {
     if (actual.isNumber()) {
         switch (conversionType) {
         case QMetaType::Double:
             return 0;
         case QMetaType::Float:
             return 1;
         case QMetaType::LongLong:
         case QMetaType::ULongLong:
             return 2;
         case QMetaType::Long:
         case QMetaType::ULong:
             return 3;
         case QMetaType::Int:
         case QMetaType::UInt:
             return 4;
         case QMetaType::Short:
         case QMetaType::UShort:
             return 5;
             break;
         case QMetaType::Char:
         case QMetaType::UChar:
             return 6;
         default:
             return 10;
         }
     } else if (actual.isString()) {
         switch (conversionType) {
         case QMetaType::QString:
             return 0;
         default:
             return 10;
         }
     } else if (actual.isBoolean()) {
         switch (conversionType) {
         case QMetaType::Bool:
             return 0;
         default:
             return 10;
         }
     } else if (actual.isDate()) {
         switch (conversionType) {
         case QMetaType::QDateTime:
             return 0;
         case QMetaType::QDate:
             return 1;
         case QMetaType::QTime:
             return 2;
         default:
             return 10;
         }
     } else if (actual.isRegExp()) {
         switch (conversionType) {
         case QMetaType::QRegExp:
             return 0;
         default:
             return 10;
         }
     } else if (actual.isVariant()) {
         if (conversionType == qMetaTypeId<QVariant>())
             return 0;
         else if (actual.toVariant().userType() == conversionType)
             return 0;
         else
             return 10;
     } else if (actual.isArray()) {
         switch (conversionType) {
         case QMetaType::QStringList:
         case QMetaType::QVariantList:
             return 5;
         default:
             return 10;
         }
     } else if (actual.isQObject()) {
         switch (conversionType) {
         case QMetaType::QObjectStar:
             return 0;
         default:
             return 10;
         }
     } else if (actual.isNull()) {
         switch (conversionType) {
         case QMetaType::VoidStar:
         case QMetaType::QObjectStar:
             return 0;
         default:
             if (!conversionTypeName.endsWith('*'))
                 return 10;
             else
                 return 0;
         }
     } else {
         return 10;
     }
 }

◆ newMethod()

QScriptValue QDeclarativeObjectMethodScriptClass::newMethod	(	QObject *	object,
		const QDeclarativePropertyCache::Data *	method
	)

Definition at line 591 of file qdeclarativeobjectscriptclass.cpp.

Referenced by QDeclarativeObjectScriptClass::property().

 {
     QScriptEngine *scriptEngine = QDeclarativeEnginePrivate::getScriptEngine(engine);
 
     return newObject(scriptEngine, this, new MethodData(object, *method));
 }

◆ property()

QDeclarativeObjectMethodScriptClass::Value QDeclarativeObjectMethodScriptClass::property	(	Object *	,
		const Identifier &	name
	)

protectedvirtual

Reimplemented from QScriptDeclarativeClass.

Definition at line 661 of file qdeclarativeobjectscriptclass.cpp.

 {
     QScriptEngine *scriptEngine = QDeclarativeEnginePrivate::getScriptEngine(engine);
 
     if (name == m_connectId.identifier)
         return Value(scriptEngine, m_connect);
     else if (name == m_disconnectId.identifier)
         return Value(scriptEngine, m_disconnect);
     else
         return Value();
 }

◆ queryProperty()

QScriptClass::QueryFlags QDeclarativeObjectMethodScriptClass::queryProperty	(	Object *	,
		const Identifier &	name,
		QScriptClass::QueryFlags	flags
	)

protectedvirtual

Reimplemented from QScriptDeclarativeClass.

Definition at line 649 of file qdeclarativeobjectscriptclass.cpp.

 {
     Q_UNUSED(flags);
     if (name == m_connectId.identifier || name == m_disconnectId.identifier)
         return QScriptClass::HandlesReadAccess;
     else
         return 0;
 
 }

◆ relatedMethod()

QDeclarativePropertyCache::Data * QDeclarativeObjectMethodScriptClass::relatedMethod	(	QObject *	object,
		QDeclarativePropertyCache::Data *	current,
		QDeclarativePropertyCache::Data &	dummy
	)

private

Returns the next related method, if one, or 0.

Definition at line 1212 of file qdeclarativeobjectscriptclass.cpp.

Referenced by callOverloaded().

 {
     QDeclarativePropertyCache *cache = QDeclarativeData::get(object)->propertyCache;
     if (current->relatedIndex == -1)
         return 0;
 
     if (cache) {
         return cache->method(current->relatedIndex);
     } else {
         const QMetaObject *mo = object->metaObject();
         int methodOffset = mo->methodCount() - QMetaObject_methods(mo);
 
         while (methodOffset > current->relatedIndex) {
             mo = mo->superClass();
             methodOffset -= QMetaObject_methods(mo);
         }
 
         QMetaMethod method = mo->method(current->relatedIndex);
         dummy.load(method);
         
         // Look for overloaded methods
         QByteArray methodName = QMetaMethod_name(method);
         for (int ii = current->relatedIndex - 1; ii >= methodOffset; --ii) {
             if (methodName == QMetaMethod_name(mo->method(ii))) {
                 dummy.relatedIndex = ii;
                 return &dummy;
             }
         }
 
         return &dummy;
     }
 }