#include "config.h"
#include "qt_instance.h"
#include "ArgList.h"
#include "JSDOMBinding.h"
#include "JSGlobalObject.h"
#include "JSLock.h"
#include "qt_class.h"
#include "qt_runtime.h"
#include "PropertyNameArray.h"
#include "runtime_object.h"
#include "ObjectPrototype.h"
#include "Error.h"
#include <qmetaobject.h>
#include <qdebug.h>
#include <qmetatype.h>
#include <qhash.h>
namespace JSC {
namespace Bindings {
typedef QMultiHash<void*, QtInstance*> QObjectInstanceMap;
static QObjectInstanceMap cachedInstances;
class QtRuntimeObject : public RuntimeObject {
public:
QtRuntimeObject(ExecState*, PassRefPtr<Instance>);
static const ClassInfo s_info;
virtual void markChildren(MarkStack& markStack)
{
RuntimeObject::markChildren(markStack);
QtInstance* instance = static_cast<QtInstance*>(getInternalInstance());
if (instance)
instance->markAggregate(markStack);
}
static PassRefPtr<Structure> createStructure(JSValue prototype)
{
return Structure::create(prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount);
}
protected:
static const unsigned StructureFlags = RuntimeObject::StructureFlags | OverridesMarkChildren;
private:
virtual const ClassInfo* classInfo() const { return &s_info; }
};
const ClassInfo QtRuntimeObject::s_info = { "QtRuntimeObject", &RuntimeObject::s_info, 0, 0 };
QtRuntimeObject::QtRuntimeObject(ExecState* exec, PassRefPtr<Instance> instance)
: RuntimeObject(exec, WebCore::deprecatedGetDOMStructure<QtRuntimeObject>(exec), instance)
{
}
QtInstance::QtInstance(QObject* o, PassRefPtr<RootObject> rootObject, QScriptEngine::ValueOwnership ownership)
: Instance(rootObject)
, m_class(0)
, m_object(o)
, m_hashkey(o)
, m_defaultMethod(0)
, m_ownership(ownership)
{
}
QtInstance::~QtInstance()
{
JSLock lock(SilenceAssertionsOnly);
cachedInstances.remove(m_hashkey);
m_methods.clear();
qDeleteAll(m_fields);
m_fields.clear();
if (m_object) {
switch (m_ownership) {
case QScriptEngine::QtOwnership:
break;
case QScriptEngine::AutoOwnership:
if (m_object->parent())
break;
case QScriptEngine::ScriptOwnership:
delete m_object;
break;
}
}
}
PassRefPtr<QtInstance> QtInstance::getQtInstance(QObject* o, PassRefPtr<RootObject> rootObject, QScriptEngine::ValueOwnership ownership)
{
JSLock lock(SilenceAssertionsOnly);
foreach(QtInstance* instance, cachedInstances.values(o))
if (instance->rootObject() == rootObject) {
if (!instance->getObject())
cachedInstances.remove(instance->hashKey());
else
return instance;
}
RefPtr<QtInstance> ret = QtInstance::create(o, rootObject, ownership);
cachedInstances.insert(o, ret.get());
return ret.release();
}
bool QtInstance::getOwnPropertySlot(JSObject* object, ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
{
return object->JSObject::getOwnPropertySlot(exec, propertyName, slot);
}
void QtInstance::put(JSObject* object, ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot& slot)
{
object->JSObject::put(exec, propertyName, value, slot);
}
void QtInstance::removeCachedMethod(JSObject* method)
{
if (m_defaultMethod == method)
m_defaultMethod = 0;
for(QHash<QByteArray, JSObject*>::Iterator it = m_methods.begin(),
end = m_methods.end(); it != end; ++it)
if (it.value() == method) {
m_methods.erase(it);
return;
}
}
QtInstance* QtInstance::getInstance(JSObject* object)
{
if (!object)
return 0;
if (!object->inherits(&QtRuntimeObject::s_info))
return 0;
return static_cast<QtInstance*>(static_cast<RuntimeObject*>(object)->getInternalInstance());
}
Class* QtInstance::getClass() const
{
if (!m_class) {
if (!m_object)
return 0;
m_class = QtClass::classForObject(m_object);
}
return m_class;
}
RuntimeObject* QtInstance::newRuntimeObject(ExecState* exec)
{
JSLock lock(SilenceAssertionsOnly);
return new (exec) QtRuntimeObject(exec, this);
}
void QtInstance::markAggregate(MarkStack& markStack)
{
if (m_defaultMethod)
markStack.append(m_defaultMethod);
foreach(JSObject* val, m_methods.values()) {
if (val)
markStack.append(val);
}
}
void QtInstance::begin()
{
}
void QtInstance::end()
{
}
void QtInstance::getPropertyNames(ExecState* exec, PropertyNameArray& array)
{
QObject* obj = getObject();
if (obj) {
const QMetaObject* meta = obj->metaObject();
int i;
for (i=0; i < meta->propertyCount(); i++) {
QMetaProperty prop = meta->property(i);
if (prop.isScriptable()) {
array.add(Identifier(exec, prop.name()));
}
}
#ifndef QT_NO_PROPERTIES
QList<QByteArray> dynProps = obj->dynamicPropertyNames();
foreach(QByteArray ba, dynProps) {
array.add(Identifier(exec, ba.constData()));
}
#endif
for (i=0; i < meta->methodCount(); i++) {
QMetaMethod method = meta->method(i);
if (method.access() != QMetaMethod::Private) {
array.add(Identifier(exec, method.signature()));
}
}
}
}
JSValue QtInstance::getMethod(ExecState* exec, const Identifier& propertyName)
{
if (!getClass())
return jsNull();
MethodList methodList = m_class->methodsNamed(propertyName, this);
return new (exec) RuntimeMethod(exec, propertyName, methodList);
}
JSValue QtInstance::invokeMethod(ExecState*, RuntimeMethod*, const ArgList&)
{
return jsUndefined();
}
JSValue QtInstance::defaultValue(ExecState* exec, PreferredPrimitiveType hint) const
{
if (hint == PreferString)
return stringValue(exec);
if (hint == PreferNumber)
return numberValue(exec);
return valueOf(exec);
}
JSValue QtInstance::stringValue(ExecState* exec) const
{
QObject* obj = getObject();
if (!obj)
return jsNull();
QByteArray buf;
bool useDefault = true;
getClass();
if (m_class) {
int index = obj->metaObject()->indexOfMethod("toString()");
if (index >= 0) {
QMetaMethod m = obj->metaObject()->method(index);
if (m.access() != QMetaMethod::Private
&& m.methodType() != QMetaMethod::Signal
&& m.parameterTypes().count() == 0) {
const char* retsig = m.typeName();
if (retsig && *retsig) {
QVariant ret(QMetaType::type(retsig), (void*)0);
void * qargs[1];
qargs[0] = ret.data();
if (obj->qt_metacall(QMetaObject::InvokeMetaMethod, index, qargs) < 0) {
if (ret.isValid() && ret.canConvert(QVariant::String)) {
buf = ret.toString().toLatin1().constData(); useDefault = false;
}
}
}
}
}
}
if (useDefault) {
const QMetaObject* meta = obj ? obj->metaObject() : &QObject::staticMetaObject;
QString name = obj ? obj->objectName() : QString::fromUtf8("unnamed");
QString str = QString::fromUtf8("%0(name = \"%1\")")
.arg(QLatin1String(meta->className())).arg(name);
buf = str.toLatin1();
}
return jsString(exec, buf.constData());
}
JSValue QtInstance::numberValue(ExecState* exec) const
{
return jsNumber(exec, 0);
}
JSValue QtInstance::booleanValue() const
{
return jsBoolean(getObject());
}
JSValue QtInstance::valueOf(ExecState* exec) const
{
return stringValue(exec);
}
JSValue convertQVariantToValue(ExecState*, PassRefPtr<RootObject> root, const QVariant& variant);
QVariant convertValueToQVariant(ExecState*, JSValue, QMetaType::Type hint, int *distance);
const char* QtField::name() const
{
if (m_type == MetaProperty)
return m_property.name();
else if (m_type == ChildObject && m_childObject)
return m_childObject->objectName().toLatin1();
#ifndef QT_NO_PROPERTIES
else if (m_type == DynamicProperty)
return m_dynamicProperty.constData();
#endif
return ""; }
JSValue QtField::valueFromInstance(ExecState* exec, const Instance* inst) const
{
const QtInstance* instance = static_cast<const QtInstance*>(inst);
QObject* obj = instance->getObject();
if (obj) {
QVariant val;
if (m_type == MetaProperty) {
if (m_property.isReadable())
val = m_property.read(obj);
else
return jsUndefined();
} else if (m_type == ChildObject)
val = QVariant::fromValue((QObject*) m_childObject);
#ifndef QT_NO_PROPERTIES
else if (m_type == DynamicProperty)
val = obj->property(m_dynamicProperty);
#endif
return convertQVariantToValue(exec, inst->rootObject(), val);
} else {
QString msg = QString(QLatin1String("cannot access member `%1' of deleted QObject")).arg(QLatin1String(name()));
return throwError(exec, GeneralError, msg.toLatin1().constData());
}
}
void QtField::setValueToInstance(ExecState* exec, const Instance* inst, JSValue aValue) const
{
if (m_type == ChildObject) return;
const QtInstance* instance = static_cast<const QtInstance*>(inst);
QObject* obj = instance->getObject();
if (obj) {
QMetaType::Type argtype = QMetaType::Void;
if (m_type == MetaProperty)
argtype = (QMetaType::Type) QMetaType::type(m_property.typeName());
QVariant val = convertValueToQVariant(exec, aValue, argtype, 0);
if (m_type == MetaProperty) {
if (m_property.isWritable())
m_property.write(obj, val);
}
#ifndef QT_NO_PROPERTIES
else if (m_type == DynamicProperty)
obj->setProperty(m_dynamicProperty.constData(), val);
#endif
} else {
QString msg = QString(QLatin1String("cannot access member `%1' of deleted QObject")).arg(QLatin1String(name()));
throwError(exec, GeneralError, msg.toLatin1().constData());
}
}
}
}