#include "config.h"
#include "Identifier.h"
#include "qt_class.h"
#include "qt_instance.h"
#include "qt_runtime.h"
#include <qmetaobject.h>
#include <qdebug.h>
namespace JSC {
namespace Bindings {
QtClass::QtClass(const QMetaObject* mo)
: m_metaObject(mo)
{
}
QtClass::~QtClass()
{
}
typedef HashMap<const QMetaObject*, QtClass*> ClassesByMetaObject;
static ClassesByMetaObject* classesByMetaObject = 0;
QtClass* QtClass::classForObject(QObject* o)
{
if (!classesByMetaObject)
classesByMetaObject = new ClassesByMetaObject;
const QMetaObject* mo = o->metaObject();
QtClass* aClass = classesByMetaObject->get(mo);
if (!aClass) {
aClass = new QtClass(mo);
classesByMetaObject->set(mo, aClass);
}
return aClass;
}
const char* QtClass::name() const
{
return m_metaObject->className();
}
JSValue QtClass::fallbackObject(ExecState* exec, Instance* inst, const Identifier& identifier)
{
QtInstance* qtinst = static_cast<QtInstance*>(inst);
QByteArray name(identifier.ascii());
JSObject* val = qtinst->m_methods.value(name);
if (val)
return val;
QByteArray normal = QMetaObject::normalizedSignature(name.constData());
int index = -1;
if (normal.contains('(') && (index = m_metaObject->indexOfMethod(normal)) != -1) {
QMetaMethod m = m_metaObject->method(index);
if (m.access() != QMetaMethod::Private) {
QtRuntimeMetaMethod* val = new (exec) QtRuntimeMetaMethod(exec, identifier, static_cast<QtInstance*>(inst), index, normal, false);
qtinst->m_methods.insert(name, val);
return val;
}
}
int count = m_metaObject->methodCount();
for (index = count - 1; index >= 0; --index) {
const QMetaMethod m = m_metaObject->method(index);
if (m.access() == QMetaMethod::Private)
continue;
QByteArray signature = m.signature();
signature.truncate(signature.indexOf('('));
if (normal == signature) {
QtRuntimeMetaMethod* val = new (exec) QtRuntimeMetaMethod(exec, identifier, static_cast<QtInstance*>(inst), index, normal, false);
qtinst->m_methods.insert(name, val);
return val;
}
}
return jsUndefined();
}
MethodList QtClass::methodsNamed(const Identifier&, Instance*) const
{
return MethodList();
}
Field* QtClass::fieldNamed(const Identifier& identifier, Instance* instance) const
{
QtInstance* qtinst = static_cast<QtInstance*>(instance);
QObject* obj = qtinst->getObject();
UString ustring = identifier.ustring();
QString objName(QString::fromUtf16((const ushort*)ustring.rep()->data(),ustring.size()));
QByteArray ba = objName.toAscii();
QtField* f = qtinst->m_fields.value(objName);
if (obj) {
if (f) {
if (f->fieldType() == QtField::MetaProperty)
return f;
else if (f->fieldType() == QtField::DynamicProperty) {
if (obj->dynamicPropertyNames().indexOf(ba) >= 0)
return f;
else {
qtinst->m_fields.remove(objName);
delete f;
}
} else {
QList<QObject*> children = obj->children();
for (int index = 0; index < children.count(); ++index) {
QObject *child = children.at(index);
if (child->objectName() == objName)
return f;
}
qtinst->m_fields.remove(objName);
delete f;
}
}
int index = m_metaObject->indexOfProperty(identifier.ascii());
if (index >= 0) {
QMetaProperty prop = m_metaObject->property(index);
if (prop.isScriptable(obj)) {
f = new QtField(prop);
qtinst->m_fields.insert(objName, f);
return f;
}
}
index = obj->dynamicPropertyNames().indexOf(ba);
if (index >= 0) {
f = new QtField(ba);
qtinst->m_fields.insert(objName, f);
return f;
}
QList<QObject*> children = obj->children();
for (index = 0; index < children.count(); ++index) {
QObject *child = children.at(index);
if (child->objectName() == objName) {
f = new QtField(child);
qtinst->m_fields.insert(objName, f);
return f;
}
}
return 0;
} else {
QByteArray ba(identifier.ascii());
if (qtinst->m_methods.contains(ba))
return 0;
if (!f) {
f = new QtField(ba);
qtinst->m_fields.insert(objName, f);
}
return f;
}
}
}
}