← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/libs_3rdparty/qtbindings_gui/src/qtscriptshell_QGraphicsItem.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_gui/src/qtscriptshell_QGraphicsItem.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 "qtscriptshell_QGraphicsItem.h"
12
 
 
13
 
#include <QtScript/QScriptEngine>
14
 
#include <QVariant>
15
 
#include <qcoreevent.h>
16
 
#include <qcursor.h>
17
 
#include <qevent.h>
18
 
#include <qgraphicsitem.h>
19
 
#include <qgraphicsscene.h>
20
 
#include <qgraphicssceneevent.h>
21
 
#include <qgraphicswidget.h>
22
 
#include <qlist.h>
23
 
#include <qpainter.h>
24
 
#include <qpainterpath.h>
25
 
#include <qpoint.h>
26
 
#include <qpolygon.h>
27
 
#include <qrect.h>
28
 
#include <qregion.h>
29
 
#include <qsize.h>
30
 
#include <qstyleoption.h>
31
 
#include <qtransform.h>
32
 
#include <qwidget.h>
33
 
 
34
 
#define QTSCRIPT_IS_GENERATED_FUNCTION(fun) ((fun.data().toUInt32() & 0xFFFF0000) == 0xBABE0000)
35
 
 
36
 
Q_DECLARE_METATYPE(Qt::ItemSelectionMode)
37
 
Q_DECLARE_METATYPE(QPainterPath)
38
 
Q_DECLARE_METATYPE(QGraphicsSceneContextMenuEvent*)
39
 
Q_DECLARE_METATYPE(QGraphicsSceneDragDropEvent*)
40
 
Q_DECLARE_METATYPE(QVariant)
41
 
Q_DECLARE_METATYPE(QFocusEvent*)
42
 
Q_DECLARE_METATYPE(QGraphicsSceneHoverEvent*)
43
 
Q_DECLARE_METATYPE(QInputMethodEvent*)
44
 
Q_DECLARE_METATYPE(Qt::InputMethodQuery)
45
 
Q_DECLARE_METATYPE(QGraphicsItem::GraphicsItemChange)
46
 
Q_DECLARE_METATYPE(QKeyEvent*)
47
 
Q_DECLARE_METATYPE(QGraphicsSceneMouseEvent*)
48
 
Q_DECLARE_METATYPE(QPainter*)
49
 
Q_DECLARE_METATYPE(QStyleOptionGraphicsItem*)
50
 
Q_DECLARE_METATYPE(QEvent*)
51
 
Q_DECLARE_METATYPE(QGraphicsSceneWheelEvent*)
52
 
 
53
 
QtScriptShell_QGraphicsItem::QtScriptShell_QGraphicsItem(QGraphicsItem*  parent, QGraphicsScene*  scene)
54
 
    : QGraphicsItem(parent, scene) {}
55
 
 
56
 
QtScriptShell_QGraphicsItem::~QtScriptShell_QGraphicsItem() {}
57
 
 
58
 
void QtScriptShell_QGraphicsItem::advance(int  phase)
59
 
{
60
 
    QScriptValue _q_function = __qtscript_self.property("advance");
61
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
62
 
        || (__qtscript_self.propertyFlags("advance") & QScriptValue::QObjectMember)) {
63
 
        QGraphicsItem::advance(phase);
64
 
    } else {
65
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
66
 
        _q_function.call(__qtscript_self,
67
 
            QScriptValueList()
68
 
            << qScriptValueFromValue(_q_engine, phase));
69
 
    }
70
 
}
71
 
 
72
 
QRectF  QtScriptShell_QGraphicsItem::boundingRect() const
73
 
{
74
 
    QScriptValue _q_function = __qtscript_self.property("boundingRect");
75
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
76
 
        || (__qtscript_self.propertyFlags("boundingRect") & QScriptValue::QObjectMember)) {
77
 
        qFatal("QGraphicsItem::boundingRect() is abstract!");
78
 
    } else {
79
 
        return qscriptvalue_cast<QRectF >(_q_function.call(__qtscript_self));
80
 
    }
81
 
}
82
 
 
83
 
bool  QtScriptShell_QGraphicsItem::collidesWithItem(const QGraphicsItem*  other, Qt::ItemSelectionMode  mode) const
84
 
{
85
 
    QScriptValue _q_function = __qtscript_self.property("collidesWithItem");
86
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
87
 
        || (__qtscript_self.propertyFlags("collidesWithItem") & QScriptValue::QObjectMember)) {
88
 
        return QGraphicsItem::collidesWithItem(other, mode);
89
 
    } else {
90
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
91
 
        return qscriptvalue_cast<bool >(_q_function.call(__qtscript_self,
92
 
            QScriptValueList()
93
 
            << qScriptValueFromValue(_q_engine, const_cast<QGraphicsItem *>(other))
94
 
            << qScriptValueFromValue(_q_engine, mode)));
95
 
    }
96
 
}
97
 
 
98
 
bool  QtScriptShell_QGraphicsItem::collidesWithPath(const QPainterPath&  path, Qt::ItemSelectionMode  mode) const
99
 
{
100
 
    QScriptValue _q_function = __qtscript_self.property("collidesWithPath");
101
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
102
 
        || (__qtscript_self.propertyFlags("collidesWithPath") & QScriptValue::QObjectMember)) {
103
 
        return QGraphicsItem::collidesWithPath(path, mode);
104
 
    } else {
105
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
106
 
        return qscriptvalue_cast<bool >(_q_function.call(__qtscript_self,
107
 
            QScriptValueList()
108
 
            << qScriptValueFromValue(_q_engine, path)
109
 
            << qScriptValueFromValue(_q_engine, mode)));
110
 
    }
111
 
}
112
 
 
113
 
bool  QtScriptShell_QGraphicsItem::contains(const QPointF&  point) const
114
 
{
115
 
    QScriptValue _q_function = __qtscript_self.property("contains");
116
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
117
 
        || (__qtscript_self.propertyFlags("contains") & QScriptValue::QObjectMember)) {
118
 
        return QGraphicsItem::contains(point);
119
 
    } else {
120
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
121
 
        return qscriptvalue_cast<bool >(_q_function.call(__qtscript_self,
122
 
            QScriptValueList()
123
 
            << qScriptValueFromValue(_q_engine, point)));
124
 
    }
125
 
}
126
 
 
127
 
void QtScriptShell_QGraphicsItem::contextMenuEvent(QGraphicsSceneContextMenuEvent*  event)
128
 
{
129
 
    QScriptValue _q_function = __qtscript_self.property("contextMenuEvent");
130
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
131
 
        || (__qtscript_self.propertyFlags("contextMenuEvent") & QScriptValue::QObjectMember)) {
132
 
        QGraphicsItem::contextMenuEvent(event);
133
 
    } else {
134
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
135
 
        _q_function.call(__qtscript_self,
136
 
            QScriptValueList()
137
 
            << qScriptValueFromValue(_q_engine, event));
138
 
    }
139
 
}
140
 
 
141
 
void QtScriptShell_QGraphicsItem::dragEnterEvent(QGraphicsSceneDragDropEvent*  event)
142
 
{
143
 
    QScriptValue _q_function = __qtscript_self.property("dragEnterEvent");
144
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
145
 
        || (__qtscript_self.propertyFlags("dragEnterEvent") & QScriptValue::QObjectMember)) {
146
 
        QGraphicsItem::dragEnterEvent(event);
147
 
    } else {
148
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
149
 
        _q_function.call(__qtscript_self,
150
 
            QScriptValueList()
151
 
            << qScriptValueFromValue(_q_engine, event));
152
 
    }
153
 
}
154
 
 
155
 
void QtScriptShell_QGraphicsItem::dragLeaveEvent(QGraphicsSceneDragDropEvent*  event)
156
 
{
157
 
    QScriptValue _q_function = __qtscript_self.property("dragLeaveEvent");
158
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
159
 
        || (__qtscript_self.propertyFlags("dragLeaveEvent") & QScriptValue::QObjectMember)) {
160
 
        QGraphicsItem::dragLeaveEvent(event);
161
 
    } else {
162
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
163
 
        _q_function.call(__qtscript_self,
164
 
            QScriptValueList()
165
 
            << qScriptValueFromValue(_q_engine, event));
166
 
    }
167
 
}
168
 
 
169
 
void QtScriptShell_QGraphicsItem::dragMoveEvent(QGraphicsSceneDragDropEvent*  event)
170
 
{
171
 
    QScriptValue _q_function = __qtscript_self.property("dragMoveEvent");
172
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
173
 
        || (__qtscript_self.propertyFlags("dragMoveEvent") & QScriptValue::QObjectMember)) {
174
 
        QGraphicsItem::dragMoveEvent(event);
175
 
    } else {
176
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
177
 
        _q_function.call(__qtscript_self,
178
 
            QScriptValueList()
179
 
            << qScriptValueFromValue(_q_engine, event));
180
 
    }
181
 
}
182
 
 
183
 
void QtScriptShell_QGraphicsItem::dropEvent(QGraphicsSceneDragDropEvent*  event)
184
 
{
185
 
    QScriptValue _q_function = __qtscript_self.property("dropEvent");
186
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
187
 
        || (__qtscript_self.propertyFlags("dropEvent") & QScriptValue::QObjectMember)) {
188
 
        QGraphicsItem::dropEvent(event);
189
 
    } else {
190
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
191
 
        _q_function.call(__qtscript_self,
192
 
            QScriptValueList()
193
 
            << qScriptValueFromValue(_q_engine, event));
194
 
    }
195
 
}
196
 
 
197
 
QVariant  QtScriptShell_QGraphicsItem::extension(const QVariant&  variant) const
198
 
{
199
 
    QScriptValue _q_function = __qtscript_self.property("extension");
200
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
201
 
        || (__qtscript_self.propertyFlags("extension") & QScriptValue::QObjectMember)) {
202
 
        return QGraphicsItem::extension(variant);
203
 
    } else {
204
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
205
 
        return qscriptvalue_cast<QVariant >(_q_function.call(__qtscript_self,
206
 
            QScriptValueList()
207
 
            << qScriptValueFromValue(_q_engine, variant)));
208
 
    }
209
 
}
210
 
 
211
 
void QtScriptShell_QGraphicsItem::focusInEvent(QFocusEvent*  event)
212
 
{
213
 
    QScriptValue _q_function = __qtscript_self.property("focusInEvent");
214
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
215
 
        || (__qtscript_self.propertyFlags("focusInEvent") & QScriptValue::QObjectMember)) {
216
 
        QGraphicsItem::focusInEvent(event);
217
 
    } else {
218
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
219
 
        _q_function.call(__qtscript_self,
220
 
            QScriptValueList()
221
 
            << qScriptValueFromValue(_q_engine, event));
222
 
    }
223
 
}
224
 
 
225
 
void QtScriptShell_QGraphicsItem::focusOutEvent(QFocusEvent*  event)
226
 
{
227
 
    QScriptValue _q_function = __qtscript_self.property("focusOutEvent");
228
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
229
 
        || (__qtscript_self.propertyFlags("focusOutEvent") & QScriptValue::QObjectMember)) {
230
 
        QGraphicsItem::focusOutEvent(event);
231
 
    } else {
232
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
233
 
        _q_function.call(__qtscript_self,
234
 
            QScriptValueList()
235
 
            << qScriptValueFromValue(_q_engine, event));
236
 
    }
237
 
}
238
 
 
239
 
void QtScriptShell_QGraphicsItem::hoverEnterEvent(QGraphicsSceneHoverEvent*  event)
240
 
{
241
 
    QScriptValue _q_function = __qtscript_self.property("hoverEnterEvent");
242
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
243
 
        || (__qtscript_self.propertyFlags("hoverEnterEvent") & QScriptValue::QObjectMember)) {
244
 
        QGraphicsItem::hoverEnterEvent(event);
245
 
    } else {
246
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
247
 
        _q_function.call(__qtscript_self,
248
 
            QScriptValueList()
249
 
            << qScriptValueFromValue(_q_engine, event));
250
 
    }
251
 
}
252
 
 
253
 
void QtScriptShell_QGraphicsItem::hoverLeaveEvent(QGraphicsSceneHoverEvent*  event)
254
 
{
255
 
    QScriptValue _q_function = __qtscript_self.property("hoverLeaveEvent");
256
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
257
 
        || (__qtscript_self.propertyFlags("hoverLeaveEvent") & QScriptValue::QObjectMember)) {
258
 
        QGraphicsItem::hoverLeaveEvent(event);
259
 
    } else {
260
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
261
 
        _q_function.call(__qtscript_self,
262
 
            QScriptValueList()
263
 
            << qScriptValueFromValue(_q_engine, event));
264
 
    }
265
 
}
266
 
 
267
 
void QtScriptShell_QGraphicsItem::hoverMoveEvent(QGraphicsSceneHoverEvent*  event)
268
 
{
269
 
    QScriptValue _q_function = __qtscript_self.property("hoverMoveEvent");
270
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
271
 
        || (__qtscript_self.propertyFlags("hoverMoveEvent") & QScriptValue::QObjectMember)) {
272
 
        QGraphicsItem::hoverMoveEvent(event);
273
 
    } else {
274
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
275
 
        _q_function.call(__qtscript_self,
276
 
            QScriptValueList()
277
 
            << qScriptValueFromValue(_q_engine, event));
278
 
    }
279
 
}
280
 
 
281
 
void QtScriptShell_QGraphicsItem::inputMethodEvent(QInputMethodEvent*  event)
282
 
{
283
 
    QScriptValue _q_function = __qtscript_self.property("inputMethodEvent");
284
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
285
 
        || (__qtscript_self.propertyFlags("inputMethodEvent") & QScriptValue::QObjectMember)) {
286
 
        QGraphicsItem::inputMethodEvent(event);
287
 
    } else {
288
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
289
 
        _q_function.call(__qtscript_self,
290
 
            QScriptValueList()
291
 
            << qScriptValueFromValue(_q_engine, event));
292
 
    }
293
 
}
294
 
 
295
 
QVariant  QtScriptShell_QGraphicsItem::inputMethodQuery(Qt::InputMethodQuery  query) const
296
 
{
297
 
    QScriptValue _q_function = __qtscript_self.property("inputMethodQuery");
298
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
299
 
        || (__qtscript_self.propertyFlags("inputMethodQuery") & QScriptValue::QObjectMember)) {
300
 
        return QGraphicsItem::inputMethodQuery(query);
301
 
    } else {
302
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
303
 
        return qscriptvalue_cast<QVariant >(_q_function.call(__qtscript_self,
304
 
            QScriptValueList()
305
 
            << qScriptValueFromValue(_q_engine, query)));
306
 
    }
307
 
}
308
 
 
309
 
bool  QtScriptShell_QGraphicsItem::isObscuredBy(const QGraphicsItem*  item) const
310
 
{
311
 
    QScriptValue _q_function = __qtscript_self.property("isObscuredBy");
312
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
313
 
        || (__qtscript_self.propertyFlags("isObscuredBy") & QScriptValue::QObjectMember)) {
314
 
        return QGraphicsItem::isObscuredBy(item);
315
 
    } else {
316
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
317
 
        return qscriptvalue_cast<bool >(_q_function.call(__qtscript_self,
318
 
            QScriptValueList()
319
 
            << qScriptValueFromValue(_q_engine, const_cast<QGraphicsItem *>(item))));
320
 
    }
321
 
}
322
 
 
323
 
QVariant  QtScriptShell_QGraphicsItem::itemChange(QGraphicsItem::GraphicsItemChange  change, const QVariant&  value)
324
 
{
325
 
    QScriptValue _q_function = __qtscript_self.property("itemChange");
326
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
327
 
        || (__qtscript_self.propertyFlags("itemChange") & QScriptValue::QObjectMember)) {
328
 
        return QGraphicsItem::itemChange(change, value);
329
 
    } else {
330
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
331
 
        return qscriptvalue_cast<QVariant >(_q_function.call(__qtscript_self,
332
 
            QScriptValueList()
333
 
            << qScriptValueFromValue(_q_engine, change)
334
 
            << qScriptValueFromValue(_q_engine, value)));
335
 
    }
336
 
}
337
 
 
338
 
void QtScriptShell_QGraphicsItem::keyPressEvent(QKeyEvent*  event)
339
 
{
340
 
    QScriptValue _q_function = __qtscript_self.property("keyPressEvent");
341
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
342
 
        || (__qtscript_self.propertyFlags("keyPressEvent") & QScriptValue::QObjectMember)) {
343
 
        QGraphicsItem::keyPressEvent(event);
344
 
    } else {
345
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
346
 
        _q_function.call(__qtscript_self,
347
 
            QScriptValueList()
348
 
            << qScriptValueFromValue(_q_engine, event));
349
 
    }
350
 
}
351
 
 
352
 
void QtScriptShell_QGraphicsItem::keyReleaseEvent(QKeyEvent*  event)
353
 
{
354
 
    QScriptValue _q_function = __qtscript_self.property("keyReleaseEvent");
355
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
356
 
        || (__qtscript_self.propertyFlags("keyReleaseEvent") & QScriptValue::QObjectMember)) {
357
 
        QGraphicsItem::keyReleaseEvent(event);
358
 
    } else {
359
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
360
 
        _q_function.call(__qtscript_self,
361
 
            QScriptValueList()
362
 
            << qScriptValueFromValue(_q_engine, event));
363
 
    }
364
 
}
365
 
 
366
 
void QtScriptShell_QGraphicsItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent*  event)
367
 
{
368
 
    QScriptValue _q_function = __qtscript_self.property("mouseDoubleClickEvent");
369
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
370
 
        || (__qtscript_self.propertyFlags("mouseDoubleClickEvent") & QScriptValue::QObjectMember)) {
371
 
        QGraphicsItem::mouseDoubleClickEvent(event);
372
 
    } else {
373
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
374
 
        _q_function.call(__qtscript_self,
375
 
            QScriptValueList()
376
 
            << qScriptValueFromValue(_q_engine, event));
377
 
    }
378
 
}
379
 
 
380
 
void QtScriptShell_QGraphicsItem::mouseMoveEvent(QGraphicsSceneMouseEvent*  event)
381
 
{
382
 
    QScriptValue _q_function = __qtscript_self.property("mouseMoveEvent");
383
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
384
 
        || (__qtscript_self.propertyFlags("mouseMoveEvent") & QScriptValue::QObjectMember)) {
385
 
        QGraphicsItem::mouseMoveEvent(event);
386
 
    } else {
387
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
388
 
        _q_function.call(__qtscript_self,
389
 
            QScriptValueList()
390
 
            << qScriptValueFromValue(_q_engine, event));
391
 
    }
392
 
}
393
 
 
394
 
void QtScriptShell_QGraphicsItem::mousePressEvent(QGraphicsSceneMouseEvent*  event)
395
 
{
396
 
    QScriptValue _q_function = __qtscript_self.property("mousePressEvent");
397
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
398
 
        || (__qtscript_self.propertyFlags("mousePressEvent") & QScriptValue::QObjectMember)) {
399
 
        QGraphicsItem::mousePressEvent(event);
400
 
    } else {
401
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
402
 
        _q_function.call(__qtscript_self,
403
 
            QScriptValueList()
404
 
            << qScriptValueFromValue(_q_engine, event));
405
 
    }
406
 
}
407
 
 
408
 
void QtScriptShell_QGraphicsItem::mouseReleaseEvent(QGraphicsSceneMouseEvent*  event)
409
 
{
410
 
    QScriptValue _q_function = __qtscript_self.property("mouseReleaseEvent");
411
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
412
 
        || (__qtscript_self.propertyFlags("mouseReleaseEvent") & QScriptValue::QObjectMember)) {
413
 
        QGraphicsItem::mouseReleaseEvent(event);
414
 
    } else {
415
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
416
 
        _q_function.call(__qtscript_self,
417
 
            QScriptValueList()
418
 
            << qScriptValueFromValue(_q_engine, event));
419
 
    }
420
 
}
421
 
 
422
 
QPainterPath  QtScriptShell_QGraphicsItem::opaqueArea() const
423
 
{
424
 
    QScriptValue _q_function = __qtscript_self.property("opaqueArea");
425
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
426
 
        || (__qtscript_self.propertyFlags("opaqueArea") & QScriptValue::QObjectMember)) {
427
 
        return QGraphicsItem::opaqueArea();
428
 
    } else {
429
 
        return qscriptvalue_cast<QPainterPath >(_q_function.call(__qtscript_self));
430
 
    }
431
 
}
432
 
 
433
 
void QtScriptShell_QGraphicsItem::paint(QPainter*  painter, const QStyleOptionGraphicsItem*  option, QWidget*  widget)
434
 
{
435
 
    QScriptValue _q_function = __qtscript_self.property("paint");
436
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
437
 
        || (__qtscript_self.propertyFlags("paint") & QScriptValue::QObjectMember)) {
438
 
        qFatal("QGraphicsItem::paint() is abstract!");
439
 
    } else {
440
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
441
 
        _q_function.call(__qtscript_self,
442
 
            QScriptValueList()
443
 
            << qScriptValueFromValue(_q_engine, painter)
444
 
            << qScriptValueFromValue(_q_engine, const_cast<QStyleOptionGraphicsItem *>(option))
445
 
            << qScriptValueFromValue(_q_engine, widget));
446
 
    }
447
 
}
448
 
 
449
 
bool  QtScriptShell_QGraphicsItem::sceneEvent(QEvent*  event)
450
 
{
451
 
    QScriptValue _q_function = __qtscript_self.property("sceneEvent");
452
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
453
 
        || (__qtscript_self.propertyFlags("sceneEvent") & QScriptValue::QObjectMember)) {
454
 
        return QGraphicsItem::sceneEvent(event);
455
 
    } else {
456
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
457
 
        return qscriptvalue_cast<bool >(_q_function.call(__qtscript_self,
458
 
            QScriptValueList()
459
 
            << qScriptValueFromValue(_q_engine, event)));
460
 
    }
461
 
}
462
 
 
463
 
bool  QtScriptShell_QGraphicsItem::sceneEventFilter(QGraphicsItem*  watched, QEvent*  event)
464
 
{
465
 
    QScriptValue _q_function = __qtscript_self.property("sceneEventFilter");
466
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
467
 
        || (__qtscript_self.propertyFlags("sceneEventFilter") & QScriptValue::QObjectMember)) {
468
 
        return QGraphicsItem::sceneEventFilter(watched, event);
469
 
    } else {
470
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
471
 
        return qscriptvalue_cast<bool >(_q_function.call(__qtscript_self,
472
 
            QScriptValueList()
473
 
            << qScriptValueFromValue(_q_engine, watched)
474
 
            << qScriptValueFromValue(_q_engine, event)));
475
 
    }
476
 
}
477
 
 
478
 
QPainterPath  QtScriptShell_QGraphicsItem::shape() const
479
 
{
480
 
    QScriptValue _q_function = __qtscript_self.property("shape");
481
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
482
 
        || (__qtscript_self.propertyFlags("shape") & QScriptValue::QObjectMember)) {
483
 
        return QGraphicsItem::shape();
484
 
    } else {
485
 
        return qscriptvalue_cast<QPainterPath >(_q_function.call(__qtscript_self));
486
 
    }
487
 
}
488
 
 
489
 
int  QtScriptShell_QGraphicsItem::type() const
490
 
{
491
 
    QScriptValue _q_function = __qtscript_self.property("type");
492
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
493
 
        || (__qtscript_self.propertyFlags("type") & QScriptValue::QObjectMember)) {
494
 
        return QGraphicsItem::type();
495
 
    } else {
496
 
        return qscriptvalue_cast<int >(_q_function.call(__qtscript_self));
497
 
    }
498
 
}
499
 
 
500
 
void QtScriptShell_QGraphicsItem::wheelEvent(QGraphicsSceneWheelEvent*  event)
501
 
{
502
 
    QScriptValue _q_function = __qtscript_self.property("wheelEvent");
503
 
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
504
 
        || (__qtscript_self.propertyFlags("wheelEvent") & QScriptValue::QObjectMember)) {
505
 
        QGraphicsItem::wheelEvent(event);
506
 
    } else {
507
 
        QScriptEngine *_q_engine = __qtscript_self.engine();
508
 
        _q_function.call(__qtscript_self,
509
 
            QScriptValueList()
510
 
            << qScriptValueFromValue(_q_engine, event));
511
 
    }
512
 
}
513