← 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/qtscriptshell_QGraphicsProxyWidget.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/qtscriptshell_QGraphicsProxyWidget.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_QGraphicsProxyWidget.h"
 
12
 
 
13
#include <QtScript/QScriptEngine>
 
14
#include <QVariant>
 
15
#include <qbytearray.h>
 
16
#include <qcoreevent.h>
 
17
#include <qcursor.h>
 
18
#include <qevent.h>
 
19
#include <qfont.h>
 
20
#include <qgraphicsitem.h>
 
21
#include <qgraphicslayout.h>
 
22
#include <qgraphicslayoutitem.h>
 
23
#include <qgraphicsproxywidget.h>
 
24
#include <qgraphicsscene.h>
 
25
#include <qgraphicssceneevent.h>
 
26
#include <qgraphicswidget.h>
 
27
#include <qlist.h>
 
28
#include <qobject.h>
 
29
#include <qpainter.h>
 
30
#include <qpainterpath.h>
 
31
#include <qpalette.h>
 
32
#include <qpoint.h>
 
33
#include <qpolygon.h>
 
34
#include <qrect.h>
 
35
#include <qregion.h>
 
36
#include <qsize.h>
 
37
#include <qsizepolicy.h>
 
38
#include <qstyle.h>
 
39
#include <qstyleoption.h>
 
40
#include <qtransform.h>
 
41
#include <qwidget.h>
 
42
 
 
43
#define QTSCRIPT_IS_GENERATED_FUNCTION(fun) ((fun.data().toUInt32() & 0xFFFF0000) == 0xBABE0000)
 
44
 
 
45
Q_DECLARE_METATYPE(QEvent*)
 
46
Q_DECLARE_METATYPE(QChildEvent*)
 
47
Q_DECLARE_METATYPE(QCloseEvent*)
 
48
Q_DECLARE_METATYPE(Qt::ItemSelectionMode)
 
49
Q_DECLARE_METATYPE(QPainterPath)
 
50
Q_DECLARE_METATYPE(QGraphicsSceneContextMenuEvent*)
 
51
Q_DECLARE_METATYPE(QGraphicsSceneDragDropEvent*)
 
52
Q_DECLARE_METATYPE(QVariant)
 
53
Q_DECLARE_METATYPE(QFocusEvent*)
 
54
Q_DECLARE_METATYPE(qreal*)
 
55
Q_DECLARE_METATYPE(QHideEvent*)
 
56
Q_DECLARE_METATYPE(QGraphicsSceneHoverEvent*)
 
57
Q_DECLARE_METATYPE(QStyleOption*)
 
58
Q_DECLARE_METATYPE(QInputMethodEvent*)
 
59
Q_DECLARE_METATYPE(Qt::InputMethodQuery)
 
60
Q_DECLARE_METATYPE(QGraphicsItem::GraphicsItemChange)
 
61
Q_DECLARE_METATYPE(QKeyEvent*)
 
62
Q_DECLARE_METATYPE(QGraphicsSceneMouseEvent*)
 
63
Q_DECLARE_METATYPE(QGraphicsSceneMoveEvent*)
 
64
Q_DECLARE_METATYPE(QPainter*)
 
65
Q_DECLARE_METATYPE(QStyleOptionGraphicsItem*)
 
66
Q_DECLARE_METATYPE(QGraphicsSceneResizeEvent*)
 
67
Q_DECLARE_METATYPE(QShowEvent*)
 
68
Q_DECLARE_METATYPE(Qt::SizeHint)
 
69
Q_DECLARE_METATYPE(QTimerEvent*)
 
70
Q_DECLARE_METATYPE(QGraphicsSceneWheelEvent*)
 
71
Q_DECLARE_METATYPE(Qt::WindowFrameSection)
 
72
 
 
73
QtScriptShell_QGraphicsProxyWidget::QtScriptShell_QGraphicsProxyWidget(QGraphicsItem*  parent, Qt::WindowFlags  wFlags)
 
74
    : QGraphicsProxyWidget(parent, wFlags) {}
 
75
 
 
76
QtScriptShell_QGraphicsProxyWidget::~QtScriptShell_QGraphicsProxyWidget() {}
 
77
 
 
78
void QtScriptShell_QGraphicsProxyWidget::advance(int  phase)
 
79
{
 
80
    QScriptValue _q_function = __qtscript_self.property("advance");
 
81
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
82
        || (__qtscript_self.propertyFlags("advance") & QScriptValue::QObjectMember)) {
 
83
        QGraphicsProxyWidget::advance(phase);
 
84
    } else {
 
85
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
86
        _q_function.call(__qtscript_self,
 
87
            QScriptValueList()
 
88
            << qScriptValueFromValue(_q_engine, phase));
 
89
    }
 
90
}
 
91
 
 
92
QRectF  QtScriptShell_QGraphicsProxyWidget::boundingRect() const
 
93
{
 
94
    QScriptValue _q_function = __qtscript_self.property("boundingRect");
 
95
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
96
        || (__qtscript_self.propertyFlags("boundingRect") & QScriptValue::QObjectMember)) {
 
97
        return QGraphicsProxyWidget::boundingRect();
 
98
    } else {
 
99
        return qscriptvalue_cast<QRectF >(_q_function.call(__qtscript_self));
 
100
    }
 
101
}
 
102
 
 
103
void QtScriptShell_QGraphicsProxyWidget::changeEvent(QEvent*  event)
 
104
{
 
105
    QScriptValue _q_function = __qtscript_self.property("changeEvent");
 
106
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
107
        || (__qtscript_self.propertyFlags("changeEvent") & QScriptValue::QObjectMember)) {
 
108
        QGraphicsProxyWidget::changeEvent(event);
 
109
    } else {
 
110
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
111
        _q_function.call(__qtscript_self,
 
112
            QScriptValueList()
 
113
            << qScriptValueFromValue(_q_engine, event));
 
114
    }
 
115
}
 
116
 
 
117
void QtScriptShell_QGraphicsProxyWidget::childEvent(QChildEvent*  arg__1)
 
118
{
 
119
    QScriptValue _q_function = __qtscript_self.property("childEvent");
 
120
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
121
        || (__qtscript_self.propertyFlags("childEvent") & QScriptValue::QObjectMember)) {
 
122
        QGraphicsProxyWidget::childEvent(arg__1);
 
123
    } else {
 
124
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
125
        _q_function.call(__qtscript_self,
 
126
            QScriptValueList()
 
127
            << qScriptValueFromValue(_q_engine, arg__1));
 
128
    }
 
129
}
 
130
 
 
131
void QtScriptShell_QGraphicsProxyWidget::closeEvent(QCloseEvent*  event)
 
132
{
 
133
    QScriptValue _q_function = __qtscript_self.property("closeEvent");
 
134
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
135
        || (__qtscript_self.propertyFlags("closeEvent") & QScriptValue::QObjectMember)) {
 
136
        QGraphicsProxyWidget::closeEvent(event);
 
137
    } else {
 
138
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
139
        _q_function.call(__qtscript_self,
 
140
            QScriptValueList()
 
141
            << qScriptValueFromValue(_q_engine, event));
 
142
    }
 
143
}
 
144
 
 
145
bool  QtScriptShell_QGraphicsProxyWidget::collidesWithItem(const QGraphicsItem*  other, Qt::ItemSelectionMode  mode) const
 
146
{
 
147
    QScriptValue _q_function = __qtscript_self.property("collidesWithItem");
 
148
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
149
        || (__qtscript_self.propertyFlags("collidesWithItem") & QScriptValue::QObjectMember)) {
 
150
        return QGraphicsProxyWidget::collidesWithItem(other, mode);
 
151
    } else {
 
152
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
153
        return qscriptvalue_cast<bool >(_q_function.call(__qtscript_self,
 
154
            QScriptValueList()
 
155
            << qScriptValueFromValue(_q_engine, const_cast<QGraphicsItem *>(other))
 
156
            << qScriptValueFromValue(_q_engine, mode)));
 
157
    }
 
158
}
 
159
 
 
160
bool  QtScriptShell_QGraphicsProxyWidget::collidesWithPath(const QPainterPath&  path, Qt::ItemSelectionMode  mode) const
 
161
{
 
162
    QScriptValue _q_function = __qtscript_self.property("collidesWithPath");
 
163
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
164
        || (__qtscript_self.propertyFlags("collidesWithPath") & QScriptValue::QObjectMember)) {
 
165
        return QGraphicsProxyWidget::collidesWithPath(path, mode);
 
166
    } else {
 
167
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
168
        return qscriptvalue_cast<bool >(_q_function.call(__qtscript_self,
 
169
            QScriptValueList()
 
170
            << qScriptValueFromValue(_q_engine, path)
 
171
            << qScriptValueFromValue(_q_engine, mode)));
 
172
    }
 
173
}
 
174
 
 
175
bool  QtScriptShell_QGraphicsProxyWidget::contains(const QPointF&  point) const
 
176
{
 
177
    QScriptValue _q_function = __qtscript_self.property("contains");
 
178
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
179
        || (__qtscript_self.propertyFlags("contains") & QScriptValue::QObjectMember)) {
 
180
        return QGraphicsProxyWidget::contains(point);
 
181
    } else {
 
182
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
183
        return qscriptvalue_cast<bool >(_q_function.call(__qtscript_self,
 
184
            QScriptValueList()
 
185
            << qScriptValueFromValue(_q_engine, point)));
 
186
    }
 
187
}
 
188
 
 
189
void QtScriptShell_QGraphicsProxyWidget::contextMenuEvent(QGraphicsSceneContextMenuEvent*  event)
 
190
{
 
191
    QScriptValue _q_function = __qtscript_self.property("contextMenuEvent");
 
192
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
193
        || (__qtscript_self.propertyFlags("contextMenuEvent") & QScriptValue::QObjectMember)) {
 
194
        QGraphicsProxyWidget::contextMenuEvent(event);
 
195
    } else {
 
196
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
197
        _q_function.call(__qtscript_self,
 
198
            QScriptValueList()
 
199
            << qScriptValueFromValue(_q_engine, event));
 
200
    }
 
201
}
 
202
 
 
203
void QtScriptShell_QGraphicsProxyWidget::customEvent(QEvent*  arg__1)
 
204
{
 
205
    QScriptValue _q_function = __qtscript_self.property("customEvent");
 
206
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
207
        || (__qtscript_self.propertyFlags("customEvent") & QScriptValue::QObjectMember)) {
 
208
        QGraphicsProxyWidget::customEvent(arg__1);
 
209
    } else {
 
210
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
211
        _q_function.call(__qtscript_self,
 
212
            QScriptValueList()
 
213
            << qScriptValueFromValue(_q_engine, arg__1));
 
214
    }
 
215
}
 
216
 
 
217
void QtScriptShell_QGraphicsProxyWidget::dragEnterEvent(QGraphicsSceneDragDropEvent*  event)
 
218
{
 
219
    QScriptValue _q_function = __qtscript_self.property("dragEnterEvent");
 
220
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
221
        || (__qtscript_self.propertyFlags("dragEnterEvent") & QScriptValue::QObjectMember)) {
 
222
        QGraphicsProxyWidget::dragEnterEvent(event);
 
223
    } else {
 
224
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
225
        _q_function.call(__qtscript_self,
 
226
            QScriptValueList()
 
227
            << qScriptValueFromValue(_q_engine, event));
 
228
    }
 
229
}
 
230
 
 
231
void QtScriptShell_QGraphicsProxyWidget::dragLeaveEvent(QGraphicsSceneDragDropEvent*  event)
 
232
{
 
233
    QScriptValue _q_function = __qtscript_self.property("dragLeaveEvent");
 
234
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
235
        || (__qtscript_self.propertyFlags("dragLeaveEvent") & QScriptValue::QObjectMember)) {
 
236
        QGraphicsProxyWidget::dragLeaveEvent(event);
 
237
    } else {
 
238
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
239
        _q_function.call(__qtscript_self,
 
240
            QScriptValueList()
 
241
            << qScriptValueFromValue(_q_engine, event));
 
242
    }
 
243
}
 
244
 
 
245
void QtScriptShell_QGraphicsProxyWidget::dragMoveEvent(QGraphicsSceneDragDropEvent*  event)
 
246
{
 
247
    QScriptValue _q_function = __qtscript_self.property("dragMoveEvent");
 
248
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
249
        || (__qtscript_self.propertyFlags("dragMoveEvent") & QScriptValue::QObjectMember)) {
 
250
        QGraphicsProxyWidget::dragMoveEvent(event);
 
251
    } else {
 
252
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
253
        _q_function.call(__qtscript_self,
 
254
            QScriptValueList()
 
255
            << qScriptValueFromValue(_q_engine, event));
 
256
    }
 
257
}
 
258
 
 
259
void QtScriptShell_QGraphicsProxyWidget::dropEvent(QGraphicsSceneDragDropEvent*  event)
 
260
{
 
261
    QScriptValue _q_function = __qtscript_self.property("dropEvent");
 
262
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
263
        || (__qtscript_self.propertyFlags("dropEvent") & QScriptValue::QObjectMember)) {
 
264
        QGraphicsProxyWidget::dropEvent(event);
 
265
    } else {
 
266
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
267
        _q_function.call(__qtscript_self,
 
268
            QScriptValueList()
 
269
            << qScriptValueFromValue(_q_engine, event));
 
270
    }
 
271
}
 
272
 
 
273
bool  QtScriptShell_QGraphicsProxyWidget::event(QEvent*  event)
 
274
{
 
275
    QScriptValue _q_function = __qtscript_self.property("event");
 
276
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
277
        || (__qtscript_self.propertyFlags("event") & QScriptValue::QObjectMember)) {
 
278
        return QGraphicsProxyWidget::event(event);
 
279
    } else {
 
280
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
281
        return qscriptvalue_cast<bool >(_q_function.call(__qtscript_self,
 
282
            QScriptValueList()
 
283
            << qScriptValueFromValue(_q_engine, event)));
 
284
    }
 
285
}
 
286
 
 
287
bool  QtScriptShell_QGraphicsProxyWidget::eventFilter(QObject*  object, QEvent*  event)
 
288
{
 
289
    QScriptValue _q_function = __qtscript_self.property("eventFilter");
 
290
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
291
        || (__qtscript_self.propertyFlags("eventFilter") & QScriptValue::QObjectMember)) {
 
292
        return QGraphicsProxyWidget::eventFilter(object, event);
 
293
    } else {
 
294
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
295
        return qscriptvalue_cast<bool >(_q_function.call(__qtscript_self,
 
296
            QScriptValueList()
 
297
            << qScriptValueFromValue(_q_engine, object)
 
298
            << qScriptValueFromValue(_q_engine, event)));
 
299
    }
 
300
}
 
301
 
 
302
QVariant  QtScriptShell_QGraphicsProxyWidget::extension(const QVariant&  variant) const
 
303
{
 
304
    QScriptValue _q_function = __qtscript_self.property("extension");
 
305
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
306
        || (__qtscript_self.propertyFlags("extension") & QScriptValue::QObjectMember)) {
 
307
        return QGraphicsProxyWidget::extension(variant);
 
308
    } else {
 
309
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
310
        return qscriptvalue_cast<QVariant >(_q_function.call(__qtscript_self,
 
311
            QScriptValueList()
 
312
            << qScriptValueFromValue(_q_engine, variant)));
 
313
    }
 
314
}
 
315
 
 
316
void QtScriptShell_QGraphicsProxyWidget::focusInEvent(QFocusEvent*  event)
 
317
{
 
318
    QScriptValue _q_function = __qtscript_self.property("focusInEvent");
 
319
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
320
        || (__qtscript_self.propertyFlags("focusInEvent") & QScriptValue::QObjectMember)) {
 
321
        QGraphicsProxyWidget::focusInEvent(event);
 
322
    } else {
 
323
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
324
        _q_function.call(__qtscript_self,
 
325
            QScriptValueList()
 
326
            << qScriptValueFromValue(_q_engine, event));
 
327
    }
 
328
}
 
329
 
 
330
bool  QtScriptShell_QGraphicsProxyWidget::focusNextPrevChild(bool  next)
 
331
{
 
332
    QScriptValue _q_function = __qtscript_self.property("focusNextPrevChild");
 
333
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
334
        || (__qtscript_self.propertyFlags("focusNextPrevChild") & QScriptValue::QObjectMember)) {
 
335
        return QGraphicsProxyWidget::focusNextPrevChild(next);
 
336
    } else {
 
337
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
338
        return qscriptvalue_cast<bool >(_q_function.call(__qtscript_self,
 
339
            QScriptValueList()
 
340
            << qScriptValueFromValue(_q_engine, next)));
 
341
    }
 
342
}
 
343
 
 
344
void QtScriptShell_QGraphicsProxyWidget::focusOutEvent(QFocusEvent*  event)
 
345
{
 
346
    QScriptValue _q_function = __qtscript_self.property("focusOutEvent");
 
347
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
348
        || (__qtscript_self.propertyFlags("focusOutEvent") & QScriptValue::QObjectMember)) {
 
349
        QGraphicsProxyWidget::focusOutEvent(event);
 
350
    } else {
 
351
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
352
        _q_function.call(__qtscript_self,
 
353
            QScriptValueList()
 
354
            << qScriptValueFromValue(_q_engine, event));
 
355
    }
 
356
}
 
357
 
 
358
void QtScriptShell_QGraphicsProxyWidget::getContentsMargins(qreal*  left, qreal*  top, qreal*  right, qreal*  bottom) const
 
359
{
 
360
    QScriptValue _q_function = __qtscript_self.property("getContentsMargins");
 
361
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
362
        || (__qtscript_self.propertyFlags("getContentsMargins") & QScriptValue::QObjectMember)) {
 
363
        QGraphicsProxyWidget::getContentsMargins(left, top, right, bottom);
 
364
    } else {
 
365
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
366
        _q_function.call(__qtscript_self,
 
367
            QScriptValueList()
 
368
            << qScriptValueFromValue(_q_engine, left)
 
369
            << qScriptValueFromValue(_q_engine, top)
 
370
            << qScriptValueFromValue(_q_engine, right)
 
371
            << qScriptValueFromValue(_q_engine, bottom));
 
372
    }
 
373
}
 
374
 
 
375
void QtScriptShell_QGraphicsProxyWidget::grabKeyboardEvent(QEvent*  event)
 
376
{
 
377
    QScriptValue _q_function = __qtscript_self.property("grabKeyboardEvent");
 
378
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
379
        || (__qtscript_self.propertyFlags("grabKeyboardEvent") & QScriptValue::QObjectMember)) {
 
380
        QGraphicsProxyWidget::grabKeyboardEvent(event);
 
381
    } else {
 
382
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
383
        _q_function.call(__qtscript_self,
 
384
            QScriptValueList()
 
385
            << qScriptValueFromValue(_q_engine, event));
 
386
    }
 
387
}
 
388
 
 
389
void QtScriptShell_QGraphicsProxyWidget::grabMouseEvent(QEvent*  event)
 
390
{
 
391
    QScriptValue _q_function = __qtscript_self.property("grabMouseEvent");
 
392
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
393
        || (__qtscript_self.propertyFlags("grabMouseEvent") & QScriptValue::QObjectMember)) {
 
394
        QGraphicsProxyWidget::grabMouseEvent(event);
 
395
    } else {
 
396
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
397
        _q_function.call(__qtscript_self,
 
398
            QScriptValueList()
 
399
            << qScriptValueFromValue(_q_engine, event));
 
400
    }
 
401
}
 
402
 
 
403
void QtScriptShell_QGraphicsProxyWidget::hideEvent(QHideEvent*  event)
 
404
{
 
405
    QScriptValue _q_function = __qtscript_self.property("hideEvent");
 
406
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
407
        || (__qtscript_self.propertyFlags("hideEvent") & QScriptValue::QObjectMember)) {
 
408
        QGraphicsProxyWidget::hideEvent(event);
 
409
    } else {
 
410
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
411
        _q_function.call(__qtscript_self,
 
412
            QScriptValueList()
 
413
            << qScriptValueFromValue(_q_engine, event));
 
414
    }
 
415
}
 
416
 
 
417
void QtScriptShell_QGraphicsProxyWidget::hoverEnterEvent(QGraphicsSceneHoverEvent*  event)
 
418
{
 
419
    QScriptValue _q_function = __qtscript_self.property("hoverEnterEvent");
 
420
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
421
        || (__qtscript_self.propertyFlags("hoverEnterEvent") & QScriptValue::QObjectMember)) {
 
422
        QGraphicsProxyWidget::hoverEnterEvent(event);
 
423
    } else {
 
424
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
425
        _q_function.call(__qtscript_self,
 
426
            QScriptValueList()
 
427
            << qScriptValueFromValue(_q_engine, event));
 
428
    }
 
429
}
 
430
 
 
431
void QtScriptShell_QGraphicsProxyWidget::hoverLeaveEvent(QGraphicsSceneHoverEvent*  event)
 
432
{
 
433
    QScriptValue _q_function = __qtscript_self.property("hoverLeaveEvent");
 
434
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
435
        || (__qtscript_self.propertyFlags("hoverLeaveEvent") & QScriptValue::QObjectMember)) {
 
436
        QGraphicsProxyWidget::hoverLeaveEvent(event);
 
437
    } else {
 
438
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
439
        _q_function.call(__qtscript_self,
 
440
            QScriptValueList()
 
441
            << qScriptValueFromValue(_q_engine, event));
 
442
    }
 
443
}
 
444
 
 
445
void QtScriptShell_QGraphicsProxyWidget::hoverMoveEvent(QGraphicsSceneHoverEvent*  event)
 
446
{
 
447
    QScriptValue _q_function = __qtscript_self.property("hoverMoveEvent");
 
448
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
449
        || (__qtscript_self.propertyFlags("hoverMoveEvent") & QScriptValue::QObjectMember)) {
 
450
        QGraphicsProxyWidget::hoverMoveEvent(event);
 
451
    } else {
 
452
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
453
        _q_function.call(__qtscript_self,
 
454
            QScriptValueList()
 
455
            << qScriptValueFromValue(_q_engine, event));
 
456
    }
 
457
}
 
458
 
 
459
void QtScriptShell_QGraphicsProxyWidget::initStyleOption(QStyleOption*  option) const
 
460
{
 
461
    QScriptValue _q_function = __qtscript_self.property("initStyleOption");
 
462
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
463
        || (__qtscript_self.propertyFlags("initStyleOption") & QScriptValue::QObjectMember)) {
 
464
        QGraphicsProxyWidget::initStyleOption(option);
 
465
    } else {
 
466
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
467
        _q_function.call(__qtscript_self,
 
468
            QScriptValueList()
 
469
            << qScriptValueFromValue(_q_engine, option));
 
470
    }
 
471
}
 
472
 
 
473
void QtScriptShell_QGraphicsProxyWidget::inputMethodEvent(QInputMethodEvent*  event)
 
474
{
 
475
    QScriptValue _q_function = __qtscript_self.property("inputMethodEvent");
 
476
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
477
        || (__qtscript_self.propertyFlags("inputMethodEvent") & QScriptValue::QObjectMember)) {
 
478
        QGraphicsProxyWidget::inputMethodEvent(event);
 
479
    } else {
 
480
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
481
        _q_function.call(__qtscript_self,
 
482
            QScriptValueList()
 
483
            << qScriptValueFromValue(_q_engine, event));
 
484
    }
 
485
}
 
486
 
 
487
QVariant  QtScriptShell_QGraphicsProxyWidget::inputMethodQuery(Qt::InputMethodQuery  query) const
 
488
{
 
489
    QScriptValue _q_function = __qtscript_self.property("inputMethodQuery");
 
490
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
491
        || (__qtscript_self.propertyFlags("inputMethodQuery") & QScriptValue::QObjectMember)) {
 
492
        return QGraphicsProxyWidget::inputMethodQuery(query);
 
493
    } else {
 
494
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
495
        return qscriptvalue_cast<QVariant >(_q_function.call(__qtscript_self,
 
496
            QScriptValueList()
 
497
            << qScriptValueFromValue(_q_engine, query)));
 
498
    }
 
499
}
 
500
 
 
501
bool  QtScriptShell_QGraphicsProxyWidget::isObscuredBy(const QGraphicsItem*  item) const
 
502
{
 
503
    QScriptValue _q_function = __qtscript_self.property("isObscuredBy");
 
504
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
505
        || (__qtscript_self.propertyFlags("isObscuredBy") & QScriptValue::QObjectMember)) {
 
506
        return QGraphicsProxyWidget::isObscuredBy(item);
 
507
    } else {
 
508
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
509
        return qscriptvalue_cast<bool >(_q_function.call(__qtscript_self,
 
510
            QScriptValueList()
 
511
            << qScriptValueFromValue(_q_engine, const_cast<QGraphicsItem *>(item))));
 
512
    }
 
513
}
 
514
 
 
515
QVariant  QtScriptShell_QGraphicsProxyWidget::itemChange(QGraphicsItem::GraphicsItemChange  change, const QVariant&  value)
 
516
{
 
517
    QScriptValue _q_function = __qtscript_self.property("itemChange");
 
518
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
519
        || (__qtscript_self.propertyFlags("itemChange") & QScriptValue::QObjectMember)) {
 
520
        return QGraphicsProxyWidget::itemChange(change, value);
 
521
    } else {
 
522
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
523
        return qscriptvalue_cast<QVariant >(_q_function.call(__qtscript_self,
 
524
            QScriptValueList()
 
525
            << qScriptValueFromValue(_q_engine, change)
 
526
            << qScriptValueFromValue(_q_engine, value)));
 
527
    }
 
528
}
 
529
 
 
530
void QtScriptShell_QGraphicsProxyWidget::keyPressEvent(QKeyEvent*  event)
 
531
{
 
532
    QScriptValue _q_function = __qtscript_self.property("keyPressEvent");
 
533
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
534
        || (__qtscript_self.propertyFlags("keyPressEvent") & QScriptValue::QObjectMember)) {
 
535
        QGraphicsProxyWidget::keyPressEvent(event);
 
536
    } else {
 
537
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
538
        _q_function.call(__qtscript_self,
 
539
            QScriptValueList()
 
540
            << qScriptValueFromValue(_q_engine, event));
 
541
    }
 
542
}
 
543
 
 
544
void QtScriptShell_QGraphicsProxyWidget::keyReleaseEvent(QKeyEvent*  event)
 
545
{
 
546
    QScriptValue _q_function = __qtscript_self.property("keyReleaseEvent");
 
547
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
548
        || (__qtscript_self.propertyFlags("keyReleaseEvent") & QScriptValue::QObjectMember)) {
 
549
        QGraphicsProxyWidget::keyReleaseEvent(event);
 
550
    } else {
 
551
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
552
        _q_function.call(__qtscript_self,
 
553
            QScriptValueList()
 
554
            << qScriptValueFromValue(_q_engine, event));
 
555
    }
 
556
}
 
557
 
 
558
void QtScriptShell_QGraphicsProxyWidget::mouseDoubleClickEvent(QGraphicsSceneMouseEvent*  event)
 
559
{
 
560
    QScriptValue _q_function = __qtscript_self.property("mouseDoubleClickEvent");
 
561
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
562
        || (__qtscript_self.propertyFlags("mouseDoubleClickEvent") & QScriptValue::QObjectMember)) {
 
563
        QGraphicsProxyWidget::mouseDoubleClickEvent(event);
 
564
    } else {
 
565
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
566
        _q_function.call(__qtscript_self,
 
567
            QScriptValueList()
 
568
            << qScriptValueFromValue(_q_engine, event));
 
569
    }
 
570
}
 
571
 
 
572
void QtScriptShell_QGraphicsProxyWidget::mouseMoveEvent(QGraphicsSceneMouseEvent*  event)
 
573
{
 
574
    QScriptValue _q_function = __qtscript_self.property("mouseMoveEvent");
 
575
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
576
        || (__qtscript_self.propertyFlags("mouseMoveEvent") & QScriptValue::QObjectMember)) {
 
577
        QGraphicsProxyWidget::mouseMoveEvent(event);
 
578
    } else {
 
579
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
580
        _q_function.call(__qtscript_self,
 
581
            QScriptValueList()
 
582
            << qScriptValueFromValue(_q_engine, event));
 
583
    }
 
584
}
 
585
 
 
586
void QtScriptShell_QGraphicsProxyWidget::mousePressEvent(QGraphicsSceneMouseEvent*  event)
 
587
{
 
588
    QScriptValue _q_function = __qtscript_self.property("mousePressEvent");
 
589
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
590
        || (__qtscript_self.propertyFlags("mousePressEvent") & QScriptValue::QObjectMember)) {
 
591
        QGraphicsProxyWidget::mousePressEvent(event);
 
592
    } else {
 
593
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
594
        _q_function.call(__qtscript_self,
 
595
            QScriptValueList()
 
596
            << qScriptValueFromValue(_q_engine, event));
 
597
    }
 
598
}
 
599
 
 
600
void QtScriptShell_QGraphicsProxyWidget::mouseReleaseEvent(QGraphicsSceneMouseEvent*  event)
 
601
{
 
602
    QScriptValue _q_function = __qtscript_self.property("mouseReleaseEvent");
 
603
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
604
        || (__qtscript_self.propertyFlags("mouseReleaseEvent") & QScriptValue::QObjectMember)) {
 
605
        QGraphicsProxyWidget::mouseReleaseEvent(event);
 
606
    } else {
 
607
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
608
        _q_function.call(__qtscript_self,
 
609
            QScriptValueList()
 
610
            << qScriptValueFromValue(_q_engine, event));
 
611
    }
 
612
}
 
613
 
 
614
void QtScriptShell_QGraphicsProxyWidget::moveEvent(QGraphicsSceneMoveEvent*  event)
 
615
{
 
616
    QScriptValue _q_function = __qtscript_self.property("moveEvent");
 
617
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
618
        || (__qtscript_self.propertyFlags("moveEvent") & QScriptValue::QObjectMember)) {
 
619
        QGraphicsProxyWidget::moveEvent(event);
 
620
    } else {
 
621
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
622
        _q_function.call(__qtscript_self,
 
623
            QScriptValueList()
 
624
            << qScriptValueFromValue(_q_engine, event));
 
625
    }
 
626
}
 
627
 
 
628
QPainterPath  QtScriptShell_QGraphicsProxyWidget::opaqueArea() const
 
629
{
 
630
    QScriptValue _q_function = __qtscript_self.property("opaqueArea");
 
631
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
632
        || (__qtscript_self.propertyFlags("opaqueArea") & QScriptValue::QObjectMember)) {
 
633
        return QGraphicsProxyWidget::opaqueArea();
 
634
    } else {
 
635
        return qscriptvalue_cast<QPainterPath >(_q_function.call(__qtscript_self));
 
636
    }
 
637
}
 
638
 
 
639
void QtScriptShell_QGraphicsProxyWidget::paint(QPainter*  painter, const QStyleOptionGraphicsItem*  option, QWidget*  widget)
 
640
{
 
641
    QScriptValue _q_function = __qtscript_self.property("paint");
 
642
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
643
        || (__qtscript_self.propertyFlags("paint") & QScriptValue::QObjectMember)) {
 
644
        QGraphicsProxyWidget::paint(painter, option, widget);
 
645
    } else {
 
646
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
647
        _q_function.call(__qtscript_self,
 
648
            QScriptValueList()
 
649
            << qScriptValueFromValue(_q_engine, painter)
 
650
            << qScriptValueFromValue(_q_engine, const_cast<QStyleOptionGraphicsItem *>(option))
 
651
            << qScriptValueFromValue(_q_engine, widget));
 
652
    }
 
653
}
 
654
 
 
655
void QtScriptShell_QGraphicsProxyWidget::paintWindowFrame(QPainter*  painter, const QStyleOptionGraphicsItem*  option, QWidget*  widget)
 
656
{
 
657
    QScriptValue _q_function = __qtscript_self.property("paintWindowFrame");
 
658
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
659
        || (__qtscript_self.propertyFlags("paintWindowFrame") & QScriptValue::QObjectMember)) {
 
660
        QGraphicsProxyWidget::paintWindowFrame(painter, option, widget);
 
661
    } else {
 
662
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
663
        _q_function.call(__qtscript_self,
 
664
            QScriptValueList()
 
665
            << qScriptValueFromValue(_q_engine, painter)
 
666
            << qScriptValueFromValue(_q_engine, const_cast<QStyleOptionGraphicsItem *>(option))
 
667
            << qScriptValueFromValue(_q_engine, widget));
 
668
    }
 
669
}
 
670
 
 
671
void QtScriptShell_QGraphicsProxyWidget::polishEvent()
 
672
{
 
673
    QScriptValue _q_function = __qtscript_self.property("polishEvent");
 
674
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
675
        || (__qtscript_self.propertyFlags("polishEvent") & QScriptValue::QObjectMember)) {
 
676
        QGraphicsProxyWidget::polishEvent();
 
677
    } else {
 
678
        _q_function.call(__qtscript_self);
 
679
    }
 
680
}
 
681
 
 
682
QVariant  QtScriptShell_QGraphicsProxyWidget::propertyChange(const QString&  propertyName, const QVariant&  value)
 
683
{
 
684
    QScriptValue _q_function = __qtscript_self.property("propertyChange");
 
685
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
686
        || (__qtscript_self.propertyFlags("propertyChange") & QScriptValue::QObjectMember)) {
 
687
        return QGraphicsProxyWidget::propertyChange(propertyName, value);
 
688
    } else {
 
689
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
690
        return qscriptvalue_cast<QVariant >(_q_function.call(__qtscript_self,
 
691
            QScriptValueList()
 
692
            << qScriptValueFromValue(_q_engine, propertyName)
 
693
            << qScriptValueFromValue(_q_engine, value)));
 
694
    }
 
695
}
 
696
 
 
697
void QtScriptShell_QGraphicsProxyWidget::resizeEvent(QGraphicsSceneResizeEvent*  event)
 
698
{
 
699
    QScriptValue _q_function = __qtscript_self.property("resizeEvent");
 
700
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
701
        || (__qtscript_self.propertyFlags("resizeEvent") & QScriptValue::QObjectMember)) {
 
702
        QGraphicsProxyWidget::resizeEvent(event);
 
703
    } else {
 
704
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
705
        _q_function.call(__qtscript_self,
 
706
            QScriptValueList()
 
707
            << qScriptValueFromValue(_q_engine, event));
 
708
    }
 
709
}
 
710
 
 
711
bool  QtScriptShell_QGraphicsProxyWidget::sceneEvent(QEvent*  event)
 
712
{
 
713
    QScriptValue _q_function = __qtscript_self.property("sceneEvent");
 
714
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
715
        || (__qtscript_self.propertyFlags("sceneEvent") & QScriptValue::QObjectMember)) {
 
716
        return QGraphicsProxyWidget::sceneEvent(event);
 
717
    } else {
 
718
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
719
        return qscriptvalue_cast<bool >(_q_function.call(__qtscript_self,
 
720
            QScriptValueList()
 
721
            << qScriptValueFromValue(_q_engine, event)));
 
722
    }
 
723
}
 
724
 
 
725
bool  QtScriptShell_QGraphicsProxyWidget::sceneEventFilter(QGraphicsItem*  watched, QEvent*  event)
 
726
{
 
727
    QScriptValue _q_function = __qtscript_self.property("sceneEventFilter");
 
728
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
729
        || (__qtscript_self.propertyFlags("sceneEventFilter") & QScriptValue::QObjectMember)) {
 
730
        return QGraphicsProxyWidget::sceneEventFilter(watched, event);
 
731
    } else {
 
732
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
733
        return qscriptvalue_cast<bool >(_q_function.call(__qtscript_self,
 
734
            QScriptValueList()
 
735
            << qScriptValueFromValue(_q_engine, watched)
 
736
            << qScriptValueFromValue(_q_engine, event)));
 
737
    }
 
738
}
 
739
 
 
740
void QtScriptShell_QGraphicsProxyWidget::setGeometry(const QRectF&  rect)
 
741
{
 
742
    QScriptValue _q_function = __qtscript_self.property("setGeometry");
 
743
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
744
        || (__qtscript_self.propertyFlags("setGeometry") & QScriptValue::QObjectMember)) {
 
745
        QGraphicsProxyWidget::setGeometry(rect);
 
746
    } else {
 
747
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
748
        _q_function.call(__qtscript_self,
 
749
            QScriptValueList()
 
750
            << qScriptValueFromValue(_q_engine, rect));
 
751
    }
 
752
}
 
753
 
 
754
QPainterPath  QtScriptShell_QGraphicsProxyWidget::shape() const
 
755
{
 
756
    QScriptValue _q_function = __qtscript_self.property("shape");
 
757
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
758
        || (__qtscript_self.propertyFlags("shape") & QScriptValue::QObjectMember)) {
 
759
        return QGraphicsProxyWidget::shape();
 
760
    } else {
 
761
        return qscriptvalue_cast<QPainterPath >(_q_function.call(__qtscript_self));
 
762
    }
 
763
}
 
764
 
 
765
void QtScriptShell_QGraphicsProxyWidget::showEvent(QShowEvent*  event)
 
766
{
 
767
    QScriptValue _q_function = __qtscript_self.property("showEvent");
 
768
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
769
        || (__qtscript_self.propertyFlags("showEvent") & QScriptValue::QObjectMember)) {
 
770
        QGraphicsProxyWidget::showEvent(event);
 
771
    } else {
 
772
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
773
        _q_function.call(__qtscript_self,
 
774
            QScriptValueList()
 
775
            << qScriptValueFromValue(_q_engine, event));
 
776
    }
 
777
}
 
778
 
 
779
QSizeF  QtScriptShell_QGraphicsProxyWidget::sizeHint(Qt::SizeHint  which, const QSizeF&  constraint) const
 
780
{
 
781
    QScriptValue _q_function = __qtscript_self.property("sizeHint");
 
782
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
783
        || (__qtscript_self.propertyFlags("sizeHint") & QScriptValue::QObjectMember)) {
 
784
        return QGraphicsProxyWidget::sizeHint(which, constraint);
 
785
    } else {
 
786
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
787
        return qscriptvalue_cast<QSizeF >(_q_function.call(__qtscript_self,
 
788
            QScriptValueList()
 
789
            << qScriptValueFromValue(_q_engine, which)
 
790
            << qScriptValueFromValue(_q_engine, constraint)));
 
791
    }
 
792
}
 
793
 
 
794
void QtScriptShell_QGraphicsProxyWidget::timerEvent(QTimerEvent*  arg__1)
 
795
{
 
796
    QScriptValue _q_function = __qtscript_self.property("timerEvent");
 
797
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
798
        || (__qtscript_self.propertyFlags("timerEvent") & QScriptValue::QObjectMember)) {
 
799
        QGraphicsProxyWidget::timerEvent(arg__1);
 
800
    } else {
 
801
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
802
        _q_function.call(__qtscript_self,
 
803
            QScriptValueList()
 
804
            << qScriptValueFromValue(_q_engine, arg__1));
 
805
    }
 
806
}
 
807
 
 
808
int  QtScriptShell_QGraphicsProxyWidget::type() const
 
809
{
 
810
    QScriptValue _q_function = __qtscript_self.property("type");
 
811
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
812
        || (__qtscript_self.propertyFlags("type") & QScriptValue::QObjectMember)) {
 
813
        return QGraphicsProxyWidget::type();
 
814
    } else {
 
815
        return qscriptvalue_cast<int >(_q_function.call(__qtscript_self));
 
816
    }
 
817
}
 
818
 
 
819
void QtScriptShell_QGraphicsProxyWidget::ungrabKeyboardEvent(QEvent*  event)
 
820
{
 
821
    QScriptValue _q_function = __qtscript_self.property("ungrabKeyboardEvent");
 
822
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
823
        || (__qtscript_self.propertyFlags("ungrabKeyboardEvent") & QScriptValue::QObjectMember)) {
 
824
        QGraphicsProxyWidget::ungrabKeyboardEvent(event);
 
825
    } else {
 
826
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
827
        _q_function.call(__qtscript_self,
 
828
            QScriptValueList()
 
829
            << qScriptValueFromValue(_q_engine, event));
 
830
    }
 
831
}
 
832
 
 
833
void QtScriptShell_QGraphicsProxyWidget::ungrabMouseEvent(QEvent*  event)
 
834
{
 
835
    QScriptValue _q_function = __qtscript_self.property("ungrabMouseEvent");
 
836
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
837
        || (__qtscript_self.propertyFlags("ungrabMouseEvent") & QScriptValue::QObjectMember)) {
 
838
        QGraphicsProxyWidget::ungrabMouseEvent(event);
 
839
    } else {
 
840
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
841
        _q_function.call(__qtscript_self,
 
842
            QScriptValueList()
 
843
            << qScriptValueFromValue(_q_engine, event));
 
844
    }
 
845
}
 
846
 
 
847
void QtScriptShell_QGraphicsProxyWidget::updateGeometry()
 
848
{
 
849
    QScriptValue _q_function = __qtscript_self.property("updateGeometry");
 
850
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
851
        || (__qtscript_self.propertyFlags("updateGeometry") & QScriptValue::QObjectMember)) {
 
852
        QGraphicsProxyWidget::updateGeometry();
 
853
    } else {
 
854
        _q_function.call(__qtscript_self);
 
855
    }
 
856
}
 
857
 
 
858
void QtScriptShell_QGraphicsProxyWidget::wheelEvent(QGraphicsSceneWheelEvent*  event)
 
859
{
 
860
    QScriptValue _q_function = __qtscript_self.property("wheelEvent");
 
861
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
862
        || (__qtscript_self.propertyFlags("wheelEvent") & QScriptValue::QObjectMember)) {
 
863
        QGraphicsProxyWidget::wheelEvent(event);
 
864
    } else {
 
865
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
866
        _q_function.call(__qtscript_self,
 
867
            QScriptValueList()
 
868
            << qScriptValueFromValue(_q_engine, event));
 
869
    }
 
870
}
 
871
 
 
872
bool  QtScriptShell_QGraphicsProxyWidget::windowFrameEvent(QEvent*  e)
 
873
{
 
874
    QScriptValue _q_function = __qtscript_self.property("windowFrameEvent");
 
875
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
876
        || (__qtscript_self.propertyFlags("windowFrameEvent") & QScriptValue::QObjectMember)) {
 
877
        return QGraphicsProxyWidget::windowFrameEvent(e);
 
878
    } else {
 
879
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
880
        return qscriptvalue_cast<bool >(_q_function.call(__qtscript_self,
 
881
            QScriptValueList()
 
882
            << qScriptValueFromValue(_q_engine, e)));
 
883
    }
 
884
}
 
885
 
 
886
Qt::WindowFrameSection  QtScriptShell_QGraphicsProxyWidget::windowFrameSectionAt(const QPointF&  pos) const
 
887
{
 
888
    QScriptValue _q_function = __qtscript_self.property("windowFrameSectionAt");
 
889
    if (!_q_function.isFunction() || QTSCRIPT_IS_GENERATED_FUNCTION(_q_function)
 
890
        || (__qtscript_self.propertyFlags("windowFrameSectionAt") & QScriptValue::QObjectMember)) {
 
891
        return QGraphicsProxyWidget::windowFrameSectionAt(pos);
 
892
    } else {
 
893
        QScriptEngine *_q_engine = __qtscript_self.engine();
 
894
        return qscriptvalue_cast<Qt::WindowFrameSection >(_q_function.call(__qtscript_self,
 
895
            QScriptValueList()
 
896
            << qScriptValueFromValue(_q_engine, pos)));
 
897
    }
 
898
}
 
899