59730b875ff4cbf1d37b385440070cbed58af3ff
[WebKit-https.git] / WebCore / bridge / qt / qt_class.cpp
1 /*
2  * Copyright (C) 2006 Trolltech ASA
3  *
4  *  This library is free software; you can redistribute it and/or
5  *  modify it under the terms of the GNU Lesser General Public
6  *  License as published by the Free Software Foundation; either
7  *  version 2 of the License, or (at your option) any later version.
8  *
9  *  This library is distributed in the hope that it will be useful,
10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  *  Lesser General Public License for more details.
13  *
14  *  You should have received a copy of the GNU Lesser General Public
15  *  License along with this library; if not, write to the Free Software
16  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
17  *
18  */
19
20 #include "config.h"
21 #include "identifier.h"
22
23 #include "qt_class.h"
24 #include "qt_instance.h"
25 #include "qt_runtime.h"
26
27 #include <qmetaobject.h>
28 #include <qdebug.h>
29
30 namespace KJS {
31 namespace Bindings {
32
33 QtClass::QtClass(const QMetaObject* mo)
34     : m_metaObject(mo)
35 {
36 }
37
38 QtClass::~QtClass()
39 {
40 }
41
42 typedef HashMap<const QMetaObject*, QtClass*> ClassesByMetaObject;
43 static ClassesByMetaObject* classesByMetaObject = 0;
44
45 QtClass* QtClass::classForObject(QObject* o)
46 {
47     if (!classesByMetaObject)
48         classesByMetaObject = new ClassesByMetaObject;
49
50     const QMetaObject* mo = o->metaObject();
51     QtClass* aClass = classesByMetaObject->get(mo);
52     if (!aClass) {
53         aClass = new QtClass(mo);
54         classesByMetaObject->set(mo, aClass);
55     }
56
57     return aClass;
58 }
59
60 const char* QtClass::name() const
61 {
62     return m_metaObject->className();
63 }
64
65 // We use this to get at signals (so we can return a proper function object,
66 // and not get wrapped in RuntimeMethod).  Also, use this for methods,
67 // so we can cache the JSValue* and return the same JSValue for the same
68 // identifier...
69 //
70 // Unfortunately... we need to gcProtect our JSValues, since we don't have
71 // access to an actual JS class that can mark() our JSValues.
72 //
73 JSValue* QtClass::fallbackObject(ExecState *exec, Instance *inst, const Identifier &identifier)
74 {
75     QtInstance* qtinst = static_cast<QtInstance*>(inst);
76
77     QByteArray name(identifier.ascii());
78
79     // First see if we have a cache hit
80     JSValue* val = qtinst->m_methods.value(name);
81     if (val)
82         return val;
83
84     // Nope, create an entry
85     QByteArray normal = QMetaObject::normalizedSignature(name.constData());
86
87     // See if there is an exact match
88     int index = -1;
89     if (normal.contains('(') && (index = m_metaObject->indexOfMethod(normal)) != -1) {
90         QMetaMethod m = m_metaObject->method(index);
91         if (m.access() != QMetaMethod::Private) {
92             JSValue *val = new QtRuntimeMetaMethod(exec, identifier, static_cast<QtInstance*>(inst), index, normal, false);
93             gcProtect(val);
94             qtinst->m_methods.insert(name, val);
95             return val;
96         }
97     }
98
99     // Nope.. try a basename match
100     int count = m_metaObject->methodCount();
101     for (index = count - 1; index >= 0; --index) {
102         const QMetaMethod m = m_metaObject->method(index);
103         if (m.access() == QMetaMethod::Private)
104             continue;
105
106         QByteArray signature = m.signature();
107         signature.truncate(signature.indexOf('('));
108
109         if (normal == signature) {
110             JSValue* val = new QtRuntimeMetaMethod(exec, identifier, static_cast<QtInstance*>(inst), index, normal, false);
111             gcProtect(val);
112             qtinst->m_methods.insert(name, val);
113             return val;
114         }
115     }
116
117     return jsUndefined();
118 }
119
120 // This functionality is handled by the fallback case above...
121 MethodList QtClass::methodsNamed(const Identifier&, Instance*) const
122 {
123     return MethodList();
124 }
125
126 // ### we may end up with a different search order than QtScript by not
127 // folding this code into the fallbackMethod above, but Fields propagate out
128 // of the binding code
129 Field* QtClass::fieldNamed(const Identifier& identifier, Instance* instance) const
130 {
131     // Check static properties first
132     QtInstance* qtinst = static_cast<QtInstance*>(instance);
133
134     QObject* obj = qtinst->getObject();
135     UString ustring = identifier.ustring();
136     QString objName(QString::fromUtf16((const ushort*)ustring.rep()->data(),ustring.size()));
137     QByteArray ba = objName.toAscii();
138
139     // First check for a cached field
140     QtField* f = qtinst->m_fields.value(objName);
141
142     if (obj) {
143         if (f) {
144             // We only cache real metaproperties, but we do store the
145             // other types so we can delete them later
146             if (f->fieldType() == QtField::MetaProperty)
147                 return f;
148             else if (f->fieldType() == QtField::DynamicProperty) {
149                 if (obj->dynamicPropertyNames().indexOf(ba) >= 0)
150                     return f;
151                 else {
152                     // Dynamic property that disappeared
153                     qtinst->m_fields.remove(objName);
154                     delete f;
155                 }
156             } else {
157                 QList<QObject*> children = obj->children();
158                 for (int index = 0; index < children.count(); ++index) {
159                     QObject *child = children.at(index);
160                     if (child->objectName() == objName)
161                         return f;
162                 }
163
164                 // Didn't find it, delete it from the cache
165                 qtinst->m_fields.remove(objName);
166                 delete f;
167             }
168         }
169
170         int index = m_metaObject->indexOfProperty(identifier.ascii());
171         if (index >= 0) {
172             QMetaProperty prop = m_metaObject->property(index);
173
174             if (prop.isScriptable(obj)) {
175                 f = new QtField(prop);
176                 qtinst->m_fields.insert(objName, f);
177                 return f;
178             }
179         }
180
181         // Dynamic properties
182         index = obj->dynamicPropertyNames().indexOf(ba);
183         if (index >= 0) {
184             f = new QtField(ba);
185             qtinst->m_fields.insert(objName, f);
186             return f;
187         }
188
189         // Child objects
190
191         QList<QObject*> children = obj->children();
192         for (index = 0; index < children.count(); ++index) {
193             QObject *child = children.at(index);
194             if (child->objectName() == objName) {
195                 f = new QtField(child);
196                 qtinst->m_fields.insert(objName, f);
197                 return f;
198             }
199         }
200
201         // Nothing named this
202         return 0;
203     } else {
204         QByteArray ba(identifier.ascii());
205         // For compatibility with qtscript, cached methods don't cause
206         // errors until they are accessed, so don't blindly create an error
207         // here.
208         if (qtinst->m_methods.contains(ba))
209             return 0;
210
211         // deleted qobject, but can't throw an error from here (no exec)
212         // create a fake QtField that will throw upon access
213         if (!f) {
214             f = new QtField(ba);
215             qtinst->m_fields.insert(objName, f);
216         }
217         return f;
218     }
219 }
220
221 }
222 }
223