← Back to branch summary

~ubuntu-branches/ubuntu/karmic/ugene/karmic

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Ivan Efremov
  • Date: 2009-01-26 19:17:51 UTC
  • Revision ID: james.westby@ubuntu.com-20090126191751-9kqqevd3yf4o098r
Tags: upstream-1.3.2+repack
Import upstream version 1.3.2+repack

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/libs_3rdparty/qtbindings_core/src/qtscript_QLibraryInfo.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 <qlibraryinfo.h>
 
19
#include <QVariant>
 
20
 
 
21
static const char * const qtscript_QLibraryInfo_function_names[] = {
 
22
    "QLibraryInfo"
 
23
    // static
 
24
    , "buildKey"
 
25
    , "licensedProducts"
 
26
    , "licensee"
 
27
    , "location"
 
28
    // prototype
 
29
    , "toString"
 
30
};
 
31
 
 
32
static const char * const qtscript_QLibraryInfo_function_signatures[] = {
 
33
    ""
 
34
    // static
 
35
    , ""
 
36
    , ""
 
37
    , ""
 
38
    , "LibraryLocation arg__1"
 
39
    // prototype
 
40
""
 
41
};
 
42
 
 
43
static QScriptValue qtscript_QLibraryInfo_throw_ambiguity_error_helper(
 
44
    QScriptContext *context, const char *functionName, const char *signatures)
 
45
{
 
46
    QStringList lines = QString::fromLatin1(signatures).split(QLatin1Char('\n'));
 
47
    QStringList fullSignatures;
 
48
    for (int i = 0; i < lines.size(); ++i)
 
49
        fullSignatures.append(QString::fromLatin1("%0(%1)").arg(functionName).arg(lines.at(i)));
 
50
    return context->throwError(QString::fromLatin1("QFile::%0(): could not find a function match; candidates are:\n%1")
 
51
        .arg(functionName).arg(fullSignatures.join(QLatin1String("\n"))));
 
52
}
 
53
 
 
54
Q_DECLARE_METATYPE(QLibraryInfo*)
 
55
Q_DECLARE_METATYPE(QLibraryInfo::LibraryLocation)
 
56
 
 
57
static QScriptValue qtscript_create_enum_class_helper(
 
58
    QScriptEngine *engine,
 
59
    QScriptEngine::FunctionSignature construct,
 
60
    QScriptEngine::FunctionSignature valueOf,
 
61
    QScriptEngine::FunctionSignature toString)
 
62
{
 
63
    QScriptValue proto = engine->newObject();
 
64
    proto.setProperty(QString::fromLatin1("valueOf"),
 
65
        engine->newFunction(valueOf), QScriptValue::SkipInEnumeration);
 
66
    proto.setProperty(QString::fromLatin1("toString"),
 
67
        engine->newFunction(toString), QScriptValue::SkipInEnumeration);
 
68
    return engine->newFunction(construct, proto, 1);
 
69
}
 
70
 
 
71
//
 
72
// QLibraryInfo::LibraryLocation
 
73
//
 
74
 
 
75
static const QLibraryInfo::LibraryLocation qtscript_QLibraryInfo_LibraryLocation_values[] = {
 
76
    QLibraryInfo::PrefixPath
 
77
    , QLibraryInfo::DocumentationPath
 
78
    , QLibraryInfo::HeadersPath
 
79
    , QLibraryInfo::LibrariesPath
 
80
    , QLibraryInfo::BinariesPath
 
81
    , QLibraryInfo::PluginsPath
 
82
    , QLibraryInfo::DataPath
 
83
    , QLibraryInfo::TranslationsPath
 
84
    , QLibraryInfo::SettingsPath
 
85
    , QLibraryInfo::DemosPath
 
86
    , QLibraryInfo::ExamplesPath
 
87
};
 
88
 
 
89
static const char * const qtscript_QLibraryInfo_LibraryLocation_keys[] = {
 
90
    "PrefixPath"
 
91
    , "DocumentationPath"
 
92
    , "HeadersPath"
 
93
    , "LibrariesPath"
 
94
    , "BinariesPath"
 
95
    , "PluginsPath"
 
96
    , "DataPath"
 
97
    , "TranslationsPath"
 
98
    , "SettingsPath"
 
99
    , "DemosPath"
 
100
    , "ExamplesPath"
 
101
};
 
102
 
 
103
static QString qtscript_QLibraryInfo_LibraryLocation_toStringHelper(QLibraryInfo::LibraryLocation value)
 
104
{
 
105
    if ((value >= QLibraryInfo::PrefixPath) && (value <= QLibraryInfo::ExamplesPath))
 
106
        return qtscript_QLibraryInfo_LibraryLocation_keys[static_cast<int>(value)];
 
107
    return QString();
 
108
}
 
109
 
 
110
static QScriptValue qtscript_QLibraryInfo_LibraryLocation_toScriptValue(QScriptEngine *engine, const QLibraryInfo::LibraryLocation &value)
 
111
{
 
112
    QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("QLibraryInfo"));
 
113
    return clazz.property(qtscript_QLibraryInfo_LibraryLocation_toStringHelper(value));
 
114
}
 
115
 
 
116
static void qtscript_QLibraryInfo_LibraryLocation_fromScriptValue(const QScriptValue &value, QLibraryInfo::LibraryLocation &out)
 
117
{
 
118
    out = qvariant_cast<QLibraryInfo::LibraryLocation>(value.toVariant());
 
119
}
 
120
 
 
121
static QScriptValue qtscript_construct_QLibraryInfo_LibraryLocation(QScriptContext *context, QScriptEngine *engine)
 
122
{
 
123
    int arg = context->argument(0).toInt32();
 
124
    if ((arg >= QLibraryInfo::PrefixPath) && (arg <= QLibraryInfo::ExamplesPath))
 
125
        return qScriptValueFromValue(engine,  static_cast<QLibraryInfo::LibraryLocation>(arg));
 
126
    return context->throwError(QString::fromLatin1("LibraryLocation(): invalid enum value (%0)").arg(arg));
 
127
}
 
128
 
 
129
static QScriptValue qtscript_QLibraryInfo_LibraryLocation_valueOf(QScriptContext *context, QScriptEngine *engine)
 
130
{
 
131
    QLibraryInfo::LibraryLocation value = qscriptvalue_cast<QLibraryInfo::LibraryLocation>(context->thisObject());
 
132
    return QScriptValue(engine, static_cast<int>(value));
 
133
}
 
134
 
 
135
static QScriptValue qtscript_QLibraryInfo_LibraryLocation_toString(QScriptContext *context, QScriptEngine *engine)
 
136
{
 
137
    QLibraryInfo::LibraryLocation value = qscriptvalue_cast<QLibraryInfo::LibraryLocation>(context->thisObject());
 
138
    return QScriptValue(engine, qtscript_QLibraryInfo_LibraryLocation_toStringHelper(value));
 
139
}
 
140
 
 
141
static QScriptValue qtscript_create_QLibraryInfo_LibraryLocation_class(QScriptEngine *engine, QScriptValue &clazz)
 
142
{
 
143
    QScriptValue ctor = qtscript_create_enum_class_helper(
 
144
        engine, qtscript_construct_QLibraryInfo_LibraryLocation,
 
145
        qtscript_QLibraryInfo_LibraryLocation_valueOf, qtscript_QLibraryInfo_LibraryLocation_toString);
 
146
    qScriptRegisterMetaType<QLibraryInfo::LibraryLocation>(engine, qtscript_QLibraryInfo_LibraryLocation_toScriptValue,
 
147
        qtscript_QLibraryInfo_LibraryLocation_fromScriptValue, ctor.property(QString::fromLatin1("prototype")));
 
148
    for (int i = 0; i < 11; ++i) {
 
149
        clazz.setProperty(QString::fromLatin1(qtscript_QLibraryInfo_LibraryLocation_keys[i]),
 
150
            engine->newVariant(qVariantFromValue(qtscript_QLibraryInfo_LibraryLocation_values[i])),
 
151
            QScriptValue::ReadOnly | QScriptValue::Undeletable);
 
152
    }
 
153
    return ctor;
 
154
}
 
155
 
 
156
//
 
157
// QLibraryInfo
 
158
//
 
159
 
 
160
static QScriptValue qtscript_QLibraryInfo_prototype_call(QScriptContext *context, QScriptEngine *)
 
161
{
 
162
#if QT_VERSION > 0x040400
 
163
    Q_ASSERT(context->callee().isFunction());
 
164
    uint _id = context->callee().data().toUInt32();
 
165
#else
 
166
    uint _id;
 
167
    if (context->callee().isFunction())
 
168
        _id = context->callee().data().toUInt32();
 
169
    else
 
170
        _id = 0xBABE0000 + 0;
 
171
#endif
 
172
    Q_ASSERT((_id & 0xFFFF0000) == 0xBABE0000);
 
173
    _id &= 0x0000FFFF;
 
174
    QLibraryInfo* _q_self = qscriptvalue_cast<QLibraryInfo*>(context->thisObject());
 
175
    if (!_q_self) {
 
176
        return context->throwError(QScriptContext::TypeError,
 
177
            QString::fromLatin1("QLibraryInfo.%0(): this object is not a QLibraryInfo")
 
178
            .arg(qtscript_QLibraryInfo_function_names[_id+1]));
 
179
    }
 
180
 
 
181
    switch (_id) {
 
182
    case 0: {
 
183
    QString result = QString::fromLatin1("QLibraryInfo");
 
184
    return QScriptValue(context->engine(), result);
 
185
    }
 
186
 
 
187
    default:
 
188
    Q_ASSERT(false);
 
189
    }
 
190
    return qtscript_QLibraryInfo_throw_ambiguity_error_helper(context,
 
191
        qtscript_QLibraryInfo_function_names[_id+5],
 
192
        qtscript_QLibraryInfo_function_signatures[_id+5]);
 
193
}
 
194
 
 
195
static QScriptValue qtscript_QLibraryInfo_static_call(QScriptContext *context, QScriptEngine *)
 
196
{
 
197
    uint _id = context->callee().data().toUInt32();
 
198
    Q_ASSERT((_id & 0xFFFF0000) == 0xBABE0000);
 
199
    _id &= 0x0000FFFF;
 
200
    switch (_id) {
 
201
    case 0:
 
202
    return context->throwError(QScriptContext::TypeError,
 
203
        QString::fromLatin1("QLibraryInfo cannot be constructed"));
 
204
    break;
 
205
 
 
206
    case 1:
 
207
    if (context->argumentCount() == 0) {
 
208
        QString _q_result = QLibraryInfo::buildKey();
 
209
        return QScriptValue(context->engine(), _q_result);
 
210
    }
 
211
    break;
 
212
 
 
213
    case 2:
 
214
    if (context->argumentCount() == 0) {
 
215
        QString _q_result = QLibraryInfo::licensedProducts();
 
216
        return QScriptValue(context->engine(), _q_result);
 
217
    }
 
218
    break;
 
219
 
 
220
    case 3:
 
221
    if (context->argumentCount() == 0) {
 
222
        QString _q_result = QLibraryInfo::licensee();
 
223
        return QScriptValue(context->engine(), _q_result);
 
224
    }
 
225
    break;
 
226
 
 
227
    case 4:
 
228
    if (context->argumentCount() == 1) {
 
229
        QLibraryInfo::LibraryLocation _q_arg0 = qscriptvalue_cast<QLibraryInfo::LibraryLocation>(context->argument(0));
 
230
        QString _q_result = QLibraryInfo::location(_q_arg0);
 
231
        return QScriptValue(context->engine(), _q_result);
 
232
    }
 
233
    break;
 
234
 
 
235
    default:
 
236
    Q_ASSERT(false);
 
237
    }
 
238
    return qtscript_QLibraryInfo_throw_ambiguity_error_helper(context,
 
239
        qtscript_QLibraryInfo_function_names[_id],
 
240
        qtscript_QLibraryInfo_function_signatures[_id]);
 
241
}
 
242
 
 
243
QScriptValue qtscript_create_QLibraryInfo_class(QScriptEngine *engine)
 
244
{
 
245
    static const int function_lengths[] = {
 
246
        0
 
247
        // static
 
248
        , 0
 
249
        , 0
 
250
        , 0
 
251
        , 1
 
252
        // prototype
 
253
        , 0
 
254
    };
 
255
    engine->setDefaultPrototype(qMetaTypeId<QLibraryInfo*>(), QScriptValue());
 
256
    QScriptValue proto = engine->newVariant(qVariantFromValue((QLibraryInfo*)0));
 
257
 
 
258
    engine->setDefaultPrototype(qMetaTypeId<QLibraryInfo*>(), proto);
 
259
 
 
260
    QScriptValue ctor = engine->newFunction(qtscript_QLibraryInfo_static_call, proto, function_lengths[0]);
 
261
    ctor.setData(QScriptValue(engine, uint(0xBABE0000 + 0)));
 
262
    for (int i = 0; i < 4; ++i) {
 
263
        QScriptValue fun = engine->newFunction(qtscript_QLibraryInfo_static_call,
 
264
            function_lengths[i+1]);
 
265
        fun.setData(QScriptValue(engine, uint(0xBABE0000 + i+1)));
 
266
        ctor.setProperty(QString::fromLatin1(qtscript_QLibraryInfo_function_names[i+1]),
 
267
            fun, QScriptValue::SkipInEnumeration);
 
268
    }
 
269
 
 
270
    ctor.setProperty(QString::fromLatin1("LibraryLocation"),
 
271
        qtscript_create_QLibraryInfo_LibraryLocation_class(engine, ctor));
 
272
    return ctor;
 
273
}