|
|
#include "PythonQtWrapper_QGraphicsWidget.h"
|
|
|
|
|
|
#include <PythonQtSignalReceiver.h>
|
|
|
#include <PythonQtMethodInfo.h>
|
|
|
#include <PythonQtConversion.h>
|
|
|
#include <QVariant>
|
|
|
#include <qbytearray.h>
|
|
|
#include <qcoreevent.h>
|
|
|
#include <qcursor.h>
|
|
|
#include <qevent.h>
|
|
|
#include <qfont.h>
|
|
|
#include <qgraphicsitem.h>
|
|
|
#include <qgraphicslayout.h>
|
|
|
#include <qgraphicslayoutitem.h>
|
|
|
#include <qgraphicsscene.h>
|
|
|
#include <qgraphicssceneevent.h>
|
|
|
#include <qgraphicswidget.h>
|
|
|
#include <qlist.h>
|
|
|
#include <qobject.h>
|
|
|
#include <qpainter.h>
|
|
|
#include <qpainterpath.h>
|
|
|
#include <qpalette.h>
|
|
|
#include <qpoint.h>
|
|
|
#include <qpolygon.h>
|
|
|
#include <qrect.h>
|
|
|
#include <qregion.h>
|
|
|
#include <qsize.h>
|
|
|
#include <qsizepolicy.h>
|
|
|
#include <qstyle.h>
|
|
|
#include <qstyleoption.h>
|
|
|
#include <qtransform.h>
|
|
|
#include <qwidget.h>
|
|
|
|
|
|
void PythonQtShell_QGraphicsWidget::advance(int phase)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "advance");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"advance(QGraphicsWidget*,int )");
|
|
|
void* args[2] = {NULL, (void*)&phase};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::advance(phase);
|
|
|
}
|
|
|
QRectF PythonQtShell_QGraphicsWidget::boundingRect() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "boundingRect");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"boundingRect(QGraphicsWidget*)");
|
|
|
QRectF returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
returnValue = *((QRectF *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QGraphicsWidget::boundingRect();
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::changeEvent(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"changeEvent(QGraphicsWidget*,QEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::changeEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"childEvent(QGraphicsWidget*,QChildEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::closeEvent(QCloseEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"closeEvent(QGraphicsWidget*,QCloseEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::closeEvent(event);
|
|
|
}
|
|
|
bool PythonQtShell_QGraphicsWidget::collidesWithItem(const QGraphicsItem* other, Qt::ItemSelectionMode mode) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "collidesWithItem");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"collidesWithItem(QGraphicsWidget*,const QGraphicsItem* ,Qt::ItemSelectionMode )");
|
|
|
bool returnValue;
|
|
|
void* args[3] = {NULL, (void*)&other, (void*)&mode};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
returnValue = *((bool *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QGraphicsWidget::collidesWithItem(other, mode);
|
|
|
}
|
|
|
bool PythonQtShell_QGraphicsWidget::collidesWithPath(const QPainterPath& path, Qt::ItemSelectionMode mode) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "collidesWithPath");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"collidesWithPath(QGraphicsWidget*,const QPainterPath& ,Qt::ItemSelectionMode )");
|
|
|
bool returnValue;
|
|
|
void* args[3] = {NULL, (void*)&path, (void*)&mode};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
returnValue = *((bool *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QGraphicsWidget::collidesWithPath(path, mode);
|
|
|
}
|
|
|
bool PythonQtShell_QGraphicsWidget::contains(const QPointF& point) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contains");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"contains(QGraphicsWidget*,const QPointF& )");
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&point};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
returnValue = *((bool *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QGraphicsWidget::contains(point);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::contextMenuEvent(QGraphicsSceneContextMenuEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"contextMenuEvent(QGraphicsWidget*,QGraphicsSceneContextMenuEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::contextMenuEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"customEvent(QGraphicsWidget*,QEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::customEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::dragEnterEvent(QGraphicsSceneDragDropEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"dragEnterEvent(QGraphicsWidget*,QGraphicsSceneDragDropEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::dragEnterEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::dragLeaveEvent(QGraphicsSceneDragDropEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"dragLeaveEvent(QGraphicsWidget*,QGraphicsSceneDragDropEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::dragLeaveEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::dragMoveEvent(QGraphicsSceneDragDropEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"dragMoveEvent(QGraphicsWidget*,QGraphicsSceneDragDropEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::dragMoveEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::dropEvent(QGraphicsSceneDragDropEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"dropEvent(QGraphicsWidget*,QGraphicsSceneDragDropEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::dropEvent(event);
|
|
|
}
|
|
|
bool PythonQtShell_QGraphicsWidget::event(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"event(QGraphicsWidget*,QEvent* )");
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
returnValue = *((bool *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QGraphicsWidget::event(event);
|
|
|
}
|
|
|
bool PythonQtShell_QGraphicsWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"eventFilter(QGraphicsWidget*,QObject* ,QEvent* )");
|
|
|
bool returnValue;
|
|
|
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
returnValue = *((bool *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QGraphicsWidget::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
QVariant PythonQtShell_QGraphicsWidget::extension(const QVariant& variant) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "extension");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"extension(QGraphicsWidget*,const QVariant& )");
|
|
|
QVariant returnValue;
|
|
|
void* args[2] = {NULL, (void*)&variant};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
returnValue = *((QVariant *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QGraphicsWidget::extension(variant);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::focusInEvent(QFocusEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"focusInEvent(QGraphicsWidget*,QFocusEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::focusInEvent(event);
|
|
|
}
|
|
|
bool PythonQtShell_QGraphicsWidget::focusNextPrevChild(bool next)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"focusNextPrevChild(QGraphicsWidget*,bool )");
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&next};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
returnValue = *((bool *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QGraphicsWidget::focusNextPrevChild(next);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::focusOutEvent(QFocusEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"focusOutEvent(QGraphicsWidget*,QFocusEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::focusOutEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::getContentsMargins(qreal* left, qreal* top, qreal* right, qreal* bottom) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getContentsMargins");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"getContentsMargins(QGraphicsWidget*,qreal* ,qreal* ,qreal* ,qreal* )");
|
|
|
void* args[5] = {NULL, (void*)&left, (void*)&top, (void*)&right, (void*)&bottom};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::getContentsMargins(left, top, right, bottom);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::grabKeyboardEvent(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "grabKeyboardEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"grabKeyboardEvent(QGraphicsWidget*,QEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::grabKeyboardEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::grabMouseEvent(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "grabMouseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"grabMouseEvent(QGraphicsWidget*,QEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::grabMouseEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::hideEvent(QHideEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"hideEvent(QGraphicsWidget*,QHideEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::hideEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::hoverEnterEvent(QGraphicsSceneHoverEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hoverEnterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"hoverEnterEvent(QGraphicsWidget*,QGraphicsSceneHoverEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::hoverEnterEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::hoverLeaveEvent(QGraphicsSceneHoverEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hoverLeaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"hoverLeaveEvent(QGraphicsWidget*,QGraphicsSceneHoverEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::hoverLeaveEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::hoverMoveEvent(QGraphicsSceneHoverEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hoverMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"hoverMoveEvent(QGraphicsWidget*,QGraphicsSceneHoverEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::hoverMoveEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::initStyleOption(QStyleOption* option) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initStyleOption");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"initStyleOption(QGraphicsWidget*,QStyleOption* )");
|
|
|
void* args[2] = {NULL, (void*)&option};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::initStyleOption(option);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::inputMethodEvent(QInputMethodEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"inputMethodEvent(QGraphicsWidget*,QInputMethodEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::inputMethodEvent(event);
|
|
|
}
|
|
|
QVariant PythonQtShell_QGraphicsWidget::inputMethodQuery(Qt::InputMethodQuery query) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"inputMethodQuery(QGraphicsWidget*,Qt::InputMethodQuery )");
|
|
|
QVariant returnValue;
|
|
|
void* args[2] = {NULL, (void*)&query};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
returnValue = *((QVariant *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QGraphicsWidget::inputMethodQuery(query);
|
|
|
}
|
|
|
bool PythonQtShell_QGraphicsWidget::isObscuredBy(const QGraphicsItem* item) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isObscuredBy");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"isObscuredBy(QGraphicsWidget*,const QGraphicsItem* )");
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&item};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
returnValue = *((bool *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QGraphicsWidget::isObscuredBy(item);
|
|
|
}
|
|
|
QVariant PythonQtShell_QGraphicsWidget::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant& value)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "itemChange");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"itemChange(QGraphicsWidget*,QGraphicsItem::GraphicsItemChange ,const QVariant& )");
|
|
|
QVariant returnValue;
|
|
|
void* args[3] = {NULL, (void*)&change, (void*)&value};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
returnValue = *((QVariant *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QGraphicsWidget::itemChange(change, value);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::keyPressEvent(QKeyEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"keyPressEvent(QGraphicsWidget*,QKeyEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::keyPressEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::keyReleaseEvent(QKeyEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"keyReleaseEvent(QGraphicsWidget*,QKeyEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::keyReleaseEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"mouseDoubleClickEvent(QGraphicsWidget*,QGraphicsSceneMouseEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::mouseDoubleClickEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"mouseMoveEvent(QGraphicsWidget*,QGraphicsSceneMouseEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::mouseMoveEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::mousePressEvent(QGraphicsSceneMouseEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"mousePressEvent(QGraphicsWidget*,QGraphicsSceneMouseEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::mousePressEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::mouseReleaseEvent(QGraphicsSceneMouseEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"mouseReleaseEvent(QGraphicsWidget*,QGraphicsSceneMouseEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::mouseReleaseEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::moveEvent(QGraphicsSceneMoveEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"moveEvent(QGraphicsWidget*,QGraphicsSceneMoveEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::moveEvent(event);
|
|
|
}
|
|
|
QPainterPath PythonQtShell_QGraphicsWidget::opaqueArea() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "opaqueArea");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"opaqueArea(QGraphicsWidget*)");
|
|
|
QPainterPath returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
returnValue = *((QPainterPath *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QGraphicsWidget::opaqueArea();
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paint");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"paint(QGraphicsWidget*,QPainter* ,const QStyleOptionGraphicsItem* ,QWidget* )");
|
|
|
void* args[4] = {NULL, (void*)&painter, (void*)&option, (void*)&widget};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::paint(painter, option, widget);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::paintWindowFrame(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintWindowFrame");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"paintWindowFrame(QGraphicsWidget*,QPainter* ,const QStyleOptionGraphicsItem* ,QWidget* )");
|
|
|
void* args[4] = {NULL, (void*)&painter, (void*)&option, (void*)&widget};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::paintWindowFrame(painter, option, widget);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::polishEvent()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "polishEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"polishEvent(QGraphicsWidget*)");
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::polishEvent();
|
|
|
}
|
|
|
QVariant PythonQtShell_QGraphicsWidget::propertyChange(const QString& propertyName, const QVariant& value)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "propertyChange");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"propertyChange(QGraphicsWidget*,const QString& ,const QVariant& )");
|
|
|
QVariant returnValue;
|
|
|
void* args[3] = {NULL, (void*)&propertyName, (void*)&value};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
returnValue = *((QVariant *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QGraphicsWidget::propertyChange(propertyName, value);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::resizeEvent(QGraphicsSceneResizeEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"resizeEvent(QGraphicsWidget*,QGraphicsSceneResizeEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::resizeEvent(event);
|
|
|
}
|
|
|
bool PythonQtShell_QGraphicsWidget::sceneEvent(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sceneEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"sceneEvent(QGraphicsWidget*,QEvent* )");
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
returnValue = *((bool *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QGraphicsWidget::sceneEvent(event);
|
|
|
}
|
|
|
bool PythonQtShell_QGraphicsWidget::sceneEventFilter(QGraphicsItem* watched, QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sceneEventFilter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"sceneEventFilter(QGraphicsWidget*,QGraphicsItem* ,QEvent* )");
|
|
|
bool returnValue;
|
|
|
void* args[3] = {NULL, (void*)&watched, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
returnValue = *((bool *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QGraphicsWidget::sceneEventFilter(watched, event);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::setExtension(QGraphicsItem::Extension extension, const QVariant& variant)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setExtension");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"setExtension(QGraphicsWidget*,QGraphicsItem::Extension ,const QVariant& )");
|
|
|
void* args[3] = {NULL, (void*)&extension, (void*)&variant};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::setExtension(extension, variant);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::setGeometry(const QRectF& rect)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setGeometry");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"setGeometry(QGraphicsWidget*,const QRectF& )");
|
|
|
void* args[2] = {NULL, (void*)&rect};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::setGeometry(rect);
|
|
|
}
|
|
|
QPainterPath PythonQtShell_QGraphicsWidget::shape() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "shape");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"shape(QGraphicsWidget*)");
|
|
|
QPainterPath returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
returnValue = *((QPainterPath *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QGraphicsWidget::shape();
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::showEvent(QShowEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"showEvent(QGraphicsWidget*,QShowEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::showEvent(event);
|
|
|
}
|
|
|
QSizeF PythonQtShell_QGraphicsWidget::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sizeHint");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"sizeHint(QGraphicsWidget*,Qt::SizeHint ,const QSizeF& )");
|
|
|
QSizeF returnValue;
|
|
|
void* args[3] = {NULL, (void*)&which, (void*)&constraint};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
returnValue = *((QSizeF *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QGraphicsWidget::sizeHint(which, constraint);
|
|
|
}
|
|
|
bool PythonQtShell_QGraphicsWidget::supportsExtension(QGraphicsItem::Extension extension) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "supportsExtension");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"supportsExtension(QGraphicsWidget*,QGraphicsItem::Extension )");
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&extension};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
returnValue = *((bool *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QGraphicsWidget::supportsExtension(extension);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"timerEvent(QGraphicsWidget*,QTimerEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::timerEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QGraphicsWidget::type() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "type");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"type(QGraphicsWidget*)");
|
|
|
int returnValue;
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
returnValue = *((int *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QGraphicsWidget::type();
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::ungrabKeyboardEvent(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "ungrabKeyboardEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"ungrabKeyboardEvent(QGraphicsWidget*,QEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::ungrabKeyboardEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::ungrabMouseEvent(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "ungrabMouseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"ungrabMouseEvent(QGraphicsWidget*,QEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::ungrabMouseEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::updateGeometry()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateGeometry");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"updateGeometry(QGraphicsWidget*)");
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::updateGeometry();
|
|
|
}
|
|
|
void PythonQtShell_QGraphicsWidget::wheelEvent(QGraphicsSceneWheelEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"wheelEvent(QGraphicsWidget*,QGraphicsSceneWheelEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QGraphicsWidget::wheelEvent(event);
|
|
|
}
|
|
|
bool PythonQtShell_QGraphicsWidget::windowFrameEvent(QEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "windowFrameEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"windowFrameEvent(QGraphicsWidget*,QEvent* )");
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
returnValue = *((bool *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QGraphicsWidget::windowFrameEvent(e);
|
|
|
}
|
|
|
Qt::WindowFrameSection PythonQtShell_QGraphicsWidget::windowFrameSectionAt(const QPointF& pos) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "windowFrameSectionAt");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QGraphicsWidget::staticMetaObject,
|
|
|
"windowFrameSectionAt(QGraphicsWidget*,const QPointF& )");
|
|
|
Qt::WindowFrameSection returnValue;
|
|
|
void* args[2] = {NULL, (void*)&pos};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
returnValue = *((Qt::WindowFrameSection *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QGraphicsWidget::windowFrameSectionAt(pos);
|
|
|
}
|
|
|
QGraphicsWidget* PythonQtWrapper_QGraphicsWidget::new_QGraphicsWidget(QGraphicsItem* parent, Qt::WindowFlags wFlags)
|
|
|
{
|
|
|
return new PythonQtShell_QGraphicsWidget(parent, wFlags); }
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::setGeometry(QGraphicsWidget* theWrappedObject, qreal x, qreal y, qreal w, qreal h)
|
|
|
{
|
|
|
theWrappedObject->setGeometry(x, y, w, h);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::polishEvent(QGraphicsWidget* theWrappedObject)
|
|
|
{
|
|
|
((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_polishEvent();
|
|
|
}
|
|
|
|
|
|
QGraphicsLayout* PythonQtWrapper_QGraphicsWidget::layout(QGraphicsWidget* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->layout();
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::getContentsMargins(QGraphicsWidget* theWrappedObject, qreal* left, qreal* top, qreal* right, qreal* bottom) const
|
|
|
{
|
|
|
((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_getContentsMargins(left, top, right, bottom);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::setWindowTitle(QGraphicsWidget* theWrappedObject, const QString& title)
|
|
|
{
|
|
|
theWrappedObject->setWindowTitle(title);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QGraphicsWidget::focusNextPrevChild(QGraphicsWidget* theWrappedObject, bool next)
|
|
|
{
|
|
|
return ((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_focusNextPrevChild(next);
|
|
|
}
|
|
|
|
|
|
QRectF PythonQtWrapper_QGraphicsWidget::windowFrameRect(QGraphicsWidget* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->windowFrameRect();
|
|
|
}
|
|
|
|
|
|
QVariant PythonQtWrapper_QGraphicsWidget::propertyChange(QGraphicsWidget* theWrappedObject, const QString& propertyName, const QVariant& value)
|
|
|
{
|
|
|
return ((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_propertyChange(propertyName, value);
|
|
|
}
|
|
|
|
|
|
QPalette PythonQtWrapper_QGraphicsWidget::palette(QGraphicsWidget* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->palette();
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QGraphicsWidget::windowFrameEvent(QGraphicsWidget* theWrappedObject, QEvent* e)
|
|
|
{
|
|
|
return ((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_windowFrameEvent(e);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::ungrabKeyboardEvent(QGraphicsWidget* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_ungrabKeyboardEvent(event);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::setStyle(QGraphicsWidget* theWrappedObject, QStyle* style)
|
|
|
{
|
|
|
theWrappedObject->setStyle(style);
|
|
|
}
|
|
|
|
|
|
Qt::LayoutDirection PythonQtWrapper_QGraphicsWidget::layoutDirection(QGraphicsWidget* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->layoutDirection();
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::grabKeyboardEvent(QGraphicsWidget* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_grabKeyboardEvent(event);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::resizeEvent(QGraphicsWidget* theWrappedObject, QGraphicsSceneResizeEvent* event)
|
|
|
{
|
|
|
((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_resizeEvent(event);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::setLayout(QGraphicsWidget* theWrappedObject, QGraphicsLayout* layout)
|
|
|
{
|
|
|
theWrappedObject->setLayout(layout);
|
|
|
}
|
|
|
|
|
|
QFont PythonQtWrapper_QGraphicsWidget::font(QGraphicsWidget* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->font();
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::setFocusPolicy(QGraphicsWidget* theWrappedObject, Qt::FocusPolicy policy)
|
|
|
{
|
|
|
theWrappedObject->setFocusPolicy(policy);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::static_QGraphicsWidget_setTabOrder(QGraphicsWidget* first, QGraphicsWidget* second)
|
|
|
{
|
|
|
QGraphicsWidget::setTabOrder(first, second);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QGraphicsWidget::testAttribute(QGraphicsWidget* theWrappedObject, Qt::WidgetAttribute attribute) const
|
|
|
{
|
|
|
return theWrappedObject->testAttribute(attribute);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::getWindowFrameMargins(QGraphicsWidget* theWrappedObject, qreal* left, qreal* top, qreal* right, qreal* bottom) const
|
|
|
{
|
|
|
theWrappedObject->getWindowFrameMargins(left, top, right, bottom);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::showEvent(QGraphicsWidget* theWrappedObject, QShowEvent* event)
|
|
|
{
|
|
|
((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_showEvent(event);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::unsetWindowFrameMargins(QGraphicsWidget* theWrappedObject)
|
|
|
{
|
|
|
theWrappedObject->unsetWindowFrameMargins();
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QGraphicsWidget::type(QGraphicsWidget* theWrappedObject) const
|
|
|
{
|
|
|
return ((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_type();
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::resize(QGraphicsWidget* theWrappedObject, qreal w, qreal h)
|
|
|
{
|
|
|
theWrappedObject->resize(w, h);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QGraphicsWidget::sceneEvent(QGraphicsWidget* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
return ((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_sceneEvent(event);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::ungrabMouseEvent(QGraphicsWidget* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_ungrabMouseEvent(event);
|
|
|
}
|
|
|
|
|
|
Qt::WindowFrameSection PythonQtWrapper_QGraphicsWidget::windowFrameSectionAt(QGraphicsWidget* theWrappedObject, const QPointF& pos) const
|
|
|
{
|
|
|
return ((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_windowFrameSectionAt(pos);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::hideEvent(QGraphicsWidget* theWrappedObject, QHideEvent* event)
|
|
|
{
|
|
|
((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_hideEvent(event);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::setPalette(QGraphicsWidget* theWrappedObject, const QPalette& palette)
|
|
|
{
|
|
|
theWrappedObject->setPalette(palette);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::moveEvent(QGraphicsWidget* theWrappedObject, QGraphicsSceneMoveEvent* event)
|
|
|
{
|
|
|
((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_moveEvent(event);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::setWindowFrameMargins(QGraphicsWidget* theWrappedObject, qreal left, qreal top, qreal right, qreal bottom)
|
|
|
{
|
|
|
theWrappedObject->setWindowFrameMargins(left, top, right, bottom);
|
|
|
}
|
|
|
|
|
|
QRectF PythonQtWrapper_QGraphicsWidget::boundingRect(QGraphicsWidget* theWrappedObject) const
|
|
|
{
|
|
|
return ((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_boundingRect();
|
|
|
}
|
|
|
|
|
|
Qt::WindowType PythonQtWrapper_QGraphicsWidget::windowType(QGraphicsWidget* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->windowType();
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::grabMouseEvent(QGraphicsWidget* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_grabMouseEvent(event);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::closeEvent(QGraphicsWidget* theWrappedObject, QCloseEvent* event)
|
|
|
{
|
|
|
((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_closeEvent(event);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::hoverMoveEvent(QGraphicsWidget* theWrappedObject, QGraphicsSceneHoverEvent* event)
|
|
|
{
|
|
|
((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_hoverMoveEvent(event);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::unsetLayoutDirection(QGraphicsWidget* theWrappedObject)
|
|
|
{
|
|
|
theWrappedObject->unsetLayoutDirection();
|
|
|
}
|
|
|
|
|
|
Qt::WindowFlags PythonQtWrapper_QGraphicsWidget::windowFlags(QGraphicsWidget* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->windowFlags();
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::hoverLeaveEvent(QGraphicsWidget* theWrappedObject, QGraphicsSceneHoverEvent* event)
|
|
|
{
|
|
|
((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_hoverLeaveEvent(event);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::changeEvent(QGraphicsWidget* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_changeEvent(event);
|
|
|
}
|
|
|
|
|
|
QRectF PythonQtWrapper_QGraphicsWidget::rect(QGraphicsWidget* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->rect();
|
|
|
}
|
|
|
|
|
|
Qt::FocusPolicy PythonQtWrapper_QGraphicsWidget::focusPolicy(QGraphicsWidget* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->focusPolicy();
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::initStyleOption(QGraphicsWidget* theWrappedObject, QStyleOption* option) const
|
|
|
{
|
|
|
((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_initStyleOption(option);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::setAttribute(QGraphicsWidget* theWrappedObject, Qt::WidgetAttribute attribute, bool on)
|
|
|
{
|
|
|
theWrappedObject->setAttribute(attribute, on);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QGraphicsWidget::event(QGraphicsWidget* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
return ((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_event(event);
|
|
|
}
|
|
|
|
|
|
QGraphicsWidget* PythonQtWrapper_QGraphicsWidget::focusWidget(QGraphicsWidget* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->focusWidget();
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::setWindowFlags(QGraphicsWidget* theWrappedObject, Qt::WindowFlags wFlags)
|
|
|
{
|
|
|
theWrappedObject->setWindowFlags(wFlags);
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QGraphicsWidget::windowTitle(QGraphicsWidget* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->windowTitle();
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::focusInEvent(QGraphicsWidget* theWrappedObject, QFocusEvent* event)
|
|
|
{
|
|
|
((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_focusInEvent(event);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::adjustSize(QGraphicsWidget* theWrappedObject)
|
|
|
{
|
|
|
theWrappedObject->adjustSize();
|
|
|
}
|
|
|
|
|
|
QRectF PythonQtWrapper_QGraphicsWidget::windowFrameGeometry(QGraphicsWidget* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->windowFrameGeometry();
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::paint(QGraphicsWidget* theWrappedObject, QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
|
|
|
{
|
|
|
((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_paint(painter, option, widget);
|
|
|
}
|
|
|
|
|
|
QStyle* PythonQtWrapper_QGraphicsWidget::style(QGraphicsWidget* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->style();
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::resize(QGraphicsWidget* theWrappedObject, const QSizeF& size)
|
|
|
{
|
|
|
theWrappedObject->resize(size);
|
|
|
}
|
|
|
|
|
|
QSizeF PythonQtWrapper_QGraphicsWidget::size(QGraphicsWidget* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->size();
|
|
|
}
|
|
|
|
|
|
QSizeF PythonQtWrapper_QGraphicsWidget::sizeHint(QGraphicsWidget* theWrappedObject, Qt::SizeHint which, const QSizeF& constraint) const
|
|
|
{
|
|
|
return ((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_sizeHint(which, constraint);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::setFont(QGraphicsWidget* theWrappedObject, const QFont& font)
|
|
|
{
|
|
|
theWrappedObject->setFont(font);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::setContentsMargins(QGraphicsWidget* theWrappedObject, qreal left, qreal top, qreal right, qreal bottom)
|
|
|
{
|
|
|
theWrappedObject->setContentsMargins(left, top, right, bottom);
|
|
|
}
|
|
|
|
|
|
QVariant PythonQtWrapper_QGraphicsWidget::itemChange(QGraphicsWidget* theWrappedObject, QGraphicsItem::GraphicsItemChange change, const QVariant& value)
|
|
|
{
|
|
|
return ((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_itemChange(change, value);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::focusOutEvent(QGraphicsWidget* theWrappedObject, QFocusEvent* event)
|
|
|
{
|
|
|
((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_focusOutEvent(event);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QGraphicsWidget::isActiveWindow(QGraphicsWidget* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->isActiveWindow();
|
|
|
}
|
|
|
|
|
|
QPainterPath PythonQtWrapper_QGraphicsWidget::shape(QGraphicsWidget* theWrappedObject) const
|
|
|
{
|
|
|
return ((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_shape();
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::setLayoutDirection(QGraphicsWidget* theWrappedObject, Qt::LayoutDirection direction)
|
|
|
{
|
|
|
theWrappedObject->setLayoutDirection(direction);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::paintWindowFrame(QGraphicsWidget* theWrappedObject, QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
|
|
|
{
|
|
|
((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_paintWindowFrame(painter, option, widget);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::updateGeometry(QGraphicsWidget* theWrappedObject)
|
|
|
{
|
|
|
((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_updateGeometry();
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QGraphicsWidget::setGeometry(QGraphicsWidget* theWrappedObject, const QRectF& rect)
|
|
|
{
|
|
|
((PythonQtPublicPromoter_QGraphicsWidget*)theWrappedObject)->promoted_setGeometry(rect);
|
|
|
}
|
|
|
|
|
|
|