← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/libs_3rdparty/qtbindings_gui/src/qtscript_QToolBox.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_gui/src/qtscript_QToolBox.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 <qtoolbox.h>
 
19
#include <QVariant>
 
20
#include <qaction.h>
 
21
#include <qbitmap.h>
 
22
#include <qbytearray.h>
 
23
#include <qcoreevent.h>
 
24
#include <qcursor.h>
 
25
#include <qevent.h>
 
26
#include <qfont.h>
 
27
#include <qicon.h>
 
28
#include <qinputcontext.h>
 
29
#include <qkeysequence.h>
 
30
#include <qlayout.h>
 
31
#include <qlist.h>
 
32
#include <qlocale.h>
 
33
#include <qobject.h>
 
34
#include <qpaintdevice.h>
 
35
#include <qpaintengine.h>
 
36
#include <qpainter.h>
 
37
#include <qpalette.h>
 
38
#include <qpoint.h>
 
39
#include <qrect.h>
 
40
#include <qregion.h>
 
41
#include <qsize.h>
 
42
#include <qsizepolicy.h>
 
43
#include <qstyle.h>
 
44
#include <qtoolbox.h>
 
45
#include <qwidget.h>
 
46
 
 
47
#include "qtscriptshell_QToolBox.h"
 
48
 
 
49
static const char * const qtscript_QToolBox_function_names[] = {
 
50
    "QToolBox"
 
51
    // static
 
52
    // prototype
 
53
    , "addItem"
 
54
    , "currentWidget"
 
55
    , "indexOf"
 
56
    , "insertItem"
 
57
    , "isItemEnabled"
 
58
    , "itemIcon"
 
59
    , "itemText"
 
60
    , "itemToolTip"
 
61
    , "removeItem"
 
62
    , "setItemEnabled"
 
63
    , "setItemIcon"
 
64
    , "setItemText"
 
65
    , "setItemToolTip"
 
66
    , "widget"
 
67
    , "toString"
 
68
};
 
69
 
 
70
static const char * const qtscript_QToolBox_function_signatures[] = {
 
71
    "QWidget parent, WindowFlags f"
 
72
    // static
 
73
    // prototype
 
74
    , "QWidget widget, QIcon icon, String text\nQWidget widget, String text"
 
75
    , ""
 
76
    , "QWidget widget"
 
77
    , "int index, QWidget widget, QIcon icon, String text\nint index, QWidget widget, String text"
 
78
    , "int index"
 
79
    , "int index"
 
80
    , "int index"
 
81
    , "int index"
 
82
    , "int index"
 
83
    , "int index, bool enabled"
 
84
    , "int index, QIcon icon"
 
85
    , "int index, String text"
 
86
    , "int index, String toolTip"
 
87
    , "int index"
 
88
""
 
89
};
 
90
 
 
91
static QScriptValue qtscript_QToolBox_throw_ambiguity_error_helper(
 
92
    QScriptContext *context, const char *functionName, const char *signatures)
 
93
{
 
94
    QStringList lines = QString::fromLatin1(signatures).split(QLatin1Char('\n'));
 
95
    QStringList fullSignatures;
 
96
    for (int i = 0; i < lines.size(); ++i)
 
97
        fullSignatures.append(QString::fromLatin1("%0(%1)").arg(functionName).arg(lines.at(i)));
 
98
    return context->throwError(QString::fromLatin1("QFile::%0(): could not find a function match; candidates are:\n%1")
 
99
        .arg(functionName).arg(fullSignatures.join(QLatin1String("\n"))));
 
100
}
 
101
 
 
102
Q_DECLARE_METATYPE(QToolBox*)
 
103
Q_DECLARE_METATYPE(QtScriptShell_QToolBox*)
 
104
Q_DECLARE_METATYPE(QFlags<Qt::WindowType>)
 
105
Q_DECLARE_METATYPE(QFrame*)
 
106
 
 
107
//
 
108
// QToolBox
 
109
//
 
110
 
 
111
static QScriptValue qtscript_QToolBox_prototype_call(QScriptContext *context, QScriptEngine *)
 
112
{
 
113
#if QT_VERSION > 0x040400
 
114
    Q_ASSERT(context->callee().isFunction());
 
115
    uint _id = context->callee().data().toUInt32();
 
116
#else
 
117
    uint _id;
 
118
    if (context->callee().isFunction())
 
119
        _id = context->callee().data().toUInt32();
 
120
    else
 
121
        _id = 0xBABE0000 + 14;
 
122
#endif
 
123
    Q_ASSERT((_id & 0xFFFF0000) == 0xBABE0000);
 
124
    _id &= 0x0000FFFF;
 
125
    QToolBox* _q_self = qscriptvalue_cast<QToolBox*>(context->thisObject());
 
126
    if (!_q_self) {
 
127
        return context->throwError(QScriptContext::TypeError,
 
128
            QString::fromLatin1("QToolBox.%0(): this object is not a QToolBox")
 
129
            .arg(qtscript_QToolBox_function_names[_id+1]));
 
130
    }
 
131
 
 
132
    switch (_id) {
 
133
    case 0:
 
134
    if (context->argumentCount() == 2) {
 
135
        QWidget* _q_arg0 = qscriptvalue_cast<QWidget*>(context->argument(0));
 
136
        QString _q_arg1 = context->argument(1).toString();
 
137
        int _q_result = _q_self->addItem(_q_arg0, _q_arg1);
 
138
        return QScriptValue(context->engine(), _q_result);
 
139
    }
 
140
    if (context->argumentCount() == 3) {
 
141
        QWidget* _q_arg0 = qscriptvalue_cast<QWidget*>(context->argument(0));
 
142
        QIcon _q_arg1 = qscriptvalue_cast<QIcon>(context->argument(1));
 
143
        QString _q_arg2 = context->argument(2).toString();
 
144
        int _q_result = _q_self->addItem(_q_arg0, _q_arg1, _q_arg2);
 
145
        return QScriptValue(context->engine(), _q_result);
 
146
    }
 
147
    break;
 
148
 
 
149
    case 1:
 
150
    if (context->argumentCount() == 0) {
 
151
        QWidget* _q_result = _q_self->currentWidget();
 
152
        return qScriptValueFromValue(context->engine(), _q_result);
 
153
    }
 
154
    break;
 
155
 
 
156
    case 2:
 
157
    if (context->argumentCount() == 1) {
 
158
        QWidget* _q_arg0 = qscriptvalue_cast<QWidget*>(context->argument(0));
 
159
        int _q_result = _q_self->indexOf(_q_arg0);
 
160
        return QScriptValue(context->engine(), _q_result);
 
161
    }
 
162
    break;
 
163
 
 
164
    case 3:
 
165
    if (context->argumentCount() == 3) {
 
166
        int _q_arg0 = context->argument(0).toInt32();
 
167
        QWidget* _q_arg1 = qscriptvalue_cast<QWidget*>(context->argument(1));
 
168
        QString _q_arg2 = context->argument(2).toString();
 
169
        int _q_result = _q_self->insertItem(_q_arg0, _q_arg1, _q_arg2);
 
170
        return QScriptValue(context->engine(), _q_result);
 
171
    }
 
172
    if (context->argumentCount() == 4) {
 
173
        int _q_arg0 = context->argument(0).toInt32();
 
174
        QWidget* _q_arg1 = qscriptvalue_cast<QWidget*>(context->argument(1));
 
175
        QIcon _q_arg2 = qscriptvalue_cast<QIcon>(context->argument(2));
 
176
        QString _q_arg3 = context->argument(3).toString();
 
177
        int _q_result = _q_self->insertItem(_q_arg0, _q_arg1, _q_arg2, _q_arg3);
 
178
        return QScriptValue(context->engine(), _q_result);
 
179
    }
 
180
    break;
 
181
 
 
182
    case 4:
 
183
    if (context->argumentCount() == 1) {
 
184
        int _q_arg0 = context->argument(0).toInt32();
 
185
        bool _q_result = _q_self->isItemEnabled(_q_arg0);
 
186
        return QScriptValue(context->engine(), _q_result);
 
187
    }
 
188
    break;
 
189
 
 
190
    case 5:
 
191
    if (context->argumentCount() == 1) {
 
192
        int _q_arg0 = context->argument(0).toInt32();
 
193
        QIcon _q_result = _q_self->itemIcon(_q_arg0);
 
194
        return qScriptValueFromValue(context->engine(), _q_result);
 
195
    }
 
196
    break;
 
197
 
 
198
    case 6:
 
199
    if (context->argumentCount() == 1) {
 
200
        int _q_arg0 = context->argument(0).toInt32();
 
201
        QString _q_result = _q_self->itemText(_q_arg0);
 
202
        return QScriptValue(context->engine(), _q_result);
 
203
    }
 
204
    break;
 
205
 
 
206
    case 7:
 
207
    if (context->argumentCount() == 1) {
 
208
        int _q_arg0 = context->argument(0).toInt32();
 
209
        QString _q_result = _q_self->itemToolTip(_q_arg0);
 
210
        return QScriptValue(context->engine(), _q_result);
 
211
    }
 
212
    break;
 
213
 
 
214
    case 8:
 
215
    if (context->argumentCount() == 1) {
 
216
        int _q_arg0 = context->argument(0).toInt32();
 
217
        _q_self->removeItem(_q_arg0);
 
218
        return context->engine()->undefinedValue();
 
219
    }
 
220
    break;
 
221
 
 
222
    case 9:
 
223
    if (context->argumentCount() == 2) {
 
224
        int _q_arg0 = context->argument(0).toInt32();
 
225
        bool _q_arg1 = context->argument(1).toBoolean();
 
226
        _q_self->setItemEnabled(_q_arg0, _q_arg1);
 
227
        return context->engine()->undefinedValue();
 
228
    }
 
229
    break;
 
230
 
 
231
    case 10:
 
232
    if (context->argumentCount() == 2) {
 
233
        int _q_arg0 = context->argument(0).toInt32();
 
234
        QIcon _q_arg1 = qscriptvalue_cast<QIcon>(context->argument(1));
 
235
        _q_self->setItemIcon(_q_arg0, _q_arg1);
 
236
        return context->engine()->undefinedValue();
 
237
    }
 
238
    break;
 
239
 
 
240
    case 11:
 
241
    if (context->argumentCount() == 2) {
 
242
        int _q_arg0 = context->argument(0).toInt32();
 
243
        QString _q_arg1 = context->argument(1).toString();
 
244
        _q_self->setItemText(_q_arg0, _q_arg1);
 
245
        return context->engine()->undefinedValue();
 
246
    }
 
247
    break;
 
248
 
 
249
    case 12:
 
250
    if (context->argumentCount() == 2) {
 
251
        int _q_arg0 = context->argument(0).toInt32();
 
252
        QString _q_arg1 = context->argument(1).toString();
 
253
        _q_self->setItemToolTip(_q_arg0, _q_arg1);
 
254
        return context->engine()->undefinedValue();
 
255
    }
 
256
    break;
 
257
 
 
258
    case 13:
 
259
    if (context->argumentCount() == 1) {
 
260
        int _q_arg0 = context->argument(0).toInt32();
 
261
        QWidget* _q_result = _q_self->widget(_q_arg0);
 
262
        return qScriptValueFromValue(context->engine(), _q_result);
 
263
    }
 
264
    break;
 
265
 
 
266
    case 14: {
 
267
    QString result = QString::fromLatin1("QToolBox");
 
268
    return QScriptValue(context->engine(), result);
 
269
    }
 
270
 
 
271
    default:
 
272
    Q_ASSERT(false);
 
273
    }
 
274
    return qtscript_QToolBox_throw_ambiguity_error_helper(context,
 
275
        qtscript_QToolBox_function_names[_id+1],
 
276
        qtscript_QToolBox_function_signatures[_id+1]);
 
277
}
 
278
 
 
279
static QScriptValue qtscript_QToolBox_static_call(QScriptContext *context, QScriptEngine *)
 
280
{
 
281
    uint _id = context->callee().data().toUInt32();
 
282
    Q_ASSERT((_id & 0xFFFF0000) == 0xBABE0000);
 
283
    _id &= 0x0000FFFF;
 
284
    switch (_id) {
 
285
    case 0:
 
286
    if (context->thisObject().strictlyEquals(context->engine()->globalObject())) {
 
287
        return context->throwError(QString::fromLatin1("QToolBox(): Did you forget to construct with 'new'?"));
 
288
    }
 
289
    if (context->argumentCount() == 0) {
 
290
        QtScriptShell_QToolBox* _q_cpp_result = new QtScriptShell_QToolBox();
 
291
        QScriptValue _q_result = context->engine()->newQObject(context->thisObject(), (QToolBox*)_q_cpp_result, QScriptEngine::AutoOwnership);
 
292
        _q_cpp_result->__qtscript_self = _q_result;
 
293
        return _q_result;
 
294
    } else if (context->argumentCount() == 1) {
 
295
        QWidget* _q_arg0 = qscriptvalue_cast<QWidget*>(context->argument(0));
 
296
        QtScriptShell_QToolBox* _q_cpp_result = new QtScriptShell_QToolBox(_q_arg0);
 
297
        QScriptValue _q_result = context->engine()->newQObject(context->thisObject(), (QToolBox*)_q_cpp_result, QScriptEngine::AutoOwnership);
 
298
        _q_cpp_result->__qtscript_self = _q_result;
 
299
        return _q_result;
 
300
    } else if (context->argumentCount() == 2) {
 
301
        QWidget* _q_arg0 = qscriptvalue_cast<QWidget*>(context->argument(0));
 
302
        QFlags<Qt::WindowType> _q_arg1 = qscriptvalue_cast<QFlags<Qt::WindowType> >(context->argument(1));
 
303
        QtScriptShell_QToolBox* _q_cpp_result = new QtScriptShell_QToolBox(_q_arg0, _q_arg1);
 
304
        QScriptValue _q_result = context->engine()->newQObject(context->thisObject(), (QToolBox*)_q_cpp_result, QScriptEngine::AutoOwnership);
 
305
        _q_cpp_result->__qtscript_self = _q_result;
 
306
        return _q_result;
 
307
    }
 
308
    break;
 
309
 
 
310
    default:
 
311
    Q_ASSERT(false);
 
312
    }
 
313
    return qtscript_QToolBox_throw_ambiguity_error_helper(context,
 
314
        qtscript_QToolBox_function_names[_id],
 
315
        qtscript_QToolBox_function_signatures[_id]);
 
316
}
 
317
 
 
318
static QScriptValue qtscript_QToolBox_toScriptValue(QScriptEngine *engine, QToolBox* const &in)
 
319
{
 
320
    return engine->newQObject(in, QScriptEngine::QtOwnership, QScriptEngine::PreferExistingWrapperObject);
 
321
}
 
322
 
 
323
static void qtscript_QToolBox_fromScriptValue(const QScriptValue &value, QToolBox* &out)
 
324
{
 
325
    out = qobject_cast<QToolBox*>(value.toQObject());
 
326
}
 
327
 
 
328
QScriptValue qtscript_create_QToolBox_class(QScriptEngine *engine)
 
329
{
 
330
    static const int function_lengths[] = {
 
331
        2
 
332
        // static
 
333
        // prototype
 
334
        , 3
 
335
        , 0
 
336
        , 1
 
337
        , 4
 
338
        , 1
 
339
        , 1
 
340
        , 1
 
341
        , 1
 
342
        , 1
 
343
        , 2
 
344
        , 2
 
345
        , 2
 
346
        , 2
 
347
        , 1
 
348
        , 0
 
349
    };
 
350
    engine->setDefaultPrototype(qMetaTypeId<QToolBox*>(), QScriptValue());
 
351
    QScriptValue proto = engine->newVariant(qVariantFromValue((QToolBox*)0));
 
352
    proto.setPrototype(engine->defaultPrototype(qMetaTypeId<QFrame*>()));
 
353
    for (int i = 0; i < 15; ++i) {
 
354
        QScriptValue fun = engine->newFunction(qtscript_QToolBox_prototype_call, function_lengths[i+1]);
 
355
        fun.setData(QScriptValue(engine, uint(0xBABE0000 + i)));
 
356
        proto.setProperty(QString::fromLatin1(qtscript_QToolBox_function_names[i+1]),
 
357
            fun, QScriptValue::SkipInEnumeration);
 
358
    }
 
359
 
 
360
    qScriptRegisterMetaType<QToolBox*>(engine, qtscript_QToolBox_toScriptValue, 
 
361
        qtscript_QToolBox_fromScriptValue, proto);
 
362
 
 
363
    QScriptValue ctor = engine->newFunction(qtscript_QToolBox_static_call, proto, function_lengths[0]);
 
364
    ctor.setData(QScriptValue(engine, uint(0xBABE0000 + 0)));
 
365
 
 
366
    return ctor;
 
367
}