← Back to branch summary

~ubuntu-branches/debian/jessie/ugene/jessie

« back to all changes in this revision

Viewing changes to src/libs_3rdparty/qtbindings_core/src/qtscript_QFile.cpp

  • Committer: Package Import Robot
  • Author(s): Steffen Moeller
  • Date: 2011-11-02 13:29:07 UTC
  • mfrom: (1.2.1) (3.1.11 natty)
  • Revision ID: package-import@ubuntu.com-20111102132907-o34gwnt0uj5g6hen
Tags: 1.9.8+repack-1
* First release to Debian
  - added README.Debian
  - increased policy version to 3.9.2
  - added URLs for version control system
* Added debug package.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/libs_3rdparty/qtbindings_core/src/qtscript_QFile.cpp
1
 
/*****************************************************************
2
 
* Unipro UGENE - Integrated Bioinformatics Suite
3
 
* Copyright (C) 2008 Unipro, Russia (http://ugene.unipro.ru)
4
 
* All Rights Reserved
5
 
* 
6
 
*     This source code is distributed under the terms of the
7
 
*     GNU General Public License. See the files COPYING and LICENSE
8
 
*     for details.
9
 
*****************************************************************/
10
 
 
11
 
#include <QtScript/QScriptEngine>
12
 
#include <QtScript/QScriptContext>
13
 
#include <QtScript/QScriptValue>
14
 
#include <QtCore/QStringList>
15
 
#include <QtCore/QDebug>
16
 
#include <qmetaobject.h>
17
 
 
18
 
#include <qfile.h>
19
 
#include <QVariant>
20
 
#include <qbytearray.h>
21
 
#include <qcoreevent.h>
22
 
#include <qfile.h>
23
 
#include <qlist.h>
24
 
#include <qobject.h>
25
 
 
26
 
#include "qtscriptshell_QFile.h"
27
 
 
28
 
static const char * const qtscript_QFile_function_names[] = {
29
 
    "QFile"
30
 
    // static
31
 
    , "copy"
32
 
    , "decodeName"
33
 
    , "encodeName"
34
 
    , "exists"
35
 
    , "link"
36
 
    , "permissions"
37
 
    , "remove"
38
 
    , "rename"
39
 
    , "resize"
40
 
    , "setPermissions"
41
 
    , "symLinkTarget"
42
 
    // prototype
43
 
    , "copy"
44
 
    , "error"
45
 
    , "exists"
46
 
    , "fileEngine"
47
 
    , "fileName"
48
 
    , "flush"
49
 
    , "handle"
50
 
    , "link"
51
 
    , "permissions"
52
 
    , "remove"
53
 
    , "rename"
54
 
    , "resize"
55
 
    , "setFileName"
56
 
    , "setPermissions"
57
 
    , "symLinkTarget"
58
 
    , "unsetError"
59
 
    , "toString"
60
 
};
61
 
 
62
 
static const char * const qtscript_QFile_function_signatures[] = {
63
 
    "\nQObject parent\nString name\nString name, QObject parent"
64
 
    // static
65
 
    , "String fileName, String newName"
66
 
    , "QByteArray localFileName"
67
 
    , "String fileName"
68
 
    , "String fileName"
69
 
    , "String oldname, String newName"
70
 
    , "String filename"
71
 
    , "String fileName"
72
 
    , "String oldName, String newName"
73
 
    , "String filename, qint64 sz"
74
 
    , "String filename, Permissions permissionSpec"
75
 
    , "String fileName"
76
 
    // prototype
77
 
    , "String newName"
78
 
    , ""
79
 
    , ""
80
 
    , ""
81
 
    , ""
82
 
    , ""
83
 
    , ""
84
 
    , "String newName"
85
 
    , ""
86
 
    , ""
87
 
    , "String newName"
88
 
    , "qint64 sz"
89
 
    , "String name"
90
 
    , "Permissions permissionSpec"
91
 
    , ""
92
 
    , ""
93
 
""
94
 
};
95
 
 
96
 
static QScriptValue qtscript_QFile_throw_ambiguity_error_helper(
97
 
    QScriptContext *context, const char *functionName, const char *signatures)
98
 
{
99
 
    QStringList lines = QString::fromLatin1(signatures).split(QLatin1Char('\n'));
100
 
    QStringList fullSignatures;
101
 
    for (int i = 0; i < lines.size(); ++i)
102
 
        fullSignatures.append(QString::fromLatin1("%0(%1)").arg(functionName).arg(lines.at(i)));
103
 
    return context->throwError(QString::fromLatin1("QFile::%0(): could not find a function match; candidates are:\n%1")
104
 
        .arg(functionName).arg(fullSignatures.join(QLatin1String("\n"))));
105
 
}
106
 
 
107
 
Q_DECLARE_METATYPE(QFile*)
108
 
Q_DECLARE_METATYPE(QtScriptShell_QFile*)
109
 
Q_DECLARE_METATYPE(QFile::FileError)
110
 
Q_DECLARE_METATYPE(QFile::MemoryMapFlags)
111
 
Q_DECLARE_METATYPE(QFile::Permission)
112
 
Q_DECLARE_METATYPE(QFlags<QFile::Permission>)
113
 
Q_DECLARE_METATYPE(QAbstractFileEngine*)
114
 
Q_DECLARE_METATYPE(QIODevice*)
115
 
 
116
 
static QScriptValue qtscript_create_enum_class_helper(
117
 
    QScriptEngine *engine,
118
 
    QScriptEngine::FunctionSignature construct,
119
 
    QScriptEngine::FunctionSignature valueOf,
120
 
    QScriptEngine::FunctionSignature toString)
121
 
{
122
 
    QScriptValue proto = engine->newObject();
123
 
    proto.setProperty(QString::fromLatin1("valueOf"),
124
 
        engine->newFunction(valueOf), QScriptValue::SkipInEnumeration);
125
 
    proto.setProperty(QString::fromLatin1("toString"),
126
 
        engine->newFunction(toString), QScriptValue::SkipInEnumeration);
127
 
    return engine->newFunction(construct, proto, 1);
128
 
}
129
 
 
130
 
static QScriptValue qtscript_create_flags_class_helper(
131
 
    QScriptEngine *engine,
132
 
    QScriptEngine::FunctionSignature construct,
133
 
    QScriptEngine::FunctionSignature valueOf,
134
 
    QScriptEngine::FunctionSignature toString,
135
 
    QScriptEngine::FunctionSignature equals)
136
 
{
137
 
    QScriptValue proto = engine->newObject();
138
 
    proto.setProperty(QString::fromLatin1("valueOf"),
139
 
        engine->newFunction(valueOf), QScriptValue::SkipInEnumeration);
140
 
    proto.setProperty(QString::fromLatin1("toString"),
141
 
        engine->newFunction(toString), QScriptValue::SkipInEnumeration);
142
 
    proto.setProperty(QString::fromLatin1("equals"),
143
 
        engine->newFunction(equals), QScriptValue::SkipInEnumeration);
144
 
    return engine->newFunction(construct, proto);
145
 
}
146
 
 
147
 
//
148
 
// QFile::FileError
149
 
//
150
 
 
151
 
static const QFile::FileError qtscript_QFile_FileError_values[] = {
152
 
    QFile::NoError
153
 
    , QFile::ReadError
154
 
    , QFile::WriteError
155
 
    , QFile::FatalError
156
 
    , QFile::ResourceError
157
 
    , QFile::OpenError
158
 
    , QFile::AbortError
159
 
    , QFile::TimeOutError
160
 
    , QFile::UnspecifiedError
161
 
    , QFile::RemoveError
162
 
    , QFile::RenameError
163
 
    , QFile::PositionError
164
 
    , QFile::ResizeError
165
 
    , QFile::PermissionsError
166
 
    , QFile::CopyError
167
 
};
168
 
 
169
 
static const char * const qtscript_QFile_FileError_keys[] = {
170
 
    "NoError"
171
 
    , "ReadError"
172
 
    , "WriteError"
173
 
    , "FatalError"
174
 
    , "ResourceError"
175
 
    , "OpenError"
176
 
    , "AbortError"
177
 
    , "TimeOutError"
178
 
    , "UnspecifiedError"
179
 
    , "RemoveError"
180
 
    , "RenameError"
181
 
    , "PositionError"
182
 
    , "ResizeError"
183
 
    , "PermissionsError"
184
 
    , "CopyError"
185
 
};
186
 
 
187
 
static QString qtscript_QFile_FileError_toStringHelper(QFile::FileError value)
188
 
{
189
 
    if ((value >= QFile::NoError) && (value <= QFile::CopyError))
190
 
        return qtscript_QFile_FileError_keys[static_cast<int>(value)];
191
 
    return QString();
192
 
}
193
 
 
194
 
static QScriptValue qtscript_QFile_FileError_toScriptValue(QScriptEngine *engine, const QFile::FileError &value)
195
 
{
196
 
    QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("QFile"));
197
 
    return clazz.property(qtscript_QFile_FileError_toStringHelper(value));
198
 
}
199
 
 
200
 
static void qtscript_QFile_FileError_fromScriptValue(const QScriptValue &value, QFile::FileError &out)
201
 
{
202
 
    out = qvariant_cast<QFile::FileError>(value.toVariant());
203
 
}
204
 
 
205
 
static QScriptValue qtscript_construct_QFile_FileError(QScriptContext *context, QScriptEngine *engine)
206
 
{
207
 
    int arg = context->argument(0).toInt32();
208
 
    if ((arg >= QFile::NoError) && (arg <= QFile::CopyError))
209
 
        return qScriptValueFromValue(engine,  static_cast<QFile::FileError>(arg));
210
 
    return context->throwError(QString::fromLatin1("FileError(): invalid enum value (%0)").arg(arg));
211
 
}
212
 
 
213
 
static QScriptValue qtscript_QFile_FileError_valueOf(QScriptContext *context, QScriptEngine *engine)
214
 
{
215
 
    QFile::FileError value = qscriptvalue_cast<QFile::FileError>(context->thisObject());
216
 
    return QScriptValue(engine, static_cast<int>(value));
217
 
}
218
 
 
219
 
static QScriptValue qtscript_QFile_FileError_toString(QScriptContext *context, QScriptEngine *engine)
220
 
{
221
 
    QFile::FileError value = qscriptvalue_cast<QFile::FileError>(context->thisObject());
222
 
    return QScriptValue(engine, qtscript_QFile_FileError_toStringHelper(value));
223
 
}
224
 
 
225
 
static QScriptValue qtscript_create_QFile_FileError_class(QScriptEngine *engine, QScriptValue &clazz)
226
 
{
227
 
    QScriptValue ctor = qtscript_create_enum_class_helper(
228
 
        engine, qtscript_construct_QFile_FileError,
229
 
        qtscript_QFile_FileError_valueOf, qtscript_QFile_FileError_toString);
230
 
    qScriptRegisterMetaType<QFile::FileError>(engine, qtscript_QFile_FileError_toScriptValue,
231
 
        qtscript_QFile_FileError_fromScriptValue, ctor.property(QString::fromLatin1("prototype")));
232
 
    for (int i = 0; i < 15; ++i) {
233
 
        clazz.setProperty(QString::fromLatin1(qtscript_QFile_FileError_keys[i]),
234
 
            engine->newVariant(qVariantFromValue(qtscript_QFile_FileError_values[i])),
235
 
            QScriptValue::ReadOnly | QScriptValue::Undeletable);
236
 
    }
237
 
    return ctor;
238
 
}
239
 
 
240
 
//
241
 
// QFile::MemoryMapFlags
242
 
//
243
 
 
244
 
static const QFile::MemoryMapFlags qtscript_QFile_MemoryMapFlags_values[] = {
245
 
    QFile::NoOptions
246
 
};
247
 
 
248
 
static const char * const qtscript_QFile_MemoryMapFlags_keys[] = {
249
 
    "NoOptions"
250
 
};
251
 
 
252
 
static QString qtscript_QFile_MemoryMapFlags_toStringHelper(QFile::MemoryMapFlags value)
253
 
{
254
 
    if ((value >= QFile::NoOptions) && (value <= QFile::NoOptions))
255
 
        return qtscript_QFile_MemoryMapFlags_keys[static_cast<int>(value)];
256
 
    return QString();
257
 
}
258
 
 
259
 
static QScriptValue qtscript_QFile_MemoryMapFlags_toScriptValue(QScriptEngine *engine, const QFile::MemoryMapFlags &value)
260
 
{
261
 
    QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("QFile"));
262
 
    return clazz.property(qtscript_QFile_MemoryMapFlags_toStringHelper(value));
263
 
}
264
 
 
265
 
static void qtscript_QFile_MemoryMapFlags_fromScriptValue(const QScriptValue &value, QFile::MemoryMapFlags &out)
266
 
{
267
 
    out = qvariant_cast<QFile::MemoryMapFlags>(value.toVariant());
268
 
}
269
 
 
270
 
static QScriptValue qtscript_construct_QFile_MemoryMapFlags(QScriptContext *context, QScriptEngine *engine)
271
 
{
272
 
    int arg = context->argument(0).toInt32();
273
 
    if ((arg >= QFile::NoOptions) && (arg <= QFile::NoOptions))
274
 
        return qScriptValueFromValue(engine,  static_cast<QFile::MemoryMapFlags>(arg));
275
 
    return context->throwError(QString::fromLatin1("MemoryMapFlags(): invalid enum value (%0)").arg(arg));
276
 
}
277
 
 
278
 
static QScriptValue qtscript_QFile_MemoryMapFlags_valueOf(QScriptContext *context, QScriptEngine *engine)
279
 
{
280
 
    QFile::MemoryMapFlags value = qscriptvalue_cast<QFile::MemoryMapFlags>(context->thisObject());
281
 
    return QScriptValue(engine, static_cast<int>(value));
282
 
}
283
 
 
284
 
static QScriptValue qtscript_QFile_MemoryMapFlags_toString(QScriptContext *context, QScriptEngine *engine)
285
 
{
286
 
    QFile::MemoryMapFlags value = qscriptvalue_cast<QFile::MemoryMapFlags>(context->thisObject());
287
 
    return QScriptValue(engine, qtscript_QFile_MemoryMapFlags_toStringHelper(value));
288
 
}
289
 
 
290
 
static QScriptValue qtscript_create_QFile_MemoryMapFlags_class(QScriptEngine *engine, QScriptValue &clazz)
291
 
{
292
 
    QScriptValue ctor = qtscript_create_enum_class_helper(
293
 
        engine, qtscript_construct_QFile_MemoryMapFlags,
294
 
        qtscript_QFile_MemoryMapFlags_valueOf, qtscript_QFile_MemoryMapFlags_toString);
295
 
    qScriptRegisterMetaType<QFile::MemoryMapFlags>(engine, qtscript_QFile_MemoryMapFlags_toScriptValue,
296
 
        qtscript_QFile_MemoryMapFlags_fromScriptValue, ctor.property(QString::fromLatin1("prototype")));
297
 
    for (int i = 0; i < 1; ++i) {
298
 
        clazz.setProperty(QString::fromLatin1(qtscript_QFile_MemoryMapFlags_keys[i]),
299
 
            engine->newVariant(qVariantFromValue(qtscript_QFile_MemoryMapFlags_values[i])),
300
 
            QScriptValue::ReadOnly | QScriptValue::Undeletable);
301
 
    }
302
 
    return ctor;
303
 
}
304
 
 
305
 
//
306
 
// QFile::Permission
307
 
//
308
 
 
309
 
static const QFile::Permission qtscript_QFile_Permission_values[] = {
310
 
    QFile::ExeOther
311
 
    , QFile::WriteOther
312
 
    , QFile::ReadOther
313
 
    , QFile::ExeGroup
314
 
    , QFile::WriteGroup
315
 
    , QFile::ReadGroup
316
 
    , QFile::ExeUser
317
 
    , QFile::WriteUser
318
 
    , QFile::ReadUser
319
 
    , QFile::ExeOwner
320
 
    , QFile::WriteOwner
321
 
    , QFile::ReadOwner
322
 
};
323
 
 
324
 
static const char * const qtscript_QFile_Permission_keys[] = {
325
 
    "ExeOther"
326
 
    , "WriteOther"
327
 
    , "ReadOther"
328
 
    , "ExeGroup"
329
 
    , "WriteGroup"
330
 
    , "ReadGroup"
331
 
    , "ExeUser"
332
 
    , "WriteUser"
333
 
    , "ReadUser"
334
 
    , "ExeOwner"
335
 
    , "WriteOwner"
336
 
    , "ReadOwner"
337
 
};
338
 
 
339
 
static QString qtscript_QFile_Permission_toStringHelper(QFile::Permission value)
340
 
{
341
 
    for (int i = 0; i < 12; ++i) {
342
 
        if (qtscript_QFile_Permission_values[i] == value)
343
 
            return QString::fromLatin1(qtscript_QFile_Permission_keys[i]);
344
 
    }
345
 
    return QString();
346
 
}
347
 
 
348
 
static QScriptValue qtscript_QFile_Permission_toScriptValue(QScriptEngine *engine, const QFile::Permission &value)
349
 
{
350
 
    QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("QFile"));
351
 
    return clazz.property(qtscript_QFile_Permission_toStringHelper(value));
352
 
}
353
 
 
354
 
static void qtscript_QFile_Permission_fromScriptValue(const QScriptValue &value, QFile::Permission &out)
355
 
{
356
 
    out = qvariant_cast<QFile::Permission>(value.toVariant());
357
 
}
358
 
 
359
 
static QScriptValue qtscript_construct_QFile_Permission(QScriptContext *context, QScriptEngine *engine)
360
 
{
361
 
    int arg = context->argument(0).toInt32();
362
 
    for (int i = 0; i < 12; ++i) {
363
 
        if (qtscript_QFile_Permission_values[i] == arg)
364
 
            return qScriptValueFromValue(engine,  static_cast<QFile::Permission>(arg));
365
 
    }
366
 
    return context->throwError(QString::fromLatin1("Permission(): invalid enum value (%0)").arg(arg));
367
 
}
368
 
 
369
 
static QScriptValue qtscript_QFile_Permission_valueOf(QScriptContext *context, QScriptEngine *engine)
370
 
{
371
 
    QFile::Permission value = qscriptvalue_cast<QFile::Permission>(context->thisObject());
372
 
    return QScriptValue(engine, static_cast<int>(value));
373
 
}
374
 
 
375
 
static QScriptValue qtscript_QFile_Permission_toString(QScriptContext *context, QScriptEngine *engine)
376
 
{
377
 
    QFile::Permission value = qscriptvalue_cast<QFile::Permission>(context->thisObject());
378
 
    return QScriptValue(engine, qtscript_QFile_Permission_toStringHelper(value));
379
 
}
380
 
 
381
 
static QScriptValue qtscript_create_QFile_Permission_class(QScriptEngine *engine, QScriptValue &clazz)
382
 
{
383
 
    QScriptValue ctor = qtscript_create_enum_class_helper(
384
 
        engine, qtscript_construct_QFile_Permission,
385
 
        qtscript_QFile_Permission_valueOf, qtscript_QFile_Permission_toString);
386
 
    qScriptRegisterMetaType<QFile::Permission>(engine, qtscript_QFile_Permission_toScriptValue,
387
 
        qtscript_QFile_Permission_fromScriptValue, ctor.property(QString::fromLatin1("prototype")));
388
 
    for (int i = 0; i < 12; ++i) {
389
 
        clazz.setProperty(QString::fromLatin1(qtscript_QFile_Permission_keys[i]),
390
 
            engine->newVariant(qVariantFromValue(qtscript_QFile_Permission_values[i])),
391
 
            QScriptValue::ReadOnly | QScriptValue::Undeletable);
392
 
    }
393
 
    return ctor;
394
 
}
395
 
 
396
 
//
397
 
// QFile::Permissions
398
 
//
399
 
 
400
 
static QScriptValue qtscript_QFile_Permissions_toScriptValue(QScriptEngine *engine, const QFile::Permissions &value)
401
 
{
402
 
    return engine->newVariant(qVariantFromValue(value));
403
 
}
404
 
 
405
 
static void qtscript_QFile_Permissions_fromScriptValue(const QScriptValue &value, QFile::Permissions &out)
406
 
{
407
 
    QVariant var = value.toVariant();
408
 
    if (var.userType() == qMetaTypeId<QFile::Permissions>())
409
 
        out = qvariant_cast<QFile::Permissions>(var);
410
 
    else if (var.userType() == qMetaTypeId<QFile::Permission>())
411
 
        out = qvariant_cast<QFile::Permission>(var);
412
 
    else
413
 
        out = 0;
414
 
}
415
 
 
416
 
static QScriptValue qtscript_construct_QFile_Permissions(QScriptContext *context, QScriptEngine *engine)
417
 
{
418
 
    QFile::Permissions result = 0;
419
 
    if ((context->argumentCount() == 1) && context->argument(0).isNumber()) {
420
 
        result = static_cast<QFile::Permissions>(context->argument(0).toInt32());
421
 
    } else {
422
 
        for (int i = 0; i < context->argumentCount(); ++i) {
423
 
            QVariant v = context->argument(i).toVariant();
424
 
            if (v.userType() != qMetaTypeId<QFile::Permission>()) {
425
 
                return context->throwError(QScriptContext::TypeError,
426
 
                    QString::fromLatin1("Permissions(): argument %0 is not of type Permission").arg(i));
427
 
            }
428
 
            result |= qvariant_cast<QFile::Permission>(v);
429
 
        }
430
 
   }
431
 
    return engine->newVariant(qVariantFromValue(result));
432
 
}
433
 
 
434
 
static QScriptValue qtscript_QFile_Permissions_valueOf(QScriptContext *context, QScriptEngine *engine)
435
 
{
436
 
    QFile::Permissions value = qscriptvalue_cast<QFile::Permissions>(context->thisObject());
437
 
    return QScriptValue(engine, static_cast<int>(value));
438
 
}
439
 
 
440
 
static QScriptValue qtscript_QFile_Permissions_toString(QScriptContext *context, QScriptEngine *engine)
441
 
{
442
 
    QFile::Permissions value = qscriptvalue_cast<QFile::Permissions>(context->thisObject());
443
 
    QString result;
444
 
    for (int i = 0; i < 12; ++i) {
445
 
        if ((value & qtscript_QFile_Permission_values[i]) == qtscript_QFile_Permission_values[i]) {
446
 
            if (!result.isEmpty())
447
 
                result.append(QString::fromLatin1(","));
448
 
            result.append(QString::fromLatin1(qtscript_QFile_Permission_keys[i]));
449
 
        }
450
 
    }
451
 
    return QScriptValue(engine, result);
452
 
}
453
 
 
454
 
static QScriptValue qtscript_QFile_Permissions_equals(QScriptContext *context, QScriptEngine *engine)
455
 
{
456
 
    QVariant thisObj = context->thisObject().toVariant();
457
 
    QVariant otherObj = context->argument(0).toVariant();
458
 
    return QScriptValue(engine, ((thisObj.userType() == otherObj.userType()) &&
459
 
                                 (thisObj.value<QFile::Permissions>() == otherObj.value<QFile::Permissions>())));
460
 
}
461
 
 
462
 
static QScriptValue qtscript_create_QFile_Permissions_class(QScriptEngine *engine)
463
 
{
464
 
    QScriptValue ctor = qtscript_create_flags_class_helper(
465
 
        engine, qtscript_construct_QFile_Permissions, qtscript_QFile_Permissions_valueOf,
466
 
        qtscript_QFile_Permissions_toString, qtscript_QFile_Permissions_equals);
467
 
    qScriptRegisterMetaType<QFile::Permissions>(engine, qtscript_QFile_Permissions_toScriptValue,
468
 
        qtscript_QFile_Permissions_fromScriptValue, ctor.property(QString::fromLatin1("prototype")));
469
 
    return ctor;
470
 
}
471
 
 
472
 
//
473
 
// QFile
474
 
//
475
 
 
476
 
static QScriptValue qtscript_QFile_prototype_call(QScriptContext *context, QScriptEngine *)
477
 
{
478
 
#if QT_VERSION > 0x040400
479
 
    Q_ASSERT(context->callee().isFunction());
480
 
    uint _id = context->callee().data().toUInt32();
481
 
#else
482
 
    uint _id;
483
 
    if (context->callee().isFunction())
484
 
        _id = context->callee().data().toUInt32();
485
 
    else
486
 
        _id = 0xBABE0000 + 16;
487
 
#endif
488
 
    Q_ASSERT((_id & 0xFFFF0000) == 0xBABE0000);
489
 
    _id &= 0x0000FFFF;
490
 
    QFile* _q_self = qscriptvalue_cast<QFile*>(context->thisObject());
491
 
    if (!_q_self) {
492
 
        return context->throwError(QScriptContext::TypeError,
493
 
            QString::fromLatin1("QFile.%0(): this object is not a QFile")
494
 
            .arg(qtscript_QFile_function_names[_id+1]));
495
 
    }
496
 
 
497
 
    switch (_id) {
498
 
    case 0:
499
 
    if (context->argumentCount() == 1) {
500
 
        QString _q_arg0 = context->argument(0).toString();
501
 
        bool _q_result = _q_self->copy(_q_arg0);
502
 
        return QScriptValue(context->engine(), _q_result);
503
 
    }
504
 
    break;
505
 
 
506
 
    case 1:
507
 
    if (context->argumentCount() == 0) {
508
 
        QFile::FileError _q_result = _q_self->error();
509
 
        return qScriptValueFromValue(context->engine(), _q_result);
510
 
    }
511
 
    break;
512
 
 
513
 
    case 2:
514
 
    if (context->argumentCount() == 0) {
515
 
        bool _q_result = _q_self->exists();
516
 
        return QScriptValue(context->engine(), _q_result);
517
 
    }
518
 
    break;
519
 
 
520
 
    case 3:
521
 
    if (context->argumentCount() == 0) {
522
 
        QAbstractFileEngine* _q_result = _q_self->fileEngine();
523
 
        return qScriptValueFromValue(context->engine(), _q_result);
524
 
    }
525
 
    break;
526
 
 
527
 
    case 4:
528
 
    if (context->argumentCount() == 0) {
529
 
        QString _q_result = _q_self->fileName();
530
 
        return QScriptValue(context->engine(), _q_result);
531
 
    }
532
 
    break;
533
 
 
534
 
    case 5:
535
 
    if (context->argumentCount() == 0) {
536
 
        bool _q_result = _q_self->flush();
537
 
        return QScriptValue(context->engine(), _q_result);
538
 
    }
539
 
    break;
540
 
 
541
 
    case 6:
542
 
    if (context->argumentCount() == 0) {
543
 
        int _q_result = _q_self->handle();
544
 
        return QScriptValue(context->engine(), _q_result);
545
 
    }
546
 
    break;
547
 
 
548
 
    case 7:
549
 
    if (context->argumentCount() == 1) {
550
 
        QString _q_arg0 = context->argument(0).toString();
551
 
        bool _q_result = _q_self->link(_q_arg0);
552
 
        return QScriptValue(context->engine(), _q_result);
553
 
    }
554
 
    break;
555
 
 
556
 
    case 8:
557
 
    if (context->argumentCount() == 0) {
558
 
        QFlags<QFile::Permission> _q_result = _q_self->permissions();
559
 
        return qScriptValueFromValue(context->engine(), _q_result);
560
 
    }
561
 
    break;
562
 
 
563
 
    case 9:
564
 
    if (context->argumentCount() == 0) {
565
 
        bool _q_result = _q_self->remove();
566
 
        return QScriptValue(context->engine(), _q_result);
567
 
    }
568
 
    break;
569
 
 
570
 
    case 10:
571
 
    if (context->argumentCount() == 1) {
572
 
        QString _q_arg0 = context->argument(0).toString();
573
 
        bool _q_result = _q_self->rename(_q_arg0);
574
 
        return QScriptValue(context->engine(), _q_result);
575
 
    }
576
 
    break;
577
 
 
578
 
    case 11:
579
 
    if (context->argumentCount() == 1) {
580
 
        qint64 _q_arg0 = qscriptvalue_cast<qint64>(context->argument(0));
581
 
        bool _q_result = _q_self->resize(_q_arg0);
582
 
        return QScriptValue(context->engine(), _q_result);
583
 
    }
584
 
    break;
585
 
 
586
 
    case 12:
587
 
    if (context->argumentCount() == 1) {
588
 
        QString _q_arg0 = context->argument(0).toString();
589
 
        _q_self->setFileName(_q_arg0);
590
 
        return context->engine()->undefinedValue();
591
 
    }
592
 
    break;
593
 
 
594
 
    case 13:
595
 
    if (context->argumentCount() == 1) {
596
 
        QFlags<QFile::Permission> _q_arg0 = qscriptvalue_cast<QFlags<QFile::Permission> >(context->argument(0));
597
 
        bool _q_result = _q_self->setPermissions(_q_arg0);
598
 
        return QScriptValue(context->engine(), _q_result);
599
 
    }
600
 
    break;
601
 
 
602
 
    case 14:
603
 
    if (context->argumentCount() == 0) {
604
 
        QString _q_result = _q_self->symLinkTarget();
605
 
        return QScriptValue(context->engine(), _q_result);
606
 
    }
607
 
    break;
608
 
 
609
 
    case 15:
610
 
    if (context->argumentCount() == 0) {
611
 
        _q_self->unsetError();
612
 
        return context->engine()->undefinedValue();
613
 
    }
614
 
    break;
615
 
 
616
 
    case 16: {
617
 
    QString result = QString::fromLatin1("QFile");
618
 
    return QScriptValue(context->engine(), result);
619
 
    }
620
 
 
621
 
    default:
622
 
    Q_ASSERT(false);
623
 
    }
624
 
    return qtscript_QFile_throw_ambiguity_error_helper(context,
625
 
        qtscript_QFile_function_names[_id+12],
626
 
        qtscript_QFile_function_signatures[_id+12]);
627
 
}
628
 
 
629
 
static QScriptValue qtscript_QFile_static_call(QScriptContext *context, QScriptEngine *)
630
 
{
631
 
    uint _id = context->callee().data().toUInt32();
632
 
    Q_ASSERT((_id & 0xFFFF0000) == 0xBABE0000);
633
 
    _id &= 0x0000FFFF;
634
 
    switch (_id) {
635
 
    case 0:
636
 
    if (context->thisObject().strictlyEquals(context->engine()->globalObject())) {
637
 
        return context->throwError(QString::fromLatin1("QFile(): Did you forget to construct with 'new'?"));
638
 
    }
639
 
    if (context->argumentCount() == 0) {
640
 
        QtScriptShell_QFile* _q_cpp_result = new QtScriptShell_QFile();
641
 
        QScriptValue _q_result = context->engine()->newQObject(context->thisObject(), (QFile*)_q_cpp_result, QScriptEngine::AutoOwnership);
642
 
        _q_cpp_result->__qtscript_self = _q_result;
643
 
        return _q_result;
644
 
    } else if (context->argumentCount() == 1) {
645
 
        if (context->argument(0).isQObject()) {
646
 
            QObject* _q_arg0 = context->argument(0).toQObject();
647
 
            QtScriptShell_QFile* _q_cpp_result = new QtScriptShell_QFile(_q_arg0);
648
 
            QScriptValue _q_result = context->engine()->newQObject(context->thisObject(), (QFile*)_q_cpp_result, QScriptEngine::AutoOwnership);
649
 
            _q_cpp_result->__qtscript_self = _q_result;
650
 
            return _q_result;
651
 
        } else if (context->argument(0).isString()) {
652
 
            QString _q_arg0 = context->argument(0).toString();
653
 
            QtScriptShell_QFile* _q_cpp_result = new QtScriptShell_QFile(_q_arg0);
654
 
            QScriptValue _q_result = context->engine()->newQObject(context->thisObject(), (QFile*)_q_cpp_result, QScriptEngine::AutoOwnership);
655
 
            _q_cpp_result->__qtscript_self = _q_result;
656
 
            return _q_result;
657
 
        }
658
 
    } else if (context->argumentCount() == 2) {
659
 
        QString _q_arg0 = context->argument(0).toString();
660
 
        QObject* _q_arg1 = context->argument(1).toQObject();
661
 
        QtScriptShell_QFile* _q_cpp_result = new QtScriptShell_QFile(_q_arg0, _q_arg1);
662
 
        QScriptValue _q_result = context->engine()->newQObject(context->thisObject(), (QFile*)_q_cpp_result, QScriptEngine::AutoOwnership);
663
 
        _q_cpp_result->__qtscript_self = _q_result;
664
 
        return _q_result;
665
 
    }
666
 
    break;
667
 
 
668
 
    case 1:
669
 
    if (context->argumentCount() == 2) {
670
 
        QString _q_arg0 = context->argument(0).toString();
671
 
        QString _q_arg1 = context->argument(1).toString();
672
 
        bool _q_result = QFile::copy(_q_arg0, _q_arg1);
673
 
        return QScriptValue(context->engine(), _q_result);
674
 
    }
675
 
    break;
676
 
 
677
 
    case 2:
678
 
    if (context->argumentCount() == 1) {
679
 
        QByteArray _q_arg0 = qscriptvalue_cast<QByteArray>(context->argument(0));
680
 
        QString _q_result = QFile::decodeName(_q_arg0);
681
 
        return QScriptValue(context->engine(), _q_result);
682
 
    }
683
 
    break;
684
 
 
685
 
    case 3:
686
 
    if (context->argumentCount() == 1) {
687
 
        QString _q_arg0 = context->argument(0).toString();
688
 
        QByteArray _q_result = QFile::encodeName(_q_arg0);
689
 
        return qScriptValueFromValue(context->engine(), _q_result);
690
 
    }
691
 
    break;
692
 
 
693
 
    case 4:
694
 
    if (context->argumentCount() == 1) {
695
 
        QString _q_arg0 = context->argument(0).toString();
696
 
        bool _q_result = QFile::exists(_q_arg0);
697
 
        return QScriptValue(context->engine(), _q_result);
698
 
    }
699
 
    break;
700
 
 
701
 
    case 5:
702
 
    if (context->argumentCount() == 2) {
703
 
        QString _q_arg0 = context->argument(0).toString();
704
 
        QString _q_arg1 = context->argument(1).toString();
705
 
        bool _q_result = QFile::link(_q_arg0, _q_arg1);
706
 
        return QScriptValue(context->engine(), _q_result);
707
 
    }
708
 
    break;
709
 
 
710
 
    case 6:
711
 
    if (context->argumentCount() == 1) {
712
 
        QString _q_arg0 = context->argument(0).toString();
713
 
        QFlags<QFile::Permission> _q_result = QFile::permissions(_q_arg0);
714
 
        return qScriptValueFromValue(context->engine(), _q_result);
715
 
    }
716
 
    break;
717
 
 
718
 
    case 7:
719
 
    if (context->argumentCount() == 1) {
720
 
        QString _q_arg0 = context->argument(0).toString();
721
 
        bool _q_result = QFile::remove(_q_arg0);
722
 
        return QScriptValue(context->engine(), _q_result);
723
 
    }
724
 
    break;
725
 
 
726
 
    case 8:
727
 
    if (context->argumentCount() == 2) {
728
 
        QString _q_arg0 = context->argument(0).toString();
729
 
        QString _q_arg1 = context->argument(1).toString();
730
 
        bool _q_result = QFile::rename(_q_arg0, _q_arg1);
731
 
        return QScriptValue(context->engine(), _q_result);
732
 
    }
733
 
    break;
734
 
 
735
 
    case 9:
736
 
    if (context->argumentCount() == 2) {
737
 
        QString _q_arg0 = context->argument(0).toString();
738
 
        qint64 _q_arg1 = qscriptvalue_cast<qint64>(context->argument(1));
739
 
        bool _q_result = QFile::resize(_q_arg0, _q_arg1);
740
 
        return QScriptValue(context->engine(), _q_result);
741
 
    }
742
 
    break;
743
 
 
744
 
    case 10:
745
 
    if (context->argumentCount() == 2) {
746
 
        QString _q_arg0 = context->argument(0).toString();
747
 
        QFlags<QFile::Permission> _q_arg1 = qscriptvalue_cast<QFlags<QFile::Permission> >(context->argument(1));
748
 
        bool _q_result = QFile::setPermissions(_q_arg0, _q_arg1);
749
 
        return QScriptValue(context->engine(), _q_result);
750
 
    }
751
 
    break;
752
 
 
753
 
    case 11:
754
 
    if (context->argumentCount() == 1) {
755
 
        QString _q_arg0 = context->argument(0).toString();
756
 
        QString _q_result = QFile::symLinkTarget(_q_arg0);
757
 
        return QScriptValue(context->engine(), _q_result);
758
 
    }
759
 
    break;
760
 
 
761
 
    default:
762
 
    Q_ASSERT(false);
763
 
    }
764
 
    return qtscript_QFile_throw_ambiguity_error_helper(context,
765
 
        qtscript_QFile_function_names[_id],
766
 
        qtscript_QFile_function_signatures[_id]);
767
 
}
768
 
 
769
 
static QScriptValue qtscript_QFile_toScriptValue(QScriptEngine *engine, QFile* const &in)
770
 
{
771
 
    return engine->newQObject(in, QScriptEngine::QtOwnership, QScriptEngine::PreferExistingWrapperObject);
772
 
}
773
 
 
774
 
static void qtscript_QFile_fromScriptValue(const QScriptValue &value, QFile* &out)
775
 
{
776
 
    out = qobject_cast<QFile*>(value.toQObject());
777
 
}
778
 
 
779
 
QScriptValue qtscript_create_QFile_class(QScriptEngine *engine)
780
 
{
781
 
    static const int function_lengths[] = {
782
 
        2
783
 
        // static
784
 
        , 2
785
 
        , 1
786
 
        , 1
787
 
        , 1
788
 
        , 2
789
 
        , 1
790
 
        , 1
791
 
        , 2
792
 
        , 2
793
 
        , 2
794
 
        , 1
795
 
        // prototype
796
 
        , 1
797
 
        , 0
798
 
        , 0
799
 
        , 0
800
 
        , 0
801
 
        , 0
802
 
        , 0
803
 
        , 1
804
 
        , 0
805
 
        , 0
806
 
        , 1
807
 
        , 1
808
 
        , 1
809
 
        , 1
810
 
        , 0
811
 
        , 0
812
 
        , 0
813
 
    };
814
 
    engine->setDefaultPrototype(qMetaTypeId<QFile*>(), QScriptValue());
815
 
    QScriptValue proto = engine->newVariant(qVariantFromValue((QFile*)0));
816
 
    proto.setPrototype(engine->defaultPrototype(qMetaTypeId<QIODevice*>()));
817
 
    for (int i = 0; i < 17; ++i) {
818
 
        QScriptValue fun = engine->newFunction(qtscript_QFile_prototype_call, function_lengths[i+12]);
819
 
        fun.setData(QScriptValue(engine, uint(0xBABE0000 + i)));
820
 
        proto.setProperty(QString::fromLatin1(qtscript_QFile_function_names[i+12]),
821
 
            fun, QScriptValue::SkipInEnumeration);
822
 
    }
823
 
 
824
 
    qScriptRegisterMetaType<QFile*>(engine, qtscript_QFile_toScriptValue, 
825
 
        qtscript_QFile_fromScriptValue, proto);
826
 
 
827
 
    QScriptValue ctor = engine->newFunction(qtscript_QFile_static_call, proto, function_lengths[0]);
828
 
    ctor.setData(QScriptValue(engine, uint(0xBABE0000 + 0)));
829
 
    for (int i = 0; i < 11; ++i) {
830
 
        QScriptValue fun = engine->newFunction(qtscript_QFile_static_call,
831
 
            function_lengths[i+1]);
832
 
        fun.setData(QScriptValue(engine, uint(0xBABE0000 + i+1)));
833
 
        ctor.setProperty(QString::fromLatin1(qtscript_QFile_function_names[i+1]),
834
 
            fun, QScriptValue::SkipInEnumeration);
835
 
    }
836
 
 
837
 
    ctor.setProperty(QString::fromLatin1("FileError"),
838
 
        qtscript_create_QFile_FileError_class(engine, ctor));
839
 
    ctor.setProperty(QString::fromLatin1("MemoryMapFlags"),
840
 
        qtscript_create_QFile_MemoryMapFlags_class(engine, ctor));
841
 
    ctor.setProperty(QString::fromLatin1("Permission"),
842
 
        qtscript_create_QFile_Permission_class(engine, ctor));
843
 
    ctor.setProperty(QString::fromLatin1("Permissions"),
844
 
        qtscript_create_QFile_Permissions_class(engine));
845
 
    return ctor;
846
 
}