← Back to branch summary

~ubuntu-branches/ubuntu/wily/qtdeclarative-opensource-src/wily-proposed

« back to all changes in this revision

Viewing changes to src/qml/jsruntime/qv4managed.cpp

  • Committer: Package Import Robot
  • Author(s): Ricardo Salveti de Araujo, Ricardo Salveti de Araujo, Timo Jyrinki
  • Date: 2014-06-19 02:39:21 UTC
  • mfrom: (0.1.18 experimental)
  • Revision ID: package-import@ubuntu.com-20140619023921-yb2oasnuetz9b0fc
Tags: 5.3.0-3ubuntu4
[ Ricardo Salveti de Araujo ]
* debian/control:
  - Updating dependencies as we now also have libqt5quickwidgets5-gles
* libqt5quickwidgets5.symbols: updating to allow gles variant

[ Timo Jyrinki ]
* Update libqt5quickparticles5.symbols from build logs

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/qml/jsruntime/qv4managed.cpp
47
47
 
48
48
const ManagedVTable Managed::static_vtbl =
49
49
{
50
 
    call,
51
 
    construct,
 
50
    Managed::IsExecutionContext,
 
51
    Managed::IsString,
 
52
    Managed::IsObject,
 
53
    Managed::IsFunctionObject,
 
54
    Managed::IsErrorObject,
 
55
    Managed::IsArrayData,
 
56
    0,
 
57
    Managed::MyType,
 
58
    "Managed",
 
59
    destroy,
52
60
    0 /*markObjects*/,
53
 
    destroy,
54
 
    0 /*collectDeletables*/,
55
 
    0,
56
 
    0,
57
 
    0,
58
 
    0,
59
 
    0,
60
 
    0,
61
 
    0,
62
 
    0,
63
 
    0,
64
 
    0,
65
 
    isEqualTo,
66
 
    0,
67
 
    "Managed",
 
61
    isEqualTo
68
62
};
69
63
 
70
64
 
101
95
QString Managed::className() const
102
96
{
103
97
    const char *s = 0;
104
 
    switch (Type(type)) {
 
98
    switch (Type(internalClass->vtable->type)) {
105
99
    case Type_Invalid:
106
100
    case Type_String:
107
101
        return QString();
157
151
    case Type_ArgumentsObject:
158
152
        s = "Arguments";
159
153
        break;
160
 
    case Type_JSONObject:
 
154
    case Type_JsonObject:
161
155
        s = "JSON";
162
156
        break;
163
157
    case Type_MathObject:
164
158
        s = "Math";
165
159
        break;
 
160
 
 
161
    case Type_ExecutionContext:
 
162
        s = "__ExecutionContext";
 
163
        break;
166
164
    case Type_ForeachIteratorObject:
167
165
        s = "__ForeachIterator";
168
166
        break;
169
167
    case Type_RegExp:
170
 
        s = "RegExp";
 
168
        s = "__RegExp";
171
169
        break;
 
170
 
172
171
    case Type_QmlSequence:
173
172
        s = "QmlSequence";
174
173
        break;
182
181
    internalClass = internalClass->changeVTable(vt);
183
182
}
184
183
 
185
 
ReturnedValue Managed::construct(Managed *m, CallData *)
186
 
{
187
 
    return m->engine()->currentContext()->throwTypeError();
188
 
}
189
 
 
190
 
ReturnedValue Managed::call(Managed *m, CallData *)
191
 
{
192
 
    return m->engine()->currentContext()->throwTypeError();
193
 
}
194
 
 
195
 
ReturnedValue Managed::getLookup(Managed *m, Lookup *)
196
 
{
197
 
    return m->engine()->currentContext()->throwTypeError();
198
 
}
199
 
 
200
 
void Managed::setLookup(Managed *m, Lookup *, const ValueRef)
201
 
{
202
 
    m->engine()->currentContext()->throwTypeError();
203
 
}
204
 
 
205
184
bool Managed::isEqualTo(Managed *, Managed *)
206
185
{
207
186
    return false;
208
187
}
209
 
 
210
 
ReturnedValue Managed::get(const StringRef name, bool *hasProperty)
211
 
{
212
 
    return internalClass->vtable->get(this, name, hasProperty);
213
 
}
214
 
 
215
 
ReturnedValue Managed::getIndexed(uint index, bool *hasProperty)
216
 
{
217
 
    return internalClass->vtable->getIndexed(this, index, hasProperty);
218
 
}
219
 
 
220
 
void Managed::put(const StringRef name, const ValueRef value)
221
 
{
222
 
    internalClass->vtable->put(this, name, value);
223
 
}
224
 
 
225
 
void Managed::setLookup(Lookup *l, const ValueRef v)
226
 
{
227
 
    internalClass->vtable->setLookup(this, l, v);
228
 
}
229
 
 
230
 
void Managed::putIndexed(uint index, const ValueRef value)
231
 
{
232
 
    internalClass->vtable->putIndexed(this, index, value);
233
 
}
234
 
 
235
 
PropertyAttributes Managed::query(StringRef name) const
236
 
{
237
 
    return internalClass->vtable->query(this, name);
238
 
}
239
 
 
240
 
bool Managed::deleteProperty(const StringRef name)
241
 
{
242
 
    return internalClass->vtable->deleteProperty(this, name);
243
 
}
244
 
 
245
 
Property *Managed::advanceIterator(ObjectIterator *it, StringRef name, uint *index, PropertyAttributes *attributes)
246
 
{
247
 
    return internalClass->vtable->advanceIterator(this, it, name, index, attributes);
248
 
}