|
|
#include "com_trolltech_qt_gui5.h"
|
|
|
#include <PythonQtConversion.h>
|
|
|
#include <PythonQtMethodInfo.h>
|
|
|
#include <PythonQtSignalReceiver.h>
|
|
|
#include <QColor>
|
|
|
#include <QImage>
|
|
|
#include <QPainterPath>
|
|
|
#include <QPixmap>
|
|
|
#include <QRect>
|
|
|
#include <QSize>
|
|
|
#include <QVarLengthArray>
|
|
|
#include <QVariant>
|
|
|
#include <QWidget>
|
|
|
#include <qabstractanimation.h>
|
|
|
#include <qabstractbutton.h>
|
|
|
#include <qabstractitemdelegate.h>
|
|
|
#include <qabstractitemmodel.h>
|
|
|
#include <qabstractstate.h>
|
|
|
#include <qaction.h>
|
|
|
#include <qapplication.h>
|
|
|
#include <qbitmap.h>
|
|
|
#include <qbrush.h>
|
|
|
#include <qbytearray.h>
|
|
|
#include <qcolor.h>
|
|
|
#include <qcompleter.h>
|
|
|
#include <qcoreevent.h>
|
|
|
#include <qcursor.h>
|
|
|
#include <qdatastream.h>
|
|
|
#include <qdialog.h>
|
|
|
#include <qdockwidget.h>
|
|
|
#include <qevent.h>
|
|
|
#include <qfont.h>
|
|
|
#include <qfontinfo.h>
|
|
|
#include <qfontmetrics.h>
|
|
|
#include <qgraphicseffect.h>
|
|
|
#include <qgraphicsproxywidget.h>
|
|
|
#include <qicon.h>
|
|
|
#include <qimage.h>
|
|
|
#include <qinputcontext.h>
|
|
|
#include <qiodevice.h>
|
|
|
#include <qitemselectionmodel.h>
|
|
|
#include <qkeysequence.h>
|
|
|
#include <qlayout.h>
|
|
|
#include <qlayoutitem.h>
|
|
|
#include <qline.h>
|
|
|
#include <qlineedit.h>
|
|
|
#include <qlist.h>
|
|
|
#include <qlistview.h>
|
|
|
#include <qlistwidget.h>
|
|
|
#include <qlocale.h>
|
|
|
#include <qmainwindow.h>
|
|
|
#include <qmargins.h>
|
|
|
#include <qmatrix.h>
|
|
|
#include <qmatrix4x4.h>
|
|
|
#include <qmdiarea.h>
|
|
|
#include <qmdisubwindow.h>
|
|
|
#include <qmenu.h>
|
|
|
#include <qmenubar.h>
|
|
|
#include <qmessagebox.h>
|
|
|
#include <qmimedata.h>
|
|
|
#include <qmotifstyle.h>
|
|
|
#include <qmouseeventtransition.h>
|
|
|
#include <qmovie.h>
|
|
|
#include <qobject.h>
|
|
|
#include <qpaintdevice.h>
|
|
|
#include <qpaintengine.h>
|
|
|
#include <qpainter.h>
|
|
|
#include <qpainterpath.h>
|
|
|
#include <qpair.h>
|
|
|
#include <qpalette.h>
|
|
|
#include <qpen.h>
|
|
|
#include <qpicture.h>
|
|
|
#include <qpixmap.h>
|
|
|
#include <qpoint.h>
|
|
|
#include <qpolygon.h>
|
|
|
#include <qprinter.h>
|
|
|
#include <qpushbutton.h>
|
|
|
#include <qquaternion.h>
|
|
|
#include <qrect.h>
|
|
|
#include <qregion.h>
|
|
|
#include <qscrollbar.h>
|
|
|
#include <qsize.h>
|
|
|
#include <qsizepolicy.h>
|
|
|
#include <qstate.h>
|
|
|
#include <qstatemachine.h>
|
|
|
#include <qstatictext.h>
|
|
|
#include <qstatusbar.h>
|
|
|
#include <qstringlist.h>
|
|
|
#include <qstyle.h>
|
|
|
#include <qstyleoption.h>
|
|
|
#include <qtextoption.h>
|
|
|
#include <qtoolbar.h>
|
|
|
#include <qtransform.h>
|
|
|
#include <qvalidator.h>
|
|
|
#include <qvector.h>
|
|
|
#include <qvector3d.h>
|
|
|
#include <qvector4d.h>
|
|
|
#include <qwidget.h>
|
|
|
|
|
|
PythonQtShell_QLayout::~PythonQtShell_QLayout() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QLayout::addItem(QLayoutItem* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "addItem");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QLayoutItem*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
void PythonQtShell_QLayout::childEvent(QChildEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLayout::childEvent(e);
|
|
|
}
|
|
|
int PythonQtShell_QLayout::count() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "count");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("count", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return int();
|
|
|
}
|
|
|
void PythonQtShell_QLayout::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLayout::customEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QLayout::event(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLayout::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QLayout::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 char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLayout::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
Qt::Orientations PythonQtShell_QLayout::expandingDirections() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "expandingDirections");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"Qt::Orientations"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
Qt::Orientations 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("expandingDirections", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((Qt::Orientations*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLayout::expandingDirections();
|
|
|
}
|
|
|
QRect PythonQtShell_QLayout::geometry() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "geometry");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QRect"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QRect 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("geometry", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QRect*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLayout::geometry();
|
|
|
}
|
|
|
bool PythonQtShell_QLayout::hasHeightForWidth() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
bool 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLayout::hasHeightForWidth();
|
|
|
}
|
|
|
int PythonQtShell_QLayout::heightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLayout::heightForWidth(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QLayout::indexOf(QWidget* arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "indexOf");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "QWidget*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("indexOf", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLayout::indexOf(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QLayout::invalidate()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "invalidate");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLayout::invalidate();
|
|
|
}
|
|
|
bool PythonQtShell_QLayout::isEmpty() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isEmpty");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
bool 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("isEmpty", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLayout::isEmpty();
|
|
|
}
|
|
|
QLayoutItem* PythonQtShell_QLayout::itemAt(int index) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "itemAt");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QLayoutItem*" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QLayoutItem* returnValue;
|
|
|
void* args[2] = {NULL, (void*)&index};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("itemAt", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QLayoutItem**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
QLayout* PythonQtShell_QLayout::layout()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "layout");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QLayout*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QLayout* 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("layout", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QLayout**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLayout::layout();
|
|
|
}
|
|
|
QSize PythonQtShell_QLayout::maximumSize() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "maximumSize");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QSize"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QSize 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("maximumSize", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QSize*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLayout::maximumSize();
|
|
|
}
|
|
|
int PythonQtShell_QLayout::minimumHeightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "minimumHeightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("minimumHeightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLayout::minimumHeightForWidth(arg__1);
|
|
|
}
|
|
|
QSize PythonQtShell_QLayout::minimumSize() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "minimumSize");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QSize"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QSize 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("minimumSize", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QSize*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLayout::minimumSize();
|
|
|
}
|
|
|
void PythonQtShell_QLayout::setGeometry(const QRect& arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setGeometry");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QRect&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLayout::setGeometry(arg__1);
|
|
|
}
|
|
|
QSize PythonQtShell_QLayout::sizeHint() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sizeHint");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QSize"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QSize 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("sizeHint", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QSize*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QSize();
|
|
|
}
|
|
|
QSpacerItem* PythonQtShell_QLayout::spacerItem()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "spacerItem");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QSpacerItem*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QSpacerItem* 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("spacerItem", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QSpacerItem**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLayout::spacerItem();
|
|
|
}
|
|
|
QLayoutItem* PythonQtShell_QLayout::takeAt(int index)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "takeAt");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QLayoutItem*" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QLayoutItem* returnValue;
|
|
|
void* args[2] = {NULL, (void*)&index};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("takeAt", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QLayoutItem**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
void PythonQtShell_QLayout::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLayout::timerEvent(arg__1);
|
|
|
}
|
|
|
QWidget* PythonQtShell_QLayout::widget()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "widget");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QWidget*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QWidget* 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("widget", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QWidget**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLayout::widget();
|
|
|
}
|
|
|
QLayout* PythonQtWrapper_QLayout::new_QLayout()
|
|
|
{
|
|
|
return new PythonQtShell_QLayout(); }
|
|
|
|
|
|
QLayout* PythonQtWrapper_QLayout::new_QLayout(QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QLayout(parent); }
|
|
|
|
|
|
bool PythonQtWrapper_QLayout::activate(QLayout* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->activate());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLayout::addWidget(QLayout* theWrappedObject, QWidget* w)
|
|
|
{
|
|
|
( theWrappedObject->addWidget(w));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLayout::childEvent(QLayout* theWrappedObject, QChildEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QLayout*)theWrappedObject)->promoted_childEvent(e));
|
|
|
}
|
|
|
|
|
|
QSize PythonQtWrapper_QLayout::static_QLayout_closestAcceptableSize(const QWidget* w, const QSize& s)
|
|
|
{
|
|
|
return (QLayout::closestAcceptableSize(w, s));
|
|
|
}
|
|
|
|
|
|
QMargins PythonQtWrapper_QLayout::contentsMargins(QLayout* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->contentsMargins());
|
|
|
}
|
|
|
|
|
|
QRect PythonQtWrapper_QLayout::contentsRect(QLayout* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->contentsRect());
|
|
|
}
|
|
|
|
|
|
Qt::Orientations PythonQtWrapper_QLayout::expandingDirections(QLayout* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QLayout*)theWrappedObject)->promoted_expandingDirections());
|
|
|
}
|
|
|
|
|
|
QRect PythonQtWrapper_QLayout::geometry(QLayout* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QLayout*)theWrappedObject)->promoted_geometry());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLayout::getContentsMargins(QLayout* theWrappedObject, int* left, int* top, int* right, int* bottom) const
|
|
|
{
|
|
|
( theWrappedObject->getContentsMargins(left, top, right, bottom));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QLayout::indexOf(QLayout* theWrappedObject, QWidget* arg__1) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QLayout*)theWrappedObject)->promoted_indexOf(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLayout::invalidate(QLayout* theWrappedObject)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QLayout*)theWrappedObject)->promoted_invalidate());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QLayout::isEmpty(QLayout* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QLayout*)theWrappedObject)->promoted_isEmpty());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QLayout::isEnabled(QLayout* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isEnabled());
|
|
|
}
|
|
|
|
|
|
QLayout* PythonQtWrapper_QLayout::layout(QLayout* theWrappedObject)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QLayout*)theWrappedObject)->promoted_layout());
|
|
|
}
|
|
|
|
|
|
QSize PythonQtWrapper_QLayout::maximumSize(QLayout* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QLayout*)theWrappedObject)->promoted_maximumSize());
|
|
|
}
|
|
|
|
|
|
QWidget* PythonQtWrapper_QLayout::menuBar(QLayout* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->menuBar());
|
|
|
}
|
|
|
|
|
|
QSize PythonQtWrapper_QLayout::minimumSize(QLayout* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QLayout*)theWrappedObject)->promoted_minimumSize());
|
|
|
}
|
|
|
|
|
|
QWidget* PythonQtWrapper_QLayout::parentWidget(QLayout* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->parentWidget());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLayout::removeItem(QLayout* theWrappedObject, QLayoutItem* arg__1)
|
|
|
{
|
|
|
( theWrappedObject->removeItem(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLayout::removeWidget(QLayout* theWrappedObject, QWidget* w)
|
|
|
{
|
|
|
( theWrappedObject->removeWidget(w));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLayout::setAlignment(QLayout* theWrappedObject, Qt::Alignment alignment)
|
|
|
{
|
|
|
( theWrappedObject->setAlignment(alignment));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QLayout::setAlignment(QLayout* theWrappedObject, QLayout* l, Qt::Alignment alignment)
|
|
|
{
|
|
|
return ( theWrappedObject->setAlignment(l, alignment));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QLayout::setAlignment(QLayout* theWrappedObject, QWidget* w, Qt::Alignment alignment)
|
|
|
{
|
|
|
return ( theWrappedObject->setAlignment(w, alignment));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLayout::setContentsMargins(QLayout* theWrappedObject, const QMargins& margins)
|
|
|
{
|
|
|
( theWrappedObject->setContentsMargins(margins));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLayout::setContentsMargins(QLayout* theWrappedObject, int left, int top, int right, int bottom)
|
|
|
{
|
|
|
( theWrappedObject->setContentsMargins(left, top, right, bottom));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLayout::setEnabled(QLayout* theWrappedObject, bool arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setEnabled(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLayout::setGeometry(QLayout* theWrappedObject, const QRect& arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QLayout*)theWrappedObject)->promoted_setGeometry(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLayout::setMargin(QLayout* theWrappedObject, int arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setMargin(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLayout::setMenuBar(QLayout* theWrappedObject, QWidget* w)
|
|
|
{
|
|
|
( theWrappedObject->setMenuBar(w));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLayout::setSizeConstraint(QLayout* theWrappedObject, QLayout::SizeConstraint arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setSizeConstraint(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLayout::setSpacing(QLayout* theWrappedObject, int arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setSpacing(arg__1));
|
|
|
}
|
|
|
|
|
|
QLayout::SizeConstraint PythonQtWrapper_QLayout::sizeConstraint(QLayout* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->sizeConstraint());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QLayout::spacing(QLayout* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->spacing());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QLayout::totalHeightForWidth(QLayout* theWrappedObject, int w) const
|
|
|
{
|
|
|
return ( theWrappedObject->totalHeightForWidth(w));
|
|
|
}
|
|
|
|
|
|
QSize PythonQtWrapper_QLayout::totalMaximumSize(QLayout* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->totalMaximumSize());
|
|
|
}
|
|
|
|
|
|
QSize PythonQtWrapper_QLayout::totalMinimumSize(QLayout* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->totalMinimumSize());
|
|
|
}
|
|
|
|
|
|
QSize PythonQtWrapper_QLayout::totalSizeHint(QLayout* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->totalSizeHint());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLayout::update(QLayout* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->update());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QLayoutItem::~PythonQtShell_QLayoutItem() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
Qt::Orientations PythonQtShell_QLayoutItem::expandingDirections() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "expandingDirections");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"Qt::Orientations"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
Qt::Orientations 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("expandingDirections", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((Qt::Orientations*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return Qt::Orientations();
|
|
|
}
|
|
|
QRect PythonQtShell_QLayoutItem::geometry() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "geometry");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QRect"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QRect 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("geometry", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QRect*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QRect();
|
|
|
}
|
|
|
bool PythonQtShell_QLayoutItem::hasHeightForWidth() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
bool 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLayoutItem::hasHeightForWidth();
|
|
|
}
|
|
|
int PythonQtShell_QLayoutItem::heightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLayoutItem::heightForWidth(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QLayoutItem::invalidate()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "invalidate");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLayoutItem::invalidate();
|
|
|
}
|
|
|
bool PythonQtShell_QLayoutItem::isEmpty() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isEmpty");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
bool 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("isEmpty", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return bool();
|
|
|
}
|
|
|
QLayout* PythonQtShell_QLayoutItem::layout()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "layout");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QLayout*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QLayout* 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("layout", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QLayout**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLayoutItem::layout();
|
|
|
}
|
|
|
QSize PythonQtShell_QLayoutItem::maximumSize() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "maximumSize");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QSize"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QSize 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("maximumSize", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QSize*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QSize();
|
|
|
}
|
|
|
int PythonQtShell_QLayoutItem::minimumHeightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "minimumHeightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("minimumHeightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLayoutItem::minimumHeightForWidth(arg__1);
|
|
|
}
|
|
|
QSize PythonQtShell_QLayoutItem::minimumSize() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "minimumSize");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QSize"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QSize 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("minimumSize", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QSize*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QSize();
|
|
|
}
|
|
|
void PythonQtShell_QLayoutItem::setGeometry(const QRect& arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setGeometry");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QRect&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
QSize PythonQtShell_QLayoutItem::sizeHint() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sizeHint");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QSize"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QSize 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("sizeHint", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QSize*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QSize();
|
|
|
}
|
|
|
QSpacerItem* PythonQtShell_QLayoutItem::spacerItem()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "spacerItem");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QSpacerItem*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QSpacerItem* 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("spacerItem", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QSpacerItem**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLayoutItem::spacerItem();
|
|
|
}
|
|
|
QWidget* PythonQtShell_QLayoutItem::widget()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "widget");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QWidget*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QWidget* 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("widget", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QWidget**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLayoutItem::widget();
|
|
|
}
|
|
|
QLayoutItem* PythonQtWrapper_QLayoutItem::new_QLayoutItem(Qt::Alignment alignment)
|
|
|
{
|
|
|
return new PythonQtShell_QLayoutItem(alignment); }
|
|
|
|
|
|
Qt::Alignment PythonQtWrapper_QLayoutItem::alignment(QLayoutItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->alignment());
|
|
|
}
|
|
|
|
|
|
QSizePolicy::ControlTypes PythonQtWrapper_QLayoutItem::controlTypes(QLayoutItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->controlTypes());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QLayoutItem::hasHeightForWidth(QLayoutItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QLayoutItem*)theWrappedObject)->promoted_hasHeightForWidth());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QLayoutItem::heightForWidth(QLayoutItem* theWrappedObject, int arg__1) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QLayoutItem*)theWrappedObject)->promoted_heightForWidth(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLayoutItem::invalidate(QLayoutItem* theWrappedObject)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QLayoutItem*)theWrappedObject)->promoted_invalidate());
|
|
|
}
|
|
|
|
|
|
QLayout* PythonQtWrapper_QLayoutItem::layout(QLayoutItem* theWrappedObject)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QLayoutItem*)theWrappedObject)->promoted_layout());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QLayoutItem::minimumHeightForWidth(QLayoutItem* theWrappedObject, int arg__1) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QLayoutItem*)theWrappedObject)->promoted_minimumHeightForWidth(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLayoutItem::setAlignment(QLayoutItem* theWrappedObject, Qt::Alignment a)
|
|
|
{
|
|
|
( theWrappedObject->setAlignment(a));
|
|
|
}
|
|
|
|
|
|
QSpacerItem* PythonQtWrapper_QLayoutItem::spacerItem(QLayoutItem* theWrappedObject)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QLayoutItem*)theWrappedObject)->promoted_spacerItem());
|
|
|
}
|
|
|
|
|
|
QWidget* PythonQtWrapper_QLayoutItem::widget(QLayoutItem* theWrappedObject)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QLayoutItem*)theWrappedObject)->promoted_widget());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QLineEdit::~PythonQtShell_QLineEdit() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::actionEvent(QActionEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QActionEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::actionEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::changeEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::changeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::closeEvent(QCloseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QCloseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::closeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::contextMenuEvent(QContextMenuEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QContextMenuEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::contextMenuEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::customEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QLineEdit::devType() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLineEdit::devType();
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::dragEnterEvent(QDragEnterEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragEnterEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::dragEnterEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::dragLeaveEvent(QDragLeaveEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::dragLeaveEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::dragMoveEvent(QDragMoveEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::dragMoveEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::dropEvent(QDropEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDropEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::dropEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::enterEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::enterEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QLineEdit::event(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLineEdit::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QLineEdit::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 char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLineEdit::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::focusInEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::focusInEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QLineEdit::focusNextPrevChild(bool next)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLineEdit::focusNextPrevChild(next);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::focusOutEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::focusOutEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QLineEdit::heightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLineEdit::heightForWidth(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::hideEvent(QHideEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QHideEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::hideEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::inputMethodEvent(QInputMethodEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QInputMethodEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::inputMethodEvent(arg__1);
|
|
|
}
|
|
|
QVariant PythonQtShell_QLineEdit::inputMethodQuery(Qt::InputMethodQuery arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QVariant returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QVariant*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLineEdit::inputMethodQuery(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::keyPressEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::keyPressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::keyReleaseEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::keyReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::languageChange()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "languageChange");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::languageChange();
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::leaveEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::leaveEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QLineEdit::metric(QPaintDevice::PaintDeviceMetric arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLineEdit::metric(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::mouseDoubleClickEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::mouseDoubleClickEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::mouseMoveEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::mouseMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::mousePressEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::mousePressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::mouseReleaseEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::mouseReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::moveEvent(QMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::moveEvent(arg__1);
|
|
|
}
|
|
|
QPaintEngine* PythonQtShell_QLineEdit::paintEngine() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPaintEngine*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPaintEngine* 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintEngine**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QLineEdit::paintEngine();
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::paintEvent(QPaintEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPaintEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::paintEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::resizeEvent(QResizeEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QResizeEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::resizeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::showEvent(QShowEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QShowEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::showEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::tabletEvent(QTabletEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTabletEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::tabletEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::timerEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QLineEdit::wheelEvent(QWheelEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWheelEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QLineEdit::wheelEvent(arg__1);
|
|
|
}
|
|
|
QLineEdit* PythonQtWrapper_QLineEdit::new_QLineEdit(QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QLineEdit(parent); }
|
|
|
|
|
|
QLineEdit* PythonQtWrapper_QLineEdit::new_QLineEdit(const QString& arg__1, QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QLineEdit(arg__1, parent); }
|
|
|
|
|
|
Qt::Alignment PythonQtWrapper_QLineEdit::alignment(QLineEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->alignment());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::backspace(QLineEdit* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->backspace());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::changeEvent(QLineEdit* theWrappedObject, QEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QLineEdit*)theWrappedObject)->promoted_changeEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
QCompleter* PythonQtWrapper_QLineEdit::completer(QLineEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->completer());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::contextMenuEvent(QLineEdit* theWrappedObject, QContextMenuEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QLineEdit*)theWrappedObject)->promoted_contextMenuEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
QMenu* PythonQtWrapper_QLineEdit::createStandardContextMenu(QLineEdit* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->createStandardContextMenu());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::cursorBackward(QLineEdit* theWrappedObject, bool mark, int steps)
|
|
|
{
|
|
|
( theWrappedObject->cursorBackward(mark, steps));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::cursorForward(QLineEdit* theWrappedObject, bool mark, int steps)
|
|
|
{
|
|
|
( theWrappedObject->cursorForward(mark, steps));
|
|
|
}
|
|
|
|
|
|
Qt::CursorMoveStyle PythonQtWrapper_QLineEdit::cursorMoveStyle(QLineEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->cursorMoveStyle());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QLineEdit::cursorPosition(QLineEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->cursorPosition());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QLineEdit::cursorPositionAt(QLineEdit* theWrappedObject, const QPoint& pos)
|
|
|
{
|
|
|
return ( theWrappedObject->cursorPositionAt(pos));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::cursorWordBackward(QLineEdit* theWrappedObject, bool mark)
|
|
|
{
|
|
|
( theWrappedObject->cursorWordBackward(mark));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::cursorWordForward(QLineEdit* theWrappedObject, bool mark)
|
|
|
{
|
|
|
( theWrappedObject->cursorWordForward(mark));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::del(QLineEdit* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->del());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::deselect(QLineEdit* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->deselect());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QLineEdit::displayText(QLineEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->displayText());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QLineEdit::dragEnabled(QLineEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->dragEnabled());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::dragEnterEvent(QLineEdit* theWrappedObject, QDragEnterEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QLineEdit*)theWrappedObject)->promoted_dragEnterEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::dragLeaveEvent(QLineEdit* theWrappedObject, QDragLeaveEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QLineEdit*)theWrappedObject)->promoted_dragLeaveEvent(e));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::dragMoveEvent(QLineEdit* theWrappedObject, QDragMoveEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QLineEdit*)theWrappedObject)->promoted_dragMoveEvent(e));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::dropEvent(QLineEdit* theWrappedObject, QDropEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QLineEdit*)theWrappedObject)->promoted_dropEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
QLineEdit::EchoMode PythonQtWrapper_QLineEdit::echoMode(QLineEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->echoMode());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::end(QLineEdit* theWrappedObject, bool mark)
|
|
|
{
|
|
|
( theWrappedObject->end(mark));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QLineEdit::event(QLineEdit* theWrappedObject, QEvent* arg__1)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QLineEdit*)theWrappedObject)->promoted_event(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::focusInEvent(QLineEdit* theWrappedObject, QFocusEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QLineEdit*)theWrappedObject)->promoted_focusInEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::focusOutEvent(QLineEdit* theWrappedObject, QFocusEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QLineEdit*)theWrappedObject)->promoted_focusOutEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::getTextMargins(QLineEdit* theWrappedObject, int* left, int* top, int* right, int* bottom) const
|
|
|
{
|
|
|
( theWrappedObject->getTextMargins(left, top, right, bottom));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QLineEdit::hasAcceptableInput(QLineEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->hasAcceptableInput());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QLineEdit::hasFrame(QLineEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->hasFrame());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QLineEdit::hasSelectedText(QLineEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->hasSelectedText());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::home(QLineEdit* theWrappedObject, bool mark)
|
|
|
{
|
|
|
( theWrappedObject->home(mark));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QLineEdit::inputMask(QLineEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->inputMask());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::inputMethodEvent(QLineEdit* theWrappedObject, QInputMethodEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QLineEdit*)theWrappedObject)->promoted_inputMethodEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
QVariant PythonQtWrapper_QLineEdit::inputMethodQuery(QLineEdit* theWrappedObject, Qt::InputMethodQuery arg__1) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QLineEdit*)theWrappedObject)->promoted_inputMethodQuery(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::insert(QLineEdit* theWrappedObject, const QString& arg__1)
|
|
|
{
|
|
|
( theWrappedObject->insert(arg__1));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QLineEdit::isModified(QLineEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isModified());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QLineEdit::isReadOnly(QLineEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isReadOnly());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QLineEdit::isRedoAvailable(QLineEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isRedoAvailable());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QLineEdit::isUndoAvailable(QLineEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isUndoAvailable());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::keyPressEvent(QLineEdit* theWrappedObject, QKeyEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QLineEdit*)theWrappedObject)->promoted_keyPressEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QLineEdit::maxLength(QLineEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->maxLength());
|
|
|
}
|
|
|
|
|
|
QSize PythonQtWrapper_QLineEdit::minimumSizeHint(QLineEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->minimumSizeHint());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::mouseDoubleClickEvent(QLineEdit* theWrappedObject, QMouseEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QLineEdit*)theWrappedObject)->promoted_mouseDoubleClickEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::mouseMoveEvent(QLineEdit* theWrappedObject, QMouseEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QLineEdit*)theWrappedObject)->promoted_mouseMoveEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::mousePressEvent(QLineEdit* theWrappedObject, QMouseEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QLineEdit*)theWrappedObject)->promoted_mousePressEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::mouseReleaseEvent(QLineEdit* theWrappedObject, QMouseEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QLineEdit*)theWrappedObject)->promoted_mouseReleaseEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::paintEvent(QLineEdit* theWrappedObject, QPaintEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QLineEdit*)theWrappedObject)->promoted_paintEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QLineEdit::placeholderText(QLineEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->placeholderText());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QLineEdit::selectedText(QLineEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->selectedText());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QLineEdit::selectionStart(QLineEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->selectionStart());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::setAlignment(QLineEdit* theWrappedObject, Qt::Alignment flag)
|
|
|
{
|
|
|
( theWrappedObject->setAlignment(flag));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::setCompleter(QLineEdit* theWrappedObject, QCompleter* completer)
|
|
|
{
|
|
|
( theWrappedObject->setCompleter(completer));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::setCursorMoveStyle(QLineEdit* theWrappedObject, Qt::CursorMoveStyle style)
|
|
|
{
|
|
|
( theWrappedObject->setCursorMoveStyle(style));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::setCursorPosition(QLineEdit* theWrappedObject, int arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setCursorPosition(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::setDragEnabled(QLineEdit* theWrappedObject, bool b)
|
|
|
{
|
|
|
( theWrappedObject->setDragEnabled(b));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::setEchoMode(QLineEdit* theWrappedObject, QLineEdit::EchoMode arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setEchoMode(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::setFrame(QLineEdit* theWrappedObject, bool arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setFrame(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::setInputMask(QLineEdit* theWrappedObject, const QString& inputMask)
|
|
|
{
|
|
|
( theWrappedObject->setInputMask(inputMask));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::setMaxLength(QLineEdit* theWrappedObject, int arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setMaxLength(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::setModified(QLineEdit* theWrappedObject, bool arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setModified(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::setPlaceholderText(QLineEdit* theWrappedObject, const QString& arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setPlaceholderText(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::setReadOnly(QLineEdit* theWrappedObject, bool arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setReadOnly(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::setSelection(QLineEdit* theWrappedObject, int arg__1, int arg__2)
|
|
|
{
|
|
|
( theWrappedObject->setSelection(arg__1, arg__2));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::setTextMargins(QLineEdit* theWrappedObject, const QMargins& margins)
|
|
|
{
|
|
|
( theWrappedObject->setTextMargins(margins));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::setTextMargins(QLineEdit* theWrappedObject, int left, int top, int right, int bottom)
|
|
|
{
|
|
|
( theWrappedObject->setTextMargins(left, top, right, bottom));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLineEdit::setValidator(QLineEdit* theWrappedObject, const QValidator* arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setValidator(arg__1));
|
|
|
}
|
|
|
|
|
|
QSize PythonQtWrapper_QLineEdit::sizeHint(QLineEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->sizeHint());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QLineEdit::text(QLineEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->text());
|
|
|
}
|
|
|
|
|
|
QMargins PythonQtWrapper_QLineEdit::textMargins(QLineEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->textMargins());
|
|
|
}
|
|
|
|
|
|
const QValidator* PythonQtWrapper_QLineEdit::validator(QLineEdit* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->validator());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QLinearGradient* PythonQtWrapper_QLinearGradient::new_QLinearGradient()
|
|
|
{
|
|
|
return new QLinearGradient(); }
|
|
|
|
|
|
QLinearGradient* PythonQtWrapper_QLinearGradient::new_QLinearGradient(const QPointF& start, const QPointF& finalStop)
|
|
|
{
|
|
|
return new QLinearGradient(start, finalStop); }
|
|
|
|
|
|
QLinearGradient* PythonQtWrapper_QLinearGradient::new_QLinearGradient(qreal xStart, qreal yStart, qreal xFinalStop, qreal yFinalStop)
|
|
|
{
|
|
|
return new QLinearGradient(xStart, yStart, xFinalStop, yFinalStop); }
|
|
|
|
|
|
QPointF PythonQtWrapper_QLinearGradient::finalStop(QLinearGradient* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->finalStop());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLinearGradient::setFinalStop(QLinearGradient* theWrappedObject, const QPointF& stop)
|
|
|
{
|
|
|
( theWrappedObject->setFinalStop(stop));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLinearGradient::setFinalStop(QLinearGradient* theWrappedObject, qreal x, qreal y)
|
|
|
{
|
|
|
( theWrappedObject->setFinalStop(x, y));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLinearGradient::setStart(QLinearGradient* theWrappedObject, const QPointF& start)
|
|
|
{
|
|
|
( theWrappedObject->setStart(start));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QLinearGradient::setStart(QLinearGradient* theWrappedObject, qreal x, qreal y)
|
|
|
{
|
|
|
( theWrappedObject->setStart(x, y));
|
|
|
}
|
|
|
|
|
|
QPointF PythonQtWrapper_QLinearGradient::start(QLinearGradient* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->start());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QListView::~PythonQtShell_QListView() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QListView::actionEvent(QActionEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QActionEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::actionEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QListView::changeEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::changeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QListView::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QListView::closeEditor(QWidget* editor, QAbstractItemDelegate::EndEditHint hint)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEditor");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWidget*" , "QAbstractItemDelegate::EndEditHint"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&editor, (void*)&hint};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::closeEditor(editor, hint);
|
|
|
}
|
|
|
void PythonQtShell_QListView::closeEvent(QCloseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QCloseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::closeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QListView::commitData(QWidget* editor)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "commitData");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWidget*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&editor};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::commitData(editor);
|
|
|
}
|
|
|
void PythonQtShell_QListView::contextMenuEvent(QContextMenuEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QContextMenuEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::contextMenuEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QListView::currentChanged(const QModelIndex& current, const QModelIndex& previous)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "currentChanged");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QModelIndex&" , "const QModelIndex&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)¤t, (void*)&previous};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::currentChanged(current, previous);
|
|
|
}
|
|
|
void PythonQtShell_QListView::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::customEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QListView::dataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dataChanged");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QModelIndex&" , "const QModelIndex&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&topLeft, (void*)&bottomRight};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::dataChanged(topLeft, bottomRight);
|
|
|
}
|
|
|
int PythonQtShell_QListView::devType() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListView::devType();
|
|
|
}
|
|
|
void PythonQtShell_QListView::doItemsLayout()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "doItemsLayout");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::doItemsLayout();
|
|
|
}
|
|
|
void PythonQtShell_QListView::dragEnterEvent(QDragEnterEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragEnterEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::dragEnterEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QListView::dragLeaveEvent(QDragLeaveEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::dragLeaveEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QListView::dragMoveEvent(QDragMoveEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::dragMoveEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QListView::dropEvent(QDropEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDropEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::dropEvent(e);
|
|
|
}
|
|
|
bool PythonQtShell_QListView::edit(const QModelIndex& index, QAbstractItemView::EditTrigger trigger, QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "edit");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "const QModelIndex&" , "QAbstractItemView::EditTrigger" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[4] = {NULL, (void*)&index, (void*)&trigger, (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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("edit", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListView::edit(index, trigger, event);
|
|
|
}
|
|
|
void PythonQtShell_QListView::editorDestroyed(QObject* editor)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "editorDestroyed");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QObject*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&editor};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::editorDestroyed(editor);
|
|
|
}
|
|
|
void PythonQtShell_QListView::enterEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::enterEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QListView::event(QEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListView::event(e);
|
|
|
}
|
|
|
bool PythonQtShell_QListView::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 char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListView::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QListView::focusInEvent(QFocusEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::focusInEvent(event);
|
|
|
}
|
|
|
bool PythonQtShell_QListView::focusNextPrevChild(bool next)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListView::focusNextPrevChild(next);
|
|
|
}
|
|
|
void PythonQtShell_QListView::focusOutEvent(QFocusEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::focusOutEvent(event);
|
|
|
}
|
|
|
int PythonQtShell_QListView::heightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListView::heightForWidth(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QListView::hideEvent(QHideEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QHideEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::hideEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QListView::horizontalOffset() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "horizontalOffset");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("horizontalOffset", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListView::horizontalOffset();
|
|
|
}
|
|
|
void PythonQtShell_QListView::horizontalScrollbarAction(int action)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "horizontalScrollbarAction");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&action};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::horizontalScrollbarAction(action);
|
|
|
}
|
|
|
void PythonQtShell_QListView::horizontalScrollbarValueChanged(int value)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "horizontalScrollbarValueChanged");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&value};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::horizontalScrollbarValueChanged(value);
|
|
|
}
|
|
|
QModelIndex PythonQtShell_QListView::indexAt(const QPoint& p) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "indexAt");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QModelIndex" , "const QPoint&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QModelIndex returnValue;
|
|
|
void* args[2] = {NULL, (void*)&p};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("indexAt", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QModelIndex*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListView::indexAt(p);
|
|
|
}
|
|
|
void PythonQtShell_QListView::inputMethodEvent(QInputMethodEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QInputMethodEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::inputMethodEvent(event);
|
|
|
}
|
|
|
QVariant PythonQtShell_QListView::inputMethodQuery(Qt::InputMethodQuery query) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QVariant*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListView::inputMethodQuery(query);
|
|
|
}
|
|
|
bool PythonQtShell_QListView::isIndexHidden(const QModelIndex& index) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isIndexHidden");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "const QModelIndex&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&index};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("isIndexHidden", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListView::isIndexHidden(index);
|
|
|
}
|
|
|
void PythonQtShell_QListView::keyPressEvent(QKeyEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::keyPressEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QListView::keyReleaseEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::keyReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QListView::keyboardSearch(const QString& search)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyboardSearch");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QString&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&search};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::keyboardSearch(search);
|
|
|
}
|
|
|
void PythonQtShell_QListView::languageChange()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "languageChange");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::languageChange();
|
|
|
}
|
|
|
void PythonQtShell_QListView::leaveEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::leaveEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QListView::metric(QPaintDevice::PaintDeviceMetric arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListView::metric(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QListView::mouseDoubleClickEvent(QMouseEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::mouseDoubleClickEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QListView::mouseMoveEvent(QMouseEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::mouseMoveEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QListView::mousePressEvent(QMouseEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::mousePressEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QListView::mouseReleaseEvent(QMouseEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::mouseReleaseEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QListView::moveEvent(QMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::moveEvent(arg__1);
|
|
|
}
|
|
|
QPaintEngine* PythonQtShell_QListView::paintEngine() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPaintEngine*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPaintEngine* 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintEngine**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListView::paintEngine();
|
|
|
}
|
|
|
void PythonQtShell_QListView::paintEvent(QPaintEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPaintEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::paintEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QListView::reset()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reset");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::reset();
|
|
|
}
|
|
|
void PythonQtShell_QListView::resizeEvent(QResizeEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QResizeEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::resizeEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QListView::rowsAboutToBeRemoved(const QModelIndex& parent, int start, int end)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "rowsAboutToBeRemoved");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QModelIndex&" , "int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
void* args[4] = {NULL, (void*)&parent, (void*)&start, (void*)&end};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::rowsAboutToBeRemoved(parent, start, end);
|
|
|
}
|
|
|
void PythonQtShell_QListView::rowsInserted(const QModelIndex& parent, int start, int end)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "rowsInserted");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QModelIndex&" , "int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
void* args[4] = {NULL, (void*)&parent, (void*)&start, (void*)&end};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::rowsInserted(parent, start, end);
|
|
|
}
|
|
|
void PythonQtShell_QListView::scrollContentsBy(int dx, int dy)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "scrollContentsBy");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&dx, (void*)&dy};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::scrollContentsBy(dx, dy);
|
|
|
}
|
|
|
void PythonQtShell_QListView::scrollTo(const QModelIndex& index, QAbstractItemView::ScrollHint hint)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "scrollTo");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QModelIndex&" , "QAbstractItemView::ScrollHint"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&index, (void*)&hint};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::scrollTo(index, hint);
|
|
|
}
|
|
|
void PythonQtShell_QListView::selectAll()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "selectAll");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::selectAll();
|
|
|
}
|
|
|
QList<QModelIndex > PythonQtShell_QListView::selectedIndexes() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "selectedIndexes");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QList<QModelIndex >"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QList<QModelIndex > 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("selectedIndexes", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QList<QModelIndex >*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListView::selectedIndexes();
|
|
|
}
|
|
|
void PythonQtShell_QListView::selectionChanged(const QItemSelection& selected, const QItemSelection& deselected)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "selectionChanged");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QItemSelection&" , "const QItemSelection&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&selected, (void*)&deselected};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::selectionChanged(selected, deselected);
|
|
|
}
|
|
|
QItemSelectionModel::SelectionFlags PythonQtShell_QListView::selectionCommand(const QModelIndex& index, const QEvent* event) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "selectionCommand");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QItemSelectionModel::SelectionFlags" , "const QModelIndex&" , "const QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
QItemSelectionModel::SelectionFlags returnValue;
|
|
|
void* args[3] = {NULL, (void*)&index, (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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("selectionCommand", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QItemSelectionModel::SelectionFlags*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListView::selectionCommand(index, event);
|
|
|
}
|
|
|
void PythonQtShell_QListView::setModel(QAbstractItemModel* model)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setModel");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QAbstractItemModel*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&model};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::setModel(model);
|
|
|
}
|
|
|
void PythonQtShell_QListView::setRootIndex(const QModelIndex& index)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setRootIndex");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QModelIndex&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&index};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::setRootIndex(index);
|
|
|
}
|
|
|
void PythonQtShell_QListView::setSelection(const QRect& rect, QItemSelectionModel::SelectionFlags command)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setSelection");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QRect&" , "QItemSelectionModel::SelectionFlags"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&rect, (void*)&command};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::setSelection(rect, command);
|
|
|
}
|
|
|
void PythonQtShell_QListView::setSelectionModel(QItemSelectionModel* selectionModel)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setSelectionModel");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QItemSelectionModel*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&selectionModel};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::setSelectionModel(selectionModel);
|
|
|
}
|
|
|
void PythonQtShell_QListView::showEvent(QShowEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QShowEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::showEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QListView::sizeHintForColumn(int column) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sizeHintForColumn");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&column};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("sizeHintForColumn", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListView::sizeHintForColumn(column);
|
|
|
}
|
|
|
int PythonQtShell_QListView::sizeHintForRow(int row) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sizeHintForRow");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&row};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("sizeHintForRow", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListView::sizeHintForRow(row);
|
|
|
}
|
|
|
void PythonQtShell_QListView::startDrag(Qt::DropActions supportedActions)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "startDrag");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "Qt::DropActions"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&supportedActions};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::startDrag(supportedActions);
|
|
|
}
|
|
|
void PythonQtShell_QListView::tabletEvent(QTabletEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTabletEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::tabletEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QListView::timerEvent(QTimerEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::timerEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QListView::updateEditorData()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateEditorData");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::updateEditorData();
|
|
|
}
|
|
|
void PythonQtShell_QListView::updateEditorGeometries()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateEditorGeometries");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::updateEditorGeometries();
|
|
|
}
|
|
|
void PythonQtShell_QListView::updateGeometries()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateGeometries");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::updateGeometries();
|
|
|
}
|
|
|
int PythonQtShell_QListView::verticalOffset() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "verticalOffset");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("verticalOffset", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListView::verticalOffset();
|
|
|
}
|
|
|
void PythonQtShell_QListView::verticalScrollbarAction(int action)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "verticalScrollbarAction");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&action};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::verticalScrollbarAction(action);
|
|
|
}
|
|
|
void PythonQtShell_QListView::verticalScrollbarValueChanged(int value)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "verticalScrollbarValueChanged");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&value};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::verticalScrollbarValueChanged(value);
|
|
|
}
|
|
|
QStyleOptionViewItem PythonQtShell_QListView::viewOptions() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewOptions");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QStyleOptionViewItem"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QStyleOptionViewItem 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("viewOptions", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QStyleOptionViewItem*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListView::viewOptions();
|
|
|
}
|
|
|
bool PythonQtShell_QListView::viewportEvent(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("viewportEvent", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListView::viewportEvent(event);
|
|
|
}
|
|
|
QRect PythonQtShell_QListView::visualRect(const QModelIndex& index) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "visualRect");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QRect" , "const QModelIndex&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QRect returnValue;
|
|
|
void* args[2] = {NULL, (void*)&index};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("visualRect", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QRect*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListView::visualRect(index);
|
|
|
}
|
|
|
QRegion PythonQtShell_QListView::visualRegionForSelection(const QItemSelection& selection) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "visualRegionForSelection");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QRegion" , "const QItemSelection&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QRegion returnValue;
|
|
|
void* args[2] = {NULL, (void*)&selection};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("visualRegionForSelection", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QRegion*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListView::visualRegionForSelection(selection);
|
|
|
}
|
|
|
void PythonQtShell_QListView::wheelEvent(QWheelEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWheelEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListView::wheelEvent(arg__1);
|
|
|
}
|
|
|
QListView* PythonQtWrapper_QListView::new_QListView(QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QListView(parent); }
|
|
|
|
|
|
int PythonQtWrapper_QListView::batchSize(QListView* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->batchSize());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::clearPropertyFlags(QListView* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->clearPropertyFlags());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::currentChanged(QListView* theWrappedObject, const QModelIndex& current, const QModelIndex& previous)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_currentChanged(current, previous));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::dataChanged(QListView* theWrappedObject, const QModelIndex& topLeft, const QModelIndex& bottomRight)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_dataChanged(topLeft, bottomRight));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::doItemsLayout(QListView* theWrappedObject)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_doItemsLayout());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::dragLeaveEvent(QListView* theWrappedObject, QDragLeaveEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_dragLeaveEvent(e));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::dragMoveEvent(QListView* theWrappedObject, QDragMoveEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_dragMoveEvent(e));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::dropEvent(QListView* theWrappedObject, QDropEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_dropEvent(e));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QListView::event(QListView* theWrappedObject, QEvent* e)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_event(e));
|
|
|
}
|
|
|
|
|
|
QListView::Flow PythonQtWrapper_QListView::flow(QListView* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->flow());
|
|
|
}
|
|
|
|
|
|
QSize PythonQtWrapper_QListView::gridSize(QListView* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->gridSize());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QListView::horizontalOffset(QListView* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_horizontalOffset());
|
|
|
}
|
|
|
|
|
|
QModelIndex PythonQtWrapper_QListView::indexAt(QListView* theWrappedObject, const QPoint& p) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_indexAt(p));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QListView::isIndexHidden(QListView* theWrappedObject, const QModelIndex& index) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_isIndexHidden(index));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QListView::isRowHidden(QListView* theWrappedObject, int row) const
|
|
|
{
|
|
|
return ( theWrappedObject->isRowHidden(row));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QListView::isSelectionRectVisible(QListView* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isSelectionRectVisible());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QListView::isWrapping(QListView* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isWrapping());
|
|
|
}
|
|
|
|
|
|
QListView::LayoutMode PythonQtWrapper_QListView::layoutMode(QListView* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->layoutMode());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QListView::modelColumn(QListView* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->modelColumn());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::mouseMoveEvent(QListView* theWrappedObject, QMouseEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_mouseMoveEvent(e));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::mouseReleaseEvent(QListView* theWrappedObject, QMouseEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_mouseReleaseEvent(e));
|
|
|
}
|
|
|
|
|
|
QListView::Movement PythonQtWrapper_QListView::movement(QListView* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->movement());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::paintEvent(QListView* theWrappedObject, QPaintEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_paintEvent(e));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::reset(QListView* theWrappedObject)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_reset());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::resizeEvent(QListView* theWrappedObject, QResizeEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_resizeEvent(e));
|
|
|
}
|
|
|
|
|
|
QListView::ResizeMode PythonQtWrapper_QListView::resizeMode(QListView* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->resizeMode());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::rowsAboutToBeRemoved(QListView* theWrappedObject, const QModelIndex& parent, int start, int end)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_rowsAboutToBeRemoved(parent, start, end));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::rowsInserted(QListView* theWrappedObject, const QModelIndex& parent, int start, int end)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_rowsInserted(parent, start, end));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::scrollContentsBy(QListView* theWrappedObject, int dx, int dy)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_scrollContentsBy(dx, dy));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::scrollTo(QListView* theWrappedObject, const QModelIndex& index, QAbstractItemView::ScrollHint hint)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_scrollTo(index, hint));
|
|
|
}
|
|
|
|
|
|
QList<QModelIndex > PythonQtWrapper_QListView::selectedIndexes(QListView* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_selectedIndexes());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::selectionChanged(QListView* theWrappedObject, const QItemSelection& selected, const QItemSelection& deselected)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_selectionChanged(selected, deselected));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::setBatchSize(QListView* theWrappedObject, int batchSize)
|
|
|
{
|
|
|
( theWrappedObject->setBatchSize(batchSize));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::setFlow(QListView* theWrappedObject, QListView::Flow flow)
|
|
|
{
|
|
|
( theWrappedObject->setFlow(flow));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::setGridSize(QListView* theWrappedObject, const QSize& size)
|
|
|
{
|
|
|
( theWrappedObject->setGridSize(size));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::setLayoutMode(QListView* theWrappedObject, QListView::LayoutMode mode)
|
|
|
{
|
|
|
( theWrappedObject->setLayoutMode(mode));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::setModelColumn(QListView* theWrappedObject, int column)
|
|
|
{
|
|
|
( theWrappedObject->setModelColumn(column));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::setMovement(QListView* theWrappedObject, QListView::Movement movement)
|
|
|
{
|
|
|
( theWrappedObject->setMovement(movement));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::setResizeMode(QListView* theWrappedObject, QListView::ResizeMode mode)
|
|
|
{
|
|
|
( theWrappedObject->setResizeMode(mode));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::setRootIndex(QListView* theWrappedObject, const QModelIndex& index)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_setRootIndex(index));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::setRowHidden(QListView* theWrappedObject, int row, bool hide)
|
|
|
{
|
|
|
( theWrappedObject->setRowHidden(row, hide));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::setSelection(QListView* theWrappedObject, const QRect& rect, QItemSelectionModel::SelectionFlags command)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_setSelection(rect, command));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::setSelectionRectVisible(QListView* theWrappedObject, bool show)
|
|
|
{
|
|
|
( theWrappedObject->setSelectionRectVisible(show));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::setSpacing(QListView* theWrappedObject, int space)
|
|
|
{
|
|
|
( theWrappedObject->setSpacing(space));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::setUniformItemSizes(QListView* theWrappedObject, bool enable)
|
|
|
{
|
|
|
( theWrappedObject->setUniformItemSizes(enable));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::setViewMode(QListView* theWrappedObject, QListView::ViewMode mode)
|
|
|
{
|
|
|
( theWrappedObject->setViewMode(mode));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::setWordWrap(QListView* theWrappedObject, bool on)
|
|
|
{
|
|
|
( theWrappedObject->setWordWrap(on));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::setWrapping(QListView* theWrappedObject, bool enable)
|
|
|
{
|
|
|
( theWrappedObject->setWrapping(enable));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QListView::spacing(QListView* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->spacing());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::startDrag(QListView* theWrappedObject, Qt::DropActions supportedActions)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_startDrag(supportedActions));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::timerEvent(QListView* theWrappedObject, QTimerEvent* e)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_timerEvent(e));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QListView::uniformItemSizes(QListView* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->uniformItemSizes());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListView::updateGeometries(QListView* theWrappedObject)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_updateGeometries());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QListView::verticalOffset(QListView* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_verticalOffset());
|
|
|
}
|
|
|
|
|
|
QListView::ViewMode PythonQtWrapper_QListView::viewMode(QListView* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->viewMode());
|
|
|
}
|
|
|
|
|
|
QStyleOptionViewItem PythonQtWrapper_QListView::viewOptions(QListView* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_viewOptions());
|
|
|
}
|
|
|
|
|
|
QRect PythonQtWrapper_QListView::visualRect(QListView* theWrappedObject, const QModelIndex& index) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_visualRect(index));
|
|
|
}
|
|
|
|
|
|
QRegion PythonQtWrapper_QListView::visualRegionForSelection(QListView* theWrappedObject, const QItemSelection& selection) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QListView*)theWrappedObject)->promoted_visualRegionForSelection(selection));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QListView::wordWrap(QListView* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->wordWrap());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QListWidget::~PythonQtShell_QListWidget() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::actionEvent(QActionEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QActionEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::actionEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::changeEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::changeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::closeEditor(QWidget* editor, QAbstractItemDelegate::EndEditHint hint)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEditor");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWidget*" , "QAbstractItemDelegate::EndEditHint"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&editor, (void*)&hint};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::closeEditor(editor, hint);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::closeEvent(QCloseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QCloseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::closeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::commitData(QWidget* editor)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "commitData");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWidget*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&editor};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::commitData(editor);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::contextMenuEvent(QContextMenuEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QContextMenuEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::contextMenuEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::currentChanged(const QModelIndex& current, const QModelIndex& previous)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "currentChanged");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QModelIndex&" , "const QModelIndex&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)¤t, (void*)&previous};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::currentChanged(current, previous);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::customEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::dataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dataChanged");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QModelIndex&" , "const QModelIndex&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&topLeft, (void*)&bottomRight};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::dataChanged(topLeft, bottomRight);
|
|
|
}
|
|
|
int PythonQtShell_QListWidget::devType() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidget::devType();
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::doItemsLayout()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "doItemsLayout");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::doItemsLayout();
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::dragEnterEvent(QDragEnterEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragEnterEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::dragEnterEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::dragLeaveEvent(QDragLeaveEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::dragLeaveEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::dragMoveEvent(QDragMoveEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::dragMoveEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::dropEvent(QDropEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDropEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::dropEvent(event);
|
|
|
}
|
|
|
bool PythonQtShell_QListWidget::dropMimeData(int index, const QMimeData* data, Qt::DropAction action)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropMimeData");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "int" , "const QMimeData*" , "Qt::DropAction"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[4] = {NULL, (void*)&index, (void*)&data, (void*)&action};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("dropMimeData", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidget::dropMimeData(index, data, action);
|
|
|
}
|
|
|
bool PythonQtShell_QListWidget::edit(const QModelIndex& index, QAbstractItemView::EditTrigger trigger, QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "edit");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "const QModelIndex&" , "QAbstractItemView::EditTrigger" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[4] = {NULL, (void*)&index, (void*)&trigger, (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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("edit", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidget::edit(index, trigger, event);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::editorDestroyed(QObject* editor)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "editorDestroyed");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QObject*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&editor};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::editorDestroyed(editor);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::enterEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::enterEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QListWidget::event(QEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidget::event(e);
|
|
|
}
|
|
|
bool PythonQtShell_QListWidget::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 char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidget::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::focusInEvent(QFocusEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::focusInEvent(event);
|
|
|
}
|
|
|
bool PythonQtShell_QListWidget::focusNextPrevChild(bool next)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidget::focusNextPrevChild(next);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::focusOutEvent(QFocusEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::focusOutEvent(event);
|
|
|
}
|
|
|
int PythonQtShell_QListWidget::heightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidget::heightForWidth(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::hideEvent(QHideEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QHideEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::hideEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QListWidget::horizontalOffset() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "horizontalOffset");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("horizontalOffset", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidget::horizontalOffset();
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::horizontalScrollbarAction(int action)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "horizontalScrollbarAction");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&action};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::horizontalScrollbarAction(action);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::horizontalScrollbarValueChanged(int value)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "horizontalScrollbarValueChanged");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&value};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::horizontalScrollbarValueChanged(value);
|
|
|
}
|
|
|
QModelIndex PythonQtShell_QListWidget::indexAt(const QPoint& p) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "indexAt");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QModelIndex" , "const QPoint&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QModelIndex returnValue;
|
|
|
void* args[2] = {NULL, (void*)&p};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("indexAt", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QModelIndex*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidget::indexAt(p);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::inputMethodEvent(QInputMethodEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QInputMethodEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::inputMethodEvent(event);
|
|
|
}
|
|
|
QVariant PythonQtShell_QListWidget::inputMethodQuery(Qt::InputMethodQuery query) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QVariant*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidget::inputMethodQuery(query);
|
|
|
}
|
|
|
bool PythonQtShell_QListWidget::isIndexHidden(const QModelIndex& index) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isIndexHidden");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "const QModelIndex&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&index};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("isIndexHidden", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidget::isIndexHidden(index);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::keyPressEvent(QKeyEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::keyPressEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::keyReleaseEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::keyReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::keyboardSearch(const QString& search)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyboardSearch");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QString&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&search};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::keyboardSearch(search);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::languageChange()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "languageChange");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::languageChange();
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::leaveEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::leaveEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QListWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidget::metric(arg__1);
|
|
|
}
|
|
|
QMimeData* PythonQtShell_QListWidget::mimeData(const QList<QListWidgetItem* > items) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mimeData");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QMimeData*" , "const QList<QListWidgetItem* >"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QMimeData* returnValue;
|
|
|
void* args[2] = {NULL, (void*)&items};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("mimeData", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QMimeData**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidget::mimeData(items);
|
|
|
}
|
|
|
QStringList PythonQtShell_QListWidget::mimeTypes() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mimeTypes");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QStringList"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QStringList 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("mimeTypes", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QStringList*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidget::mimeTypes();
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::mouseDoubleClickEvent(QMouseEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::mouseDoubleClickEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::mouseMoveEvent(QMouseEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::mouseMoveEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::mousePressEvent(QMouseEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::mousePressEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::mouseReleaseEvent(QMouseEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::mouseReleaseEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::moveEvent(QMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::moveEvent(arg__1);
|
|
|
}
|
|
|
QPaintEngine* PythonQtShell_QListWidget::paintEngine() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPaintEngine*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPaintEngine* 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintEngine**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidget::paintEngine();
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::paintEvent(QPaintEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPaintEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::paintEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::reset()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reset");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::reset();
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::resizeEvent(QResizeEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QResizeEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::resizeEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::rowsAboutToBeRemoved(const QModelIndex& parent, int start, int end)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "rowsAboutToBeRemoved");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QModelIndex&" , "int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
void* args[4] = {NULL, (void*)&parent, (void*)&start, (void*)&end};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::rowsAboutToBeRemoved(parent, start, end);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::rowsInserted(const QModelIndex& parent, int start, int end)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "rowsInserted");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QModelIndex&" , "int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
void* args[4] = {NULL, (void*)&parent, (void*)&start, (void*)&end};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::rowsInserted(parent, start, end);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::scrollContentsBy(int dx, int dy)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "scrollContentsBy");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&dx, (void*)&dy};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::scrollContentsBy(dx, dy);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::scrollTo(const QModelIndex& index, QAbstractItemView::ScrollHint hint)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "scrollTo");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QModelIndex&" , "QAbstractItemView::ScrollHint"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&index, (void*)&hint};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::scrollTo(index, hint);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::selectAll()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "selectAll");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::selectAll();
|
|
|
}
|
|
|
QList<QModelIndex > PythonQtShell_QListWidget::selectedIndexes() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "selectedIndexes");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QList<QModelIndex >"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QList<QModelIndex > 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("selectedIndexes", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QList<QModelIndex >*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidget::selectedIndexes();
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::selectionChanged(const QItemSelection& selected, const QItemSelection& deselected)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "selectionChanged");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QItemSelection&" , "const QItemSelection&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&selected, (void*)&deselected};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::selectionChanged(selected, deselected);
|
|
|
}
|
|
|
QItemSelectionModel::SelectionFlags PythonQtShell_QListWidget::selectionCommand(const QModelIndex& index, const QEvent* event) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "selectionCommand");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QItemSelectionModel::SelectionFlags" , "const QModelIndex&" , "const QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
QItemSelectionModel::SelectionFlags returnValue;
|
|
|
void* args[3] = {NULL, (void*)&index, (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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("selectionCommand", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QItemSelectionModel::SelectionFlags*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidget::selectionCommand(index, event);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::setRootIndex(const QModelIndex& index)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setRootIndex");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QModelIndex&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&index};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::setRootIndex(index);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::setSelection(const QRect& rect, QItemSelectionModel::SelectionFlags command)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setSelection");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QRect&" , "QItemSelectionModel::SelectionFlags"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&rect, (void*)&command};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::setSelection(rect, command);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::setSelectionModel(QItemSelectionModel* selectionModel)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setSelectionModel");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QItemSelectionModel*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&selectionModel};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::setSelectionModel(selectionModel);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::showEvent(QShowEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QShowEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::showEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QListWidget::sizeHintForColumn(int column) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sizeHintForColumn");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&column};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("sizeHintForColumn", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidget::sizeHintForColumn(column);
|
|
|
}
|
|
|
int PythonQtShell_QListWidget::sizeHintForRow(int row) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sizeHintForRow");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&row};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("sizeHintForRow", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidget::sizeHintForRow(row);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::startDrag(Qt::DropActions supportedActions)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "startDrag");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "Qt::DropActions"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&supportedActions};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::startDrag(supportedActions);
|
|
|
}
|
|
|
Qt::DropActions PythonQtShell_QListWidget::supportedDropActions() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "supportedDropActions");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"Qt::DropActions"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
Qt::DropActions 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("supportedDropActions", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((Qt::DropActions*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidget::supportedDropActions();
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::tabletEvent(QTabletEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTabletEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::tabletEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::timerEvent(QTimerEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&e};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::timerEvent(e);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::updateEditorData()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateEditorData");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::updateEditorData();
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::updateEditorGeometries()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateEditorGeometries");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::updateEditorGeometries();
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::updateGeometries()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateGeometries");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::updateGeometries();
|
|
|
}
|
|
|
int PythonQtShell_QListWidget::verticalOffset() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "verticalOffset");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("verticalOffset", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidget::verticalOffset();
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::verticalScrollbarAction(int action)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "verticalScrollbarAction");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&action};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::verticalScrollbarAction(action);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::verticalScrollbarValueChanged(int value)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "verticalScrollbarValueChanged");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&value};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::verticalScrollbarValueChanged(value);
|
|
|
}
|
|
|
QStyleOptionViewItem PythonQtShell_QListWidget::viewOptions() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewOptions");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QStyleOptionViewItem"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QStyleOptionViewItem 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("viewOptions", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QStyleOptionViewItem*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidget::viewOptions();
|
|
|
}
|
|
|
bool PythonQtShell_QListWidget::viewportEvent(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("viewportEvent", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidget::viewportEvent(event);
|
|
|
}
|
|
|
QRect PythonQtShell_QListWidget::visualRect(const QModelIndex& index) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "visualRect");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QRect" , "const QModelIndex&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QRect returnValue;
|
|
|
void* args[2] = {NULL, (void*)&index};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("visualRect", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QRect*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidget::visualRect(index);
|
|
|
}
|
|
|
QRegion PythonQtShell_QListWidget::visualRegionForSelection(const QItemSelection& selection) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "visualRegionForSelection");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QRegion" , "const QItemSelection&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QRegion returnValue;
|
|
|
void* args[2] = {NULL, (void*)&selection};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("visualRegionForSelection", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QRegion*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidget::visualRegionForSelection(selection);
|
|
|
}
|
|
|
void PythonQtShell_QListWidget::wheelEvent(QWheelEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWheelEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidget::wheelEvent(arg__1);
|
|
|
}
|
|
|
QListWidget* PythonQtWrapper_QListWidget::new_QListWidget(QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QListWidget(parent); }
|
|
|
|
|
|
void PythonQtWrapper_QListWidget::addItem(QListWidget* theWrappedObject, QListWidgetItem* item)
|
|
|
{
|
|
|
( theWrappedObject->addItem(item));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidget::addItem(QListWidget* theWrappedObject, const QString& label)
|
|
|
{
|
|
|
( theWrappedObject->addItem(label));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidget::addItems(QListWidget* theWrappedObject, const QStringList& labels)
|
|
|
{
|
|
|
( theWrappedObject->addItems(labels));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidget::closePersistentEditor(QListWidget* theWrappedObject, QListWidgetItem* item)
|
|
|
{
|
|
|
( theWrappedObject->closePersistentEditor(item));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QListWidget::count(QListWidget* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->count());
|
|
|
}
|
|
|
|
|
|
QListWidgetItem* PythonQtWrapper_QListWidget::currentItem(QListWidget* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->currentItem());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QListWidget::currentRow(QListWidget* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->currentRow());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidget::dropEvent(QListWidget* theWrappedObject, QDropEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QListWidget*)theWrappedObject)->promoted_dropEvent(event));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QListWidget::dropMimeData(QListWidget* theWrappedObject, int index, const QMimeData* data, Qt::DropAction action)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QListWidget*)theWrappedObject)->promoted_dropMimeData(index, data, action));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidget::editItem(QListWidget* theWrappedObject, QListWidgetItem* item)
|
|
|
{
|
|
|
( theWrappedObject->editItem(item));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QListWidget::event(QListWidget* theWrappedObject, QEvent* e)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QListWidget*)theWrappedObject)->promoted_event(e));
|
|
|
}
|
|
|
|
|
|
QList<QListWidgetItem* > PythonQtWrapper_QListWidget::findItems(QListWidget* theWrappedObject, const QString& text, Qt::MatchFlags flags) const
|
|
|
{
|
|
|
return ( theWrappedObject->findItems(text, flags));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidget::insertItem(QListWidget* theWrappedObject, int row, QListWidgetItem* item)
|
|
|
{
|
|
|
( theWrappedObject->insertItem(row, item));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidget::insertItem(QListWidget* theWrappedObject, int row, const QString& label)
|
|
|
{
|
|
|
( theWrappedObject->insertItem(row, label));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidget::insertItems(QListWidget* theWrappedObject, int row, const QStringList& labels)
|
|
|
{
|
|
|
( theWrappedObject->insertItems(row, labels));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QListWidget::isSortingEnabled(QListWidget* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isSortingEnabled());
|
|
|
}
|
|
|
|
|
|
QListWidgetItem* PythonQtWrapper_QListWidget::item(QListWidget* theWrappedObject, int row) const
|
|
|
{
|
|
|
return ( theWrappedObject->item(row));
|
|
|
}
|
|
|
|
|
|
QListWidgetItem* PythonQtWrapper_QListWidget::itemAt(QListWidget* theWrappedObject, const QPoint& p) const
|
|
|
{
|
|
|
return ( theWrappedObject->itemAt(p));
|
|
|
}
|
|
|
|
|
|
QListWidgetItem* PythonQtWrapper_QListWidget::itemAt(QListWidget* theWrappedObject, int x, int y) const
|
|
|
{
|
|
|
return ( theWrappedObject->itemAt(x, y));
|
|
|
}
|
|
|
|
|
|
QWidget* PythonQtWrapper_QListWidget::itemWidget(QListWidget* theWrappedObject, QListWidgetItem* item) const
|
|
|
{
|
|
|
return ( theWrappedObject->itemWidget(item));
|
|
|
}
|
|
|
|
|
|
QStringList PythonQtWrapper_QListWidget::mimeTypes(QListWidget* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QListWidget*)theWrappedObject)->promoted_mimeTypes());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidget::openPersistentEditor(QListWidget* theWrappedObject, QListWidgetItem* item)
|
|
|
{
|
|
|
( theWrappedObject->openPersistentEditor(item));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidget::removeItemWidget(QListWidget* theWrappedObject, QListWidgetItem* item)
|
|
|
{
|
|
|
( theWrappedObject->removeItemWidget(item));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QListWidget::row(QListWidget* theWrappedObject, const QListWidgetItem* item) const
|
|
|
{
|
|
|
return ( theWrappedObject->row(item));
|
|
|
}
|
|
|
|
|
|
QList<QListWidgetItem* > PythonQtWrapper_QListWidget::selectedItems(QListWidget* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->selectedItems());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidget::setCurrentItem(QListWidget* theWrappedObject, QListWidgetItem* item)
|
|
|
{
|
|
|
( theWrappedObject->setCurrentItem(item));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidget::setCurrentItem(QListWidget* theWrappedObject, QListWidgetItem* item, QItemSelectionModel::SelectionFlags command)
|
|
|
{
|
|
|
( theWrappedObject->setCurrentItem(item, command));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidget::setCurrentRow(QListWidget* theWrappedObject, int row)
|
|
|
{
|
|
|
( theWrappedObject->setCurrentRow(row));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidget::setCurrentRow(QListWidget* theWrappedObject, int row, QItemSelectionModel::SelectionFlags command)
|
|
|
{
|
|
|
( theWrappedObject->setCurrentRow(row, command));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidget::setItemWidget(QListWidget* theWrappedObject, QListWidgetItem* item, QWidget* widget)
|
|
|
{
|
|
|
( theWrappedObject->setItemWidget(item, widget));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidget::setSortingEnabled(QListWidget* theWrappedObject, bool enable)
|
|
|
{
|
|
|
( theWrappedObject->setSortingEnabled(enable));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidget::sortItems(QListWidget* theWrappedObject, Qt::SortOrder order)
|
|
|
{
|
|
|
( theWrappedObject->sortItems(order));
|
|
|
}
|
|
|
|
|
|
Qt::DropActions PythonQtWrapper_QListWidget::supportedDropActions(QListWidget* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QListWidget*)theWrappedObject)->promoted_supportedDropActions());
|
|
|
}
|
|
|
|
|
|
QListWidgetItem* PythonQtWrapper_QListWidget::takeItem(QListWidget* theWrappedObject, int row)
|
|
|
{
|
|
|
return ( theWrappedObject->takeItem(row));
|
|
|
}
|
|
|
|
|
|
QRect PythonQtWrapper_QListWidget::visualItemRect(QListWidget* theWrappedObject, const QListWidgetItem* item) const
|
|
|
{
|
|
|
return ( theWrappedObject->visualItemRect(item));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QListWidgetItem::~PythonQtShell_QListWidgetItem() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
QListWidgetItem* PythonQtShell_QListWidgetItem::clone() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "clone");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QListWidgetItem*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QListWidgetItem* 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("clone", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QListWidgetItem**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidgetItem::clone();
|
|
|
}
|
|
|
QVariant PythonQtShell_QListWidgetItem::data(int role) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "data");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QVariant" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QVariant returnValue;
|
|
|
void* args[2] = {NULL, (void*)&role};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("data", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QVariant*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidgetItem::data(role);
|
|
|
}
|
|
|
bool PythonQtShell_QListWidgetItem::__lt__(const QListWidgetItem& other) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "__lt__");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "const QListWidgetItem&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&other};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("__lt__", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QListWidgetItem::operator<(other);
|
|
|
}
|
|
|
void PythonQtShell_QListWidgetItem::read(QDataStream& in)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "read");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDataStream&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&in};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidgetItem::read(in);
|
|
|
}
|
|
|
void PythonQtShell_QListWidgetItem::setBackgroundColor(const QColor& color)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setBackgroundColor");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QColor&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&color};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidgetItem::setBackgroundColor(color);
|
|
|
}
|
|
|
void PythonQtShell_QListWidgetItem::setData(int role, const QVariant& value)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setData");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "int" , "const QVariant&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&role, (void*)&value};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidgetItem::setData(role, value);
|
|
|
}
|
|
|
void PythonQtShell_QListWidgetItem::write(QDataStream& out) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "write");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDataStream&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&out};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QListWidgetItem::write(out);
|
|
|
}
|
|
|
QListWidgetItem* PythonQtWrapper_QListWidgetItem::new_QListWidgetItem(QListWidget* view, int type)
|
|
|
{
|
|
|
return new PythonQtShell_QListWidgetItem(view, type); }
|
|
|
|
|
|
QListWidgetItem* PythonQtWrapper_QListWidgetItem::new_QListWidgetItem(const QIcon& icon, const QString& text, QListWidget* view, int type)
|
|
|
{
|
|
|
return new PythonQtShell_QListWidgetItem(icon, text, view, type); }
|
|
|
|
|
|
QListWidgetItem* PythonQtWrapper_QListWidgetItem::new_QListWidgetItem(const QString& text, QListWidget* view, int type)
|
|
|
{
|
|
|
return new PythonQtShell_QListWidgetItem(text, view, type); }
|
|
|
|
|
|
QBrush PythonQtWrapper_QListWidgetItem::background(QListWidgetItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->background());
|
|
|
}
|
|
|
|
|
|
Qt::CheckState PythonQtWrapper_QListWidgetItem::checkState(QListWidgetItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->checkState());
|
|
|
}
|
|
|
|
|
|
QListWidgetItem* PythonQtWrapper_QListWidgetItem::clone(QListWidgetItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QListWidgetItem*)theWrappedObject)->promoted_clone());
|
|
|
}
|
|
|
|
|
|
QVariant PythonQtWrapper_QListWidgetItem::data(QListWidgetItem* theWrappedObject, int role) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QListWidgetItem*)theWrappedObject)->promoted_data(role));
|
|
|
}
|
|
|
|
|
|
Qt::ItemFlags PythonQtWrapper_QListWidgetItem::flags(QListWidgetItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->flags());
|
|
|
}
|
|
|
|
|
|
QFont PythonQtWrapper_QListWidgetItem::font(QListWidgetItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->font());
|
|
|
}
|
|
|
|
|
|
QBrush PythonQtWrapper_QListWidgetItem::foreground(QListWidgetItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->foreground());
|
|
|
}
|
|
|
|
|
|
QIcon PythonQtWrapper_QListWidgetItem::icon(QListWidgetItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->icon());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QListWidgetItem::isHidden(QListWidgetItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isHidden());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QListWidgetItem::isSelected(QListWidgetItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isSelected());
|
|
|
}
|
|
|
|
|
|
QListWidget* PythonQtWrapper_QListWidgetItem::listWidget(QListWidgetItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->listWidget());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidgetItem::writeTo(QListWidgetItem* theWrappedObject, QDataStream& out)
|
|
|
{
|
|
|
out << (*theWrappedObject);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidgetItem::readFrom(QListWidgetItem* theWrappedObject, QDataStream& in)
|
|
|
{
|
|
|
in >> (*theWrappedObject);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidgetItem::setBackground(QListWidgetItem* theWrappedObject, const QBrush& brush)
|
|
|
{
|
|
|
( theWrappedObject->setBackground(brush));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidgetItem::setCheckState(QListWidgetItem* theWrappedObject, Qt::CheckState state)
|
|
|
{
|
|
|
( theWrappedObject->setCheckState(state));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidgetItem::setData(QListWidgetItem* theWrappedObject, int role, const QVariant& value)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QListWidgetItem*)theWrappedObject)->promoted_setData(role, value));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidgetItem::setFlags(QListWidgetItem* theWrappedObject, Qt::ItemFlags flags)
|
|
|
{
|
|
|
( theWrappedObject->setFlags(flags));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidgetItem::setFont(QListWidgetItem* theWrappedObject, const QFont& font)
|
|
|
{
|
|
|
( theWrappedObject->setFont(font));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidgetItem::setForeground(QListWidgetItem* theWrappedObject, const QBrush& brush)
|
|
|
{
|
|
|
( theWrappedObject->setForeground(brush));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidgetItem::setHidden(QListWidgetItem* theWrappedObject, bool hide)
|
|
|
{
|
|
|
( theWrappedObject->setHidden(hide));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidgetItem::setIcon(QListWidgetItem* theWrappedObject, const QIcon& icon)
|
|
|
{
|
|
|
( theWrappedObject->setIcon(icon));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidgetItem::setSelected(QListWidgetItem* theWrappedObject, bool select)
|
|
|
{
|
|
|
( theWrappedObject->setSelected(select));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidgetItem::setSizeHint(QListWidgetItem* theWrappedObject, const QSize& size)
|
|
|
{
|
|
|
( theWrappedObject->setSizeHint(size));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidgetItem::setStatusTip(QListWidgetItem* theWrappedObject, const QString& statusTip)
|
|
|
{
|
|
|
( theWrappedObject->setStatusTip(statusTip));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidgetItem::setText(QListWidgetItem* theWrappedObject, const QString& text)
|
|
|
{
|
|
|
( theWrappedObject->setText(text));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidgetItem::setTextAlignment(QListWidgetItem* theWrappedObject, int alignment)
|
|
|
{
|
|
|
( theWrappedObject->setTextAlignment(alignment));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidgetItem::setToolTip(QListWidgetItem* theWrappedObject, const QString& toolTip)
|
|
|
{
|
|
|
( theWrappedObject->setToolTip(toolTip));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QListWidgetItem::setWhatsThis(QListWidgetItem* theWrappedObject, const QString& whatsThis)
|
|
|
{
|
|
|
( theWrappedObject->setWhatsThis(whatsThis));
|
|
|
}
|
|
|
|
|
|
QSize PythonQtWrapper_QListWidgetItem::sizeHint(QListWidgetItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->sizeHint());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QListWidgetItem::statusTip(QListWidgetItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->statusTip());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QListWidgetItem::text(QListWidgetItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->text());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QListWidgetItem::textAlignment(QListWidgetItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->textAlignment());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QListWidgetItem::toolTip(QListWidgetItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->toolTip());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QListWidgetItem::type(QListWidgetItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->type());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QListWidgetItem::whatsThis(QListWidgetItem* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->whatsThis());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QMainWindow::~PythonQtShell_QMainWindow() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::actionEvent(QActionEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QActionEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::actionEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::changeEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::changeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::closeEvent(QCloseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QCloseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::closeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::contextMenuEvent(QContextMenuEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QContextMenuEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::contextMenuEvent(event);
|
|
|
}
|
|
|
QMenu* PythonQtShell_QMainWindow::createPopupMenu()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "createPopupMenu");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QMenu*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QMenu* 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("createPopupMenu", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QMenu**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMainWindow::createPopupMenu();
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::customEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QMainWindow::devType() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMainWindow::devType();
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::dragEnterEvent(QDragEnterEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragEnterEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::dragEnterEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::dragLeaveEvent(QDragLeaveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::dragLeaveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::dragMoveEvent(QDragMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::dragMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::dropEvent(QDropEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDropEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::dropEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::enterEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::enterEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QMainWindow::event(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMainWindow::event(event);
|
|
|
}
|
|
|
bool PythonQtShell_QMainWindow::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 char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMainWindow::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::focusInEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::focusInEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QMainWindow::focusNextPrevChild(bool next)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMainWindow::focusNextPrevChild(next);
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::focusOutEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::focusOutEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QMainWindow::heightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMainWindow::heightForWidth(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::hideEvent(QHideEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QHideEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::hideEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::inputMethodEvent(QInputMethodEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QInputMethodEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::inputMethodEvent(arg__1);
|
|
|
}
|
|
|
QVariant PythonQtShell_QMainWindow::inputMethodQuery(Qt::InputMethodQuery arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QVariant returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QVariant*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMainWindow::inputMethodQuery(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::keyPressEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::keyPressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::keyReleaseEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::keyReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::languageChange()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "languageChange");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::languageChange();
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::leaveEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::leaveEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QMainWindow::metric(QPaintDevice::PaintDeviceMetric arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMainWindow::metric(arg__1);
|
|
|
}
|
|
|
QSize PythonQtShell_QMainWindow::minimumSizeHint() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QSize"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QSize 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QSize*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMainWindow::minimumSizeHint();
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::mouseDoubleClickEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::mouseDoubleClickEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::mouseMoveEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::mouseMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::mousePressEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::mousePressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::mouseReleaseEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::mouseReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::moveEvent(QMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::moveEvent(arg__1);
|
|
|
}
|
|
|
QPaintEngine* PythonQtShell_QMainWindow::paintEngine() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPaintEngine*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPaintEngine* 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintEngine**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMainWindow::paintEngine();
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::paintEvent(QPaintEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPaintEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::paintEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::resizeEvent(QResizeEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QResizeEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::resizeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::showEvent(QShowEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QShowEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::showEvent(arg__1);
|
|
|
}
|
|
|
QSize PythonQtShell_QMainWindow::sizeHint() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QSize"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QSize 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QSize*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMainWindow::sizeHint();
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::tabletEvent(QTabletEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTabletEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::tabletEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::timerEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMainWindow::wheelEvent(QWheelEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWheelEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMainWindow::wheelEvent(arg__1);
|
|
|
}
|
|
|
QMainWindow* PythonQtWrapper_QMainWindow::new_QMainWindow(QWidget* parent, Qt::WindowFlags flags)
|
|
|
{
|
|
|
return new PythonQtShell_QMainWindow(parent, flags); }
|
|
|
|
|
|
void PythonQtWrapper_QMainWindow::addDockWidget(QMainWindow* theWrappedObject, Qt::DockWidgetArea area, QDockWidget* dockwidget)
|
|
|
{
|
|
|
( theWrappedObject->addDockWidget(area, dockwidget));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMainWindow::addDockWidget(QMainWindow* theWrappedObject, Qt::DockWidgetArea area, QDockWidget* dockwidget, Qt::Orientation orientation)
|
|
|
{
|
|
|
( theWrappedObject->addDockWidget(area, dockwidget, orientation));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMainWindow::addToolBar(QMainWindow* theWrappedObject, QToolBar* toolbar)
|
|
|
{
|
|
|
( theWrappedObject->addToolBar(toolbar));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMainWindow::addToolBar(QMainWindow* theWrappedObject, Qt::ToolBarArea area, QToolBar* toolbar)
|
|
|
{
|
|
|
( theWrappedObject->addToolBar(area, toolbar));
|
|
|
}
|
|
|
|
|
|
QToolBar* PythonQtWrapper_QMainWindow::addToolBar(QMainWindow* theWrappedObject, const QString& title)
|
|
|
{
|
|
|
return ( theWrappedObject->addToolBar(title));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMainWindow::addToolBarBreak(QMainWindow* theWrappedObject, Qt::ToolBarArea area)
|
|
|
{
|
|
|
( theWrappedObject->addToolBarBreak(area));
|
|
|
}
|
|
|
|
|
|
QWidget* PythonQtWrapper_QMainWindow::centralWidget(QMainWindow* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->centralWidget());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMainWindow::contextMenuEvent(QMainWindow* theWrappedObject, QContextMenuEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMainWindow*)theWrappedObject)->promoted_contextMenuEvent(event));
|
|
|
}
|
|
|
|
|
|
Qt::DockWidgetArea PythonQtWrapper_QMainWindow::corner(QMainWindow* theWrappedObject, Qt::Corner corner) const
|
|
|
{
|
|
|
return ( theWrappedObject->corner(corner));
|
|
|
}
|
|
|
|
|
|
QMenu* PythonQtWrapper_QMainWindow::createPopupMenu(QMainWindow* theWrappedObject)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QMainWindow*)theWrappedObject)->promoted_createPopupMenu());
|
|
|
}
|
|
|
|
|
|
QMainWindow::DockOptions PythonQtWrapper_QMainWindow::dockOptions(QMainWindow* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->dockOptions());
|
|
|
}
|
|
|
|
|
|
Qt::DockWidgetArea PythonQtWrapper_QMainWindow::dockWidgetArea(QMainWindow* theWrappedObject, QDockWidget* dockwidget) const
|
|
|
{
|
|
|
return ( theWrappedObject->dockWidgetArea(dockwidget));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMainWindow::documentMode(QMainWindow* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->documentMode());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMainWindow::event(QMainWindow* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QMainWindow*)theWrappedObject)->promoted_event(event));
|
|
|
}
|
|
|
|
|
|
QSize PythonQtWrapper_QMainWindow::iconSize(QMainWindow* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->iconSize());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMainWindow::insertToolBar(QMainWindow* theWrappedObject, QToolBar* before, QToolBar* toolbar)
|
|
|
{
|
|
|
( theWrappedObject->insertToolBar(before, toolbar));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMainWindow::insertToolBarBreak(QMainWindow* theWrappedObject, QToolBar* before)
|
|
|
{
|
|
|
( theWrappedObject->insertToolBarBreak(before));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMainWindow::isAnimated(QMainWindow* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isAnimated());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMainWindow::isDockNestingEnabled(QMainWindow* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isDockNestingEnabled());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMainWindow::isSeparator(QMainWindow* theWrappedObject, const QPoint& pos) const
|
|
|
{
|
|
|
return ( theWrappedObject->isSeparator(pos));
|
|
|
}
|
|
|
|
|
|
QMenuBar* PythonQtWrapper_QMainWindow::menuBar(QMainWindow* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->menuBar());
|
|
|
}
|
|
|
|
|
|
QWidget* PythonQtWrapper_QMainWindow::menuWidget(QMainWindow* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->menuWidget());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMainWindow::removeDockWidget(QMainWindow* theWrappedObject, QDockWidget* dockwidget)
|
|
|
{
|
|
|
( theWrappedObject->removeDockWidget(dockwidget));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMainWindow::removeToolBar(QMainWindow* theWrappedObject, QToolBar* toolbar)
|
|
|
{
|
|
|
( theWrappedObject->removeToolBar(toolbar));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMainWindow::removeToolBarBreak(QMainWindow* theWrappedObject, QToolBar* before)
|
|
|
{
|
|
|
( theWrappedObject->removeToolBarBreak(before));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMainWindow::restoreDockWidget(QMainWindow* theWrappedObject, QDockWidget* dockwidget)
|
|
|
{
|
|
|
return ( theWrappedObject->restoreDockWidget(dockwidget));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMainWindow::restoreState(QMainWindow* theWrappedObject, const QByteArray& state, int version)
|
|
|
{
|
|
|
return ( theWrappedObject->restoreState(state, version));
|
|
|
}
|
|
|
|
|
|
QByteArray PythonQtWrapper_QMainWindow::saveState(QMainWindow* theWrappedObject, int version) const
|
|
|
{
|
|
|
return ( theWrappedObject->saveState(version));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMainWindow::setCentralWidget(QMainWindow* theWrappedObject, QWidget* widget)
|
|
|
{
|
|
|
( theWrappedObject->setCentralWidget(widget));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMainWindow::setCorner(QMainWindow* theWrappedObject, Qt::Corner corner, Qt::DockWidgetArea area)
|
|
|
{
|
|
|
( theWrappedObject->setCorner(corner, area));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMainWindow::setDockOptions(QMainWindow* theWrappedObject, QMainWindow::DockOptions options)
|
|
|
{
|
|
|
( theWrappedObject->setDockOptions(options));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMainWindow::setDocumentMode(QMainWindow* theWrappedObject, bool enabled)
|
|
|
{
|
|
|
( theWrappedObject->setDocumentMode(enabled));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMainWindow::setIconSize(QMainWindow* theWrappedObject, const QSize& iconSize)
|
|
|
{
|
|
|
( theWrappedObject->setIconSize(iconSize));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMainWindow::setMenuBar(QMainWindow* theWrappedObject, QMenuBar* menubar)
|
|
|
{
|
|
|
( theWrappedObject->setMenuBar(menubar));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMainWindow::setMenuWidget(QMainWindow* theWrappedObject, QWidget* menubar)
|
|
|
{
|
|
|
( theWrappedObject->setMenuWidget(menubar));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMainWindow::setStatusBar(QMainWindow* theWrappedObject, QStatusBar* statusbar)
|
|
|
{
|
|
|
( theWrappedObject->setStatusBar(statusbar));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMainWindow::setTabPosition(QMainWindow* theWrappedObject, Qt::DockWidgetAreas areas, QTabWidget::TabPosition tabPosition)
|
|
|
{
|
|
|
( theWrappedObject->setTabPosition(areas, tabPosition));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMainWindow::setTabShape(QMainWindow* theWrappedObject, QTabWidget::TabShape tabShape)
|
|
|
{
|
|
|
( theWrappedObject->setTabShape(tabShape));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMainWindow::setToolButtonStyle(QMainWindow* theWrappedObject, Qt::ToolButtonStyle toolButtonStyle)
|
|
|
{
|
|
|
( theWrappedObject->setToolButtonStyle(toolButtonStyle));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMainWindow::setUnifiedTitleAndToolBarOnMac(QMainWindow* theWrappedObject, bool set)
|
|
|
{
|
|
|
( theWrappedObject->setUnifiedTitleAndToolBarOnMac(set));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMainWindow::splitDockWidget(QMainWindow* theWrappedObject, QDockWidget* after, QDockWidget* dockwidget, Qt::Orientation orientation)
|
|
|
{
|
|
|
( theWrappedObject->splitDockWidget(after, dockwidget, orientation));
|
|
|
}
|
|
|
|
|
|
QStatusBar* PythonQtWrapper_QMainWindow::statusBar(QMainWindow* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->statusBar());
|
|
|
}
|
|
|
|
|
|
QTabWidget::TabPosition PythonQtWrapper_QMainWindow::tabPosition(QMainWindow* theWrappedObject, Qt::DockWidgetArea area) const
|
|
|
{
|
|
|
return ( theWrappedObject->tabPosition(area));
|
|
|
}
|
|
|
|
|
|
QTabWidget::TabShape PythonQtWrapper_QMainWindow::tabShape(QMainWindow* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->tabShape());
|
|
|
}
|
|
|
|
|
|
QList<QDockWidget* > PythonQtWrapper_QMainWindow::tabifiedDockWidgets(QMainWindow* theWrappedObject, QDockWidget* dockwidget) const
|
|
|
{
|
|
|
return ( theWrappedObject->tabifiedDockWidgets(dockwidget));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMainWindow::tabifyDockWidget(QMainWindow* theWrappedObject, QDockWidget* first, QDockWidget* second)
|
|
|
{
|
|
|
( theWrappedObject->tabifyDockWidget(first, second));
|
|
|
}
|
|
|
|
|
|
Qt::ToolBarArea PythonQtWrapper_QMainWindow::toolBarArea(QMainWindow* theWrappedObject, QToolBar* toolbar) const
|
|
|
{
|
|
|
return ( theWrappedObject->toolBarArea(toolbar));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMainWindow::toolBarBreak(QMainWindow* theWrappedObject, QToolBar* toolbar) const
|
|
|
{
|
|
|
return ( theWrappedObject->toolBarBreak(toolbar));
|
|
|
}
|
|
|
|
|
|
Qt::ToolButtonStyle PythonQtWrapper_QMainWindow::toolButtonStyle(QMainWindow* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->toolButtonStyle());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMainWindow::unifiedTitleAndToolBarOnMac(QMainWindow* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->unifiedTitleAndToolBarOnMac());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QMargins* PythonQtWrapper_QMargins::new_QMargins()
|
|
|
{
|
|
|
return new QMargins(); }
|
|
|
|
|
|
QMargins* PythonQtWrapper_QMargins::new_QMargins(int left, int top, int right, int bottom)
|
|
|
{
|
|
|
return new QMargins(left, top, right, bottom); }
|
|
|
|
|
|
int PythonQtWrapper_QMargins::bottom(QMargins* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->bottom());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMargins::isNull(QMargins* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isNull());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QMargins::left(QMargins* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->left());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMargins::__eq__(QMargins* theWrappedObject, const QMargins& m2)
|
|
|
{
|
|
|
return ( (*theWrappedObject)== m2);
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QMargins::right(QMargins* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->right());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMargins::setBottom(QMargins* theWrappedObject, int bottom)
|
|
|
{
|
|
|
( theWrappedObject->setBottom(bottom));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMargins::setLeft(QMargins* theWrappedObject, int left)
|
|
|
{
|
|
|
( theWrappedObject->setLeft(left));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMargins::setRight(QMargins* theWrappedObject, int right)
|
|
|
{
|
|
|
( theWrappedObject->setRight(right));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMargins::setTop(QMargins* theWrappedObject, int top)
|
|
|
{
|
|
|
( theWrappedObject->setTop(top));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QMargins::top(QMargins* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->top());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QMargins::py_toString(QMargins* obj) {
|
|
|
QString result;
|
|
|
QDebug d(&result);
|
|
|
d << *obj;
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QMatrix4x4* PythonQtWrapper_QMatrix4x4::new_QMatrix4x4()
|
|
|
{
|
|
|
return new QMatrix4x4(); }
|
|
|
|
|
|
QMatrix4x4* PythonQtWrapper_QMatrix4x4::new_QMatrix4x4(const QMatrix& matrix)
|
|
|
{
|
|
|
return new QMatrix4x4(matrix); }
|
|
|
|
|
|
QMatrix4x4* PythonQtWrapper_QMatrix4x4::new_QMatrix4x4(const QTransform& transform)
|
|
|
{
|
|
|
return new QMatrix4x4(transform); }
|
|
|
|
|
|
QMatrix4x4* PythonQtWrapper_QMatrix4x4::new_QMatrix4x4(const qreal* values)
|
|
|
{
|
|
|
return new QMatrix4x4(values); }
|
|
|
|
|
|
QMatrix4x4* PythonQtWrapper_QMatrix4x4::new_QMatrix4x4(const qreal* values, int cols, int rows)
|
|
|
{
|
|
|
return new QMatrix4x4(values, cols, rows); }
|
|
|
|
|
|
QMatrix4x4* PythonQtWrapper_QMatrix4x4::new_QMatrix4x4(qreal m11, qreal m12, qreal m13, qreal m14, qreal m21, qreal m22, qreal m23, qreal m24, qreal m31, qreal m32, qreal m33, qreal m34, qreal m41, qreal m42, qreal m43, qreal m44)
|
|
|
{
|
|
|
return new QMatrix4x4(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44); }
|
|
|
|
|
|
QVector4D PythonQtWrapper_QMatrix4x4::column(QMatrix4x4* theWrappedObject, int index) const
|
|
|
{
|
|
|
return ( theWrappedObject->column(index));
|
|
|
}
|
|
|
|
|
|
const qreal* PythonQtWrapper_QMatrix4x4::constData(QMatrix4x4* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->constData());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMatrix4x4::copyDataTo(QMatrix4x4* theWrappedObject, qreal* values) const
|
|
|
{
|
|
|
( theWrappedObject->copyDataTo(values));
|
|
|
}
|
|
|
|
|
|
qreal* PythonQtWrapper_QMatrix4x4::data(QMatrix4x4* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->data());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QMatrix4x4::determinant(QMatrix4x4* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->determinant());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMatrix4x4::fill(QMatrix4x4* theWrappedObject, qreal value)
|
|
|
{
|
|
|
( theWrappedObject->fill(value));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMatrix4x4::flipCoordinates(QMatrix4x4* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->flipCoordinates());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMatrix4x4::frustum(QMatrix4x4* theWrappedObject, qreal left, qreal right, qreal bottom, qreal top, qreal nearPlane, qreal farPlane)
|
|
|
{
|
|
|
( theWrappedObject->frustum(left, right, bottom, top, nearPlane, farPlane));
|
|
|
}
|
|
|
|
|
|
QMatrix4x4 PythonQtWrapper_QMatrix4x4::inverted(QMatrix4x4* theWrappedObject, bool* invertible) const
|
|
|
{
|
|
|
return ( theWrappedObject->inverted(invertible));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMatrix4x4::isIdentity(QMatrix4x4* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isIdentity());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMatrix4x4::lookAt(QMatrix4x4* theWrappedObject, const QVector3D& eye, const QVector3D& center, const QVector3D& up)
|
|
|
{
|
|
|
( theWrappedObject->lookAt(eye, center, up));
|
|
|
}
|
|
|
|
|
|
QPoint PythonQtWrapper_QMatrix4x4::map(QMatrix4x4* theWrappedObject, const QPoint& point) const
|
|
|
{
|
|
|
return ( theWrappedObject->map(point));
|
|
|
}
|
|
|
|
|
|
QPointF PythonQtWrapper_QMatrix4x4::map(QMatrix4x4* theWrappedObject, const QPointF& point) const
|
|
|
{
|
|
|
return ( theWrappedObject->map(point));
|
|
|
}
|
|
|
|
|
|
QVector3D PythonQtWrapper_QMatrix4x4::map(QMatrix4x4* theWrappedObject, const QVector3D& point) const
|
|
|
{
|
|
|
return ( theWrappedObject->map(point));
|
|
|
}
|
|
|
|
|
|
QVector4D PythonQtWrapper_QMatrix4x4::map(QMatrix4x4* theWrappedObject, const QVector4D& point) const
|
|
|
{
|
|
|
return ( theWrappedObject->map(point));
|
|
|
}
|
|
|
|
|
|
QRect PythonQtWrapper_QMatrix4x4::mapRect(QMatrix4x4* theWrappedObject, const QRect& rect) const
|
|
|
{
|
|
|
return ( theWrappedObject->mapRect(rect));
|
|
|
}
|
|
|
|
|
|
QRectF PythonQtWrapper_QMatrix4x4::mapRect(QMatrix4x4* theWrappedObject, const QRectF& rect) const
|
|
|
{
|
|
|
return ( theWrappedObject->mapRect(rect));
|
|
|
}
|
|
|
|
|
|
QVector3D PythonQtWrapper_QMatrix4x4::mapVector(QMatrix4x4* theWrappedObject, const QVector3D& vector) const
|
|
|
{
|
|
|
return ( theWrappedObject->mapVector(vector));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMatrix4x4::__ne__(QMatrix4x4* theWrappedObject, const QMatrix4x4& other) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)!= other);
|
|
|
}
|
|
|
|
|
|
qreal* PythonQtWrapper_QMatrix4x4::operator_cast_(QMatrix4x4* theWrappedObject, int row, int column)
|
|
|
{
|
|
|
return &( theWrappedObject->operator()(row, column));
|
|
|
}
|
|
|
|
|
|
QMatrix4x4 PythonQtWrapper_QMatrix4x4::__mul__(QMatrix4x4* theWrappedObject, const QMatrix4x4& m2)
|
|
|
{
|
|
|
return ( (*theWrappedObject)* m2);
|
|
|
}
|
|
|
|
|
|
QPoint PythonQtWrapper_QMatrix4x4::__mul__(QMatrix4x4* theWrappedObject, const QPoint& point)
|
|
|
{
|
|
|
return ( (*theWrappedObject)* point);
|
|
|
}
|
|
|
|
|
|
QPointF PythonQtWrapper_QMatrix4x4::__mul__(QMatrix4x4* theWrappedObject, const QPointF& point)
|
|
|
{
|
|
|
return ( (*theWrappedObject)* point);
|
|
|
}
|
|
|
|
|
|
QVector3D PythonQtWrapper_QMatrix4x4::__mul__(QMatrix4x4* theWrappedObject, const QVector3D& vector)
|
|
|
{
|
|
|
return ( (*theWrappedObject)* vector);
|
|
|
}
|
|
|
|
|
|
QVector4D PythonQtWrapper_QMatrix4x4::__mul__(QMatrix4x4* theWrappedObject, const QVector4D& vector)
|
|
|
{
|
|
|
return ( (*theWrappedObject)* vector);
|
|
|
}
|
|
|
|
|
|
QMatrix4x4 PythonQtWrapper_QMatrix4x4::__mul__(QMatrix4x4* theWrappedObject, qreal factor)
|
|
|
{
|
|
|
return ( (*theWrappedObject)* factor);
|
|
|
}
|
|
|
|
|
|
QMatrix4x4* PythonQtWrapper_QMatrix4x4::__imul__(QMatrix4x4* theWrappedObject, const QMatrix4x4& other)
|
|
|
{
|
|
|
return &( (*theWrappedObject)*= other);
|
|
|
}
|
|
|
|
|
|
QMatrix4x4* PythonQtWrapper_QMatrix4x4::__imul__(QMatrix4x4* theWrappedObject, qreal factor)
|
|
|
{
|
|
|
return &( (*theWrappedObject)*= factor);
|
|
|
}
|
|
|
|
|
|
QMatrix4x4 PythonQtWrapper_QMatrix4x4::__add__(QMatrix4x4* theWrappedObject, const QMatrix4x4& m2)
|
|
|
{
|
|
|
return ( (*theWrappedObject)+ m2);
|
|
|
}
|
|
|
|
|
|
QMatrix4x4* PythonQtWrapper_QMatrix4x4::__iadd__(QMatrix4x4* theWrappedObject, const QMatrix4x4& other)
|
|
|
{
|
|
|
return &( (*theWrappedObject)+= other);
|
|
|
}
|
|
|
|
|
|
QMatrix4x4 PythonQtWrapper_QMatrix4x4::__sub__(QMatrix4x4* theWrappedObject, const QMatrix4x4& m2)
|
|
|
{
|
|
|
return ( (*theWrappedObject)- m2);
|
|
|
}
|
|
|
|
|
|
QMatrix4x4* PythonQtWrapper_QMatrix4x4::__isub__(QMatrix4x4* theWrappedObject, const QMatrix4x4& other)
|
|
|
{
|
|
|
return &( (*theWrappedObject)-= other);
|
|
|
}
|
|
|
|
|
|
QMatrix4x4 PythonQtWrapper_QMatrix4x4::__div__(QMatrix4x4* theWrappedObject, qreal divisor)
|
|
|
{
|
|
|
return ( (*theWrappedObject)/ divisor);
|
|
|
}
|
|
|
|
|
|
QMatrix4x4* PythonQtWrapper_QMatrix4x4::__idiv__(QMatrix4x4* theWrappedObject, qreal divisor)
|
|
|
{
|
|
|
return &( (*theWrappedObject)/= divisor);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMatrix4x4::writeTo(QMatrix4x4* theWrappedObject, QDataStream& arg__1)
|
|
|
{
|
|
|
arg__1 << (*theWrappedObject);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMatrix4x4::__eq__(QMatrix4x4* theWrappedObject, const QMatrix4x4& other) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)== other);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMatrix4x4::readFrom(QMatrix4x4* theWrappedObject, QDataStream& arg__1)
|
|
|
{
|
|
|
arg__1 >> (*theWrappedObject);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMatrix4x4::optimize(QMatrix4x4* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->optimize());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMatrix4x4::ortho(QMatrix4x4* theWrappedObject, const QRect& rect)
|
|
|
{
|
|
|
( theWrappedObject->ortho(rect));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMatrix4x4::ortho(QMatrix4x4* theWrappedObject, const QRectF& rect)
|
|
|
{
|
|
|
( theWrappedObject->ortho(rect));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMatrix4x4::ortho(QMatrix4x4* theWrappedObject, qreal left, qreal right, qreal bottom, qreal top, qreal nearPlane, qreal farPlane)
|
|
|
{
|
|
|
( theWrappedObject->ortho(left, right, bottom, top, nearPlane, farPlane));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMatrix4x4::perspective(QMatrix4x4* theWrappedObject, qreal angle, qreal aspect, qreal nearPlane, qreal farPlane)
|
|
|
{
|
|
|
( theWrappedObject->perspective(angle, aspect, nearPlane, farPlane));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMatrix4x4::rotate(QMatrix4x4* theWrappedObject, const QQuaternion& quaternion)
|
|
|
{
|
|
|
( theWrappedObject->rotate(quaternion));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMatrix4x4::rotate(QMatrix4x4* theWrappedObject, qreal angle, const QVector3D& vector)
|
|
|
{
|
|
|
( theWrappedObject->rotate(angle, vector));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMatrix4x4::rotate(QMatrix4x4* theWrappedObject, qreal angle, qreal x, qreal y, qreal z)
|
|
|
{
|
|
|
( theWrappedObject->rotate(angle, x, y, z));
|
|
|
}
|
|
|
|
|
|
QVector4D PythonQtWrapper_QMatrix4x4::row(QMatrix4x4* theWrappedObject, int index) const
|
|
|
{
|
|
|
return ( theWrappedObject->row(index));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMatrix4x4::scale(QMatrix4x4* theWrappedObject, const QVector3D& vector)
|
|
|
{
|
|
|
( theWrappedObject->scale(vector));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMatrix4x4::scale(QMatrix4x4* theWrappedObject, qreal factor)
|
|
|
{
|
|
|
( theWrappedObject->scale(factor));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMatrix4x4::scale(QMatrix4x4* theWrappedObject, qreal x, qreal y)
|
|
|
{
|
|
|
( theWrappedObject->scale(x, y));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMatrix4x4::scale(QMatrix4x4* theWrappedObject, qreal x, qreal y, qreal z)
|
|
|
{
|
|
|
( theWrappedObject->scale(x, y, z));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMatrix4x4::setColumn(QMatrix4x4* theWrappedObject, int index, const QVector4D& value)
|
|
|
{
|
|
|
( theWrappedObject->setColumn(index, value));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMatrix4x4::setRow(QMatrix4x4* theWrappedObject, int index, const QVector4D& value)
|
|
|
{
|
|
|
( theWrappedObject->setRow(index, value));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMatrix4x4::setToIdentity(QMatrix4x4* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->setToIdentity());
|
|
|
}
|
|
|
|
|
|
QMatrix PythonQtWrapper_QMatrix4x4::toAffine(QMatrix4x4* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->toAffine());
|
|
|
}
|
|
|
|
|
|
QTransform PythonQtWrapper_QMatrix4x4::toTransform(QMatrix4x4* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->toTransform());
|
|
|
}
|
|
|
|
|
|
QTransform PythonQtWrapper_QMatrix4x4::toTransform(QMatrix4x4* theWrappedObject, qreal distanceToPlane) const
|
|
|
{
|
|
|
return ( theWrappedObject->toTransform(distanceToPlane));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMatrix4x4::translate(QMatrix4x4* theWrappedObject, const QVector3D& vector)
|
|
|
{
|
|
|
( theWrappedObject->translate(vector));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMatrix4x4::translate(QMatrix4x4* theWrappedObject, qreal x, qreal y)
|
|
|
{
|
|
|
( theWrappedObject->translate(x, y));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMatrix4x4::translate(QMatrix4x4* theWrappedObject, qreal x, qreal y, qreal z)
|
|
|
{
|
|
|
( theWrappedObject->translate(x, y, z));
|
|
|
}
|
|
|
|
|
|
QMatrix4x4 PythonQtWrapper_QMatrix4x4::transposed(QMatrix4x4* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->transposed());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QMatrix4x4::py_toString(QMatrix4x4* obj) {
|
|
|
QString result;
|
|
|
QDebug d(&result);
|
|
|
d << *obj;
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QMdiArea::~PythonQtShell_QMdiArea() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::actionEvent(QActionEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QActionEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::actionEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::changeEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::changeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::childEvent(QChildEvent* childEvent)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&childEvent};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::childEvent(childEvent);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::closeEvent(QCloseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QCloseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::closeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::contextMenuEvent(QContextMenuEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QContextMenuEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::contextMenuEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::customEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QMdiArea::devType() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMdiArea::devType();
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::dragEnterEvent(QDragEnterEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragEnterEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::dragEnterEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::dragLeaveEvent(QDragLeaveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::dragLeaveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::dragMoveEvent(QDragMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::dragMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::dropEvent(QDropEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDropEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::dropEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::enterEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::enterEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QMdiArea::event(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMdiArea::event(event);
|
|
|
}
|
|
|
bool PythonQtShell_QMdiArea::eventFilter(QObject* object, QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[3] = {NULL, (void*)&object, (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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMdiArea::eventFilter(object, event);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::focusInEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::focusInEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QMdiArea::focusNextPrevChild(bool next)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMdiArea::focusNextPrevChild(next);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::focusOutEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::focusOutEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QMdiArea::heightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMdiArea::heightForWidth(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::hideEvent(QHideEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QHideEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::hideEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::inputMethodEvent(QInputMethodEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QInputMethodEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::inputMethodEvent(arg__1);
|
|
|
}
|
|
|
QVariant PythonQtShell_QMdiArea::inputMethodQuery(Qt::InputMethodQuery arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QVariant returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QVariant*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMdiArea::inputMethodQuery(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::keyPressEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::keyPressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::keyReleaseEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::keyReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::languageChange()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "languageChange");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::languageChange();
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::leaveEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::leaveEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QMdiArea::metric(QPaintDevice::PaintDeviceMetric arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMdiArea::metric(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::mouseDoubleClickEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::mouseDoubleClickEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::mouseMoveEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::mouseMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::mousePressEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::mousePressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::mouseReleaseEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::mouseReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::moveEvent(QMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::moveEvent(arg__1);
|
|
|
}
|
|
|
QPaintEngine* PythonQtShell_QMdiArea::paintEngine() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPaintEngine*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPaintEngine* 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintEngine**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMdiArea::paintEngine();
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::paintEvent(QPaintEvent* paintEvent)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPaintEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&paintEvent};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::paintEvent(paintEvent);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::resizeEvent(QResizeEvent* resizeEvent)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QResizeEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&resizeEvent};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::resizeEvent(resizeEvent);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::scrollContentsBy(int dx, int dy)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "scrollContentsBy");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&dx, (void*)&dy};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::scrollContentsBy(dx, dy);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::showEvent(QShowEvent* showEvent)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QShowEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&showEvent};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::showEvent(showEvent);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::tabletEvent(QTabletEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTabletEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::tabletEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::timerEvent(QTimerEvent* timerEvent)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&timerEvent};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::timerEvent(timerEvent);
|
|
|
}
|
|
|
bool PythonQtShell_QMdiArea::viewportEvent(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("viewportEvent", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMdiArea::viewportEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QMdiArea::wheelEvent(QWheelEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWheelEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiArea::wheelEvent(arg__1);
|
|
|
}
|
|
|
QMdiArea* PythonQtWrapper_QMdiArea::new_QMdiArea(QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QMdiArea(parent); }
|
|
|
|
|
|
QMdiArea::WindowOrder PythonQtWrapper_QMdiArea::activationOrder(QMdiArea* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->activationOrder());
|
|
|
}
|
|
|
|
|
|
QMdiSubWindow* PythonQtWrapper_QMdiArea::activeSubWindow(QMdiArea* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->activeSubWindow());
|
|
|
}
|
|
|
|
|
|
QMdiSubWindow* PythonQtWrapper_QMdiArea::addSubWindow(QMdiArea* theWrappedObject, QWidget* widget, Qt::WindowFlags flags)
|
|
|
{
|
|
|
return ( theWrappedObject->addSubWindow(widget, flags));
|
|
|
}
|
|
|
|
|
|
QBrush PythonQtWrapper_QMdiArea::background(QMdiArea* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->background());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiArea::childEvent(QMdiArea* theWrappedObject, QChildEvent* childEvent)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMdiArea*)theWrappedObject)->promoted_childEvent(childEvent));
|
|
|
}
|
|
|
|
|
|
QMdiSubWindow* PythonQtWrapper_QMdiArea::currentSubWindow(QMdiArea* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->currentSubWindow());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMdiArea::documentMode(QMdiArea* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->documentMode());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMdiArea::event(QMdiArea* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QMdiArea*)theWrappedObject)->promoted_event(event));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMdiArea::eventFilter(QMdiArea* theWrappedObject, QObject* object, QEvent* event)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QMdiArea*)theWrappedObject)->promoted_eventFilter(object, event));
|
|
|
}
|
|
|
|
|
|
QSize PythonQtWrapper_QMdiArea::minimumSizeHint(QMdiArea* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->minimumSizeHint());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiArea::paintEvent(QMdiArea* theWrappedObject, QPaintEvent* paintEvent)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMdiArea*)theWrappedObject)->promoted_paintEvent(paintEvent));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiArea::removeSubWindow(QMdiArea* theWrappedObject, QWidget* widget)
|
|
|
{
|
|
|
( theWrappedObject->removeSubWindow(widget));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiArea::resizeEvent(QMdiArea* theWrappedObject, QResizeEvent* resizeEvent)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMdiArea*)theWrappedObject)->promoted_resizeEvent(resizeEvent));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiArea::scrollContentsBy(QMdiArea* theWrappedObject, int dx, int dy)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMdiArea*)theWrappedObject)->promoted_scrollContentsBy(dx, dy));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiArea::setActivationOrder(QMdiArea* theWrappedObject, QMdiArea::WindowOrder order)
|
|
|
{
|
|
|
( theWrappedObject->setActivationOrder(order));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiArea::setBackground(QMdiArea* theWrappedObject, const QBrush& background)
|
|
|
{
|
|
|
( theWrappedObject->setBackground(background));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiArea::setDocumentMode(QMdiArea* theWrappedObject, bool enabled)
|
|
|
{
|
|
|
( theWrappedObject->setDocumentMode(enabled));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiArea::setOption(QMdiArea* theWrappedObject, QMdiArea::AreaOption option, bool on)
|
|
|
{
|
|
|
( theWrappedObject->setOption(option, on));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiArea::setTabPosition(QMdiArea* theWrappedObject, QTabWidget::TabPosition position)
|
|
|
{
|
|
|
( theWrappedObject->setTabPosition(position));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiArea::setTabShape(QMdiArea* theWrappedObject, QTabWidget::TabShape shape)
|
|
|
{
|
|
|
( theWrappedObject->setTabShape(shape));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiArea::setTabsClosable(QMdiArea* theWrappedObject, bool closable)
|
|
|
{
|
|
|
( theWrappedObject->setTabsClosable(closable));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiArea::setTabsMovable(QMdiArea* theWrappedObject, bool movable)
|
|
|
{
|
|
|
( theWrappedObject->setTabsMovable(movable));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiArea::setViewMode(QMdiArea* theWrappedObject, QMdiArea::ViewMode mode)
|
|
|
{
|
|
|
( theWrappedObject->setViewMode(mode));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiArea::showEvent(QMdiArea* theWrappedObject, QShowEvent* showEvent)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMdiArea*)theWrappedObject)->promoted_showEvent(showEvent));
|
|
|
}
|
|
|
|
|
|
QSize PythonQtWrapper_QMdiArea::sizeHint(QMdiArea* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->sizeHint());
|
|
|
}
|
|
|
|
|
|
QList<QMdiSubWindow* > PythonQtWrapper_QMdiArea::subWindowList(QMdiArea* theWrappedObject, QMdiArea::WindowOrder order) const
|
|
|
{
|
|
|
return ( theWrappedObject->subWindowList(order));
|
|
|
}
|
|
|
|
|
|
QTabWidget::TabPosition PythonQtWrapper_QMdiArea::tabPosition(QMdiArea* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->tabPosition());
|
|
|
}
|
|
|
|
|
|
QTabWidget::TabShape PythonQtWrapper_QMdiArea::tabShape(QMdiArea* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->tabShape());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMdiArea::tabsClosable(QMdiArea* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->tabsClosable());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMdiArea::tabsMovable(QMdiArea* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->tabsMovable());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMdiArea::testOption(QMdiArea* theWrappedObject, QMdiArea::AreaOption opton) const
|
|
|
{
|
|
|
return ( theWrappedObject->testOption(opton));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiArea::timerEvent(QMdiArea* theWrappedObject, QTimerEvent* timerEvent)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMdiArea*)theWrappedObject)->promoted_timerEvent(timerEvent));
|
|
|
}
|
|
|
|
|
|
QMdiArea::ViewMode PythonQtWrapper_QMdiArea::viewMode(QMdiArea* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->viewMode());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMdiArea::viewportEvent(QMdiArea* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QMdiArea*)theWrappedObject)->promoted_viewportEvent(event));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QMdiSubWindow::~PythonQtShell_QMdiSubWindow() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::actionEvent(QActionEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QActionEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::actionEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::changeEvent(QEvent* changeEvent)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&changeEvent};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::changeEvent(changeEvent);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::childEvent(QChildEvent* childEvent)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&childEvent};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::childEvent(childEvent);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::closeEvent(QCloseEvent* closeEvent)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QCloseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&closeEvent};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::closeEvent(closeEvent);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::contextMenuEvent(QContextMenuEvent* contextMenuEvent)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QContextMenuEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&contextMenuEvent};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::contextMenuEvent(contextMenuEvent);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::customEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QMdiSubWindow::devType() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMdiSubWindow::devType();
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::dragEnterEvent(QDragEnterEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragEnterEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::dragEnterEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::dragLeaveEvent(QDragLeaveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::dragLeaveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::dragMoveEvent(QDragMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::dragMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::dropEvent(QDropEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDropEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::dropEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::enterEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::enterEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QMdiSubWindow::event(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMdiSubWindow::event(event);
|
|
|
}
|
|
|
bool PythonQtShell_QMdiSubWindow::eventFilter(QObject* object, QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[3] = {NULL, (void*)&object, (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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMdiSubWindow::eventFilter(object, event);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::focusInEvent(QFocusEvent* focusInEvent)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&focusInEvent};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::focusInEvent(focusInEvent);
|
|
|
}
|
|
|
bool PythonQtShell_QMdiSubWindow::focusNextPrevChild(bool next)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMdiSubWindow::focusNextPrevChild(next);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::focusOutEvent(QFocusEvent* focusOutEvent)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&focusOutEvent};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::focusOutEvent(focusOutEvent);
|
|
|
}
|
|
|
int PythonQtShell_QMdiSubWindow::heightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMdiSubWindow::heightForWidth(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::hideEvent(QHideEvent* hideEvent)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QHideEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&hideEvent};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::hideEvent(hideEvent);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::inputMethodEvent(QInputMethodEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QInputMethodEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::inputMethodEvent(arg__1);
|
|
|
}
|
|
|
QVariant PythonQtShell_QMdiSubWindow::inputMethodQuery(Qt::InputMethodQuery arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QVariant returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QVariant*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMdiSubWindow::inputMethodQuery(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::keyPressEvent(QKeyEvent* keyEvent)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&keyEvent};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::keyPressEvent(keyEvent);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::keyReleaseEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::keyReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::languageChange()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "languageChange");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::languageChange();
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::leaveEvent(QEvent* leaveEvent)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&leaveEvent};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::leaveEvent(leaveEvent);
|
|
|
}
|
|
|
int PythonQtShell_QMdiSubWindow::metric(QPaintDevice::PaintDeviceMetric arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMdiSubWindow::metric(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::mouseDoubleClickEvent(QMouseEvent* mouseEvent)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&mouseEvent};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::mouseDoubleClickEvent(mouseEvent);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::mouseMoveEvent(QMouseEvent* mouseEvent)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&mouseEvent};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::mouseMoveEvent(mouseEvent);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::mousePressEvent(QMouseEvent* mouseEvent)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&mouseEvent};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::mousePressEvent(mouseEvent);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::mouseReleaseEvent(QMouseEvent* mouseEvent)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&mouseEvent};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::mouseReleaseEvent(mouseEvent);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::moveEvent(QMoveEvent* moveEvent)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&moveEvent};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::moveEvent(moveEvent);
|
|
|
}
|
|
|
QPaintEngine* PythonQtShell_QMdiSubWindow::paintEngine() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPaintEngine*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPaintEngine* 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintEngine**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMdiSubWindow::paintEngine();
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::paintEvent(QPaintEvent* paintEvent)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPaintEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&paintEvent};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::paintEvent(paintEvent);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::resizeEvent(QResizeEvent* resizeEvent)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QResizeEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&resizeEvent};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::resizeEvent(resizeEvent);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::showEvent(QShowEvent* showEvent)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QShowEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&showEvent};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::showEvent(showEvent);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::tabletEvent(QTabletEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTabletEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::tabletEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::timerEvent(QTimerEvent* timerEvent)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&timerEvent};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::timerEvent(timerEvent);
|
|
|
}
|
|
|
void PythonQtShell_QMdiSubWindow::wheelEvent(QWheelEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWheelEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMdiSubWindow::wheelEvent(arg__1);
|
|
|
}
|
|
|
QMdiSubWindow* PythonQtWrapper_QMdiSubWindow::new_QMdiSubWindow(QWidget* parent, Qt::WindowFlags flags)
|
|
|
{
|
|
|
return new PythonQtShell_QMdiSubWindow(parent, flags); }
|
|
|
|
|
|
void PythonQtWrapper_QMdiSubWindow::changeEvent(QMdiSubWindow* theWrappedObject, QEvent* changeEvent)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMdiSubWindow*)theWrappedObject)->promoted_changeEvent(changeEvent));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiSubWindow::childEvent(QMdiSubWindow* theWrappedObject, QChildEvent* childEvent)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMdiSubWindow*)theWrappedObject)->promoted_childEvent(childEvent));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiSubWindow::closeEvent(QMdiSubWindow* theWrappedObject, QCloseEvent* closeEvent)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMdiSubWindow*)theWrappedObject)->promoted_closeEvent(closeEvent));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiSubWindow::contextMenuEvent(QMdiSubWindow* theWrappedObject, QContextMenuEvent* contextMenuEvent)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMdiSubWindow*)theWrappedObject)->promoted_contextMenuEvent(contextMenuEvent));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMdiSubWindow::event(QMdiSubWindow* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QMdiSubWindow*)theWrappedObject)->promoted_event(event));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMdiSubWindow::eventFilter(QMdiSubWindow* theWrappedObject, QObject* object, QEvent* event)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QMdiSubWindow*)theWrappedObject)->promoted_eventFilter(object, event));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiSubWindow::focusInEvent(QMdiSubWindow* theWrappedObject, QFocusEvent* focusInEvent)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMdiSubWindow*)theWrappedObject)->promoted_focusInEvent(focusInEvent));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiSubWindow::focusOutEvent(QMdiSubWindow* theWrappedObject, QFocusEvent* focusOutEvent)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMdiSubWindow*)theWrappedObject)->promoted_focusOutEvent(focusOutEvent));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiSubWindow::hideEvent(QMdiSubWindow* theWrappedObject, QHideEvent* hideEvent)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMdiSubWindow*)theWrappedObject)->promoted_hideEvent(hideEvent));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMdiSubWindow::isShaded(QMdiSubWindow* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isShaded());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiSubWindow::keyPressEvent(QMdiSubWindow* theWrappedObject, QKeyEvent* keyEvent)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMdiSubWindow*)theWrappedObject)->promoted_keyPressEvent(keyEvent));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QMdiSubWindow::keyboardPageStep(QMdiSubWindow* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->keyboardPageStep());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QMdiSubWindow::keyboardSingleStep(QMdiSubWindow* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->keyboardSingleStep());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiSubWindow::leaveEvent(QMdiSubWindow* theWrappedObject, QEvent* leaveEvent)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMdiSubWindow*)theWrappedObject)->promoted_leaveEvent(leaveEvent));
|
|
|
}
|
|
|
|
|
|
QWidget* PythonQtWrapper_QMdiSubWindow::maximizedButtonsWidget(QMdiSubWindow* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->maximizedButtonsWidget());
|
|
|
}
|
|
|
|
|
|
QWidget* PythonQtWrapper_QMdiSubWindow::maximizedSystemMenuIconWidget(QMdiSubWindow* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->maximizedSystemMenuIconWidget());
|
|
|
}
|
|
|
|
|
|
QMdiArea* PythonQtWrapper_QMdiSubWindow::mdiArea(QMdiSubWindow* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->mdiArea());
|
|
|
}
|
|
|
|
|
|
QSize PythonQtWrapper_QMdiSubWindow::minimumSizeHint(QMdiSubWindow* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->minimumSizeHint());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiSubWindow::mouseDoubleClickEvent(QMdiSubWindow* theWrappedObject, QMouseEvent* mouseEvent)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMdiSubWindow*)theWrappedObject)->promoted_mouseDoubleClickEvent(mouseEvent));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiSubWindow::mouseMoveEvent(QMdiSubWindow* theWrappedObject, QMouseEvent* mouseEvent)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMdiSubWindow*)theWrappedObject)->promoted_mouseMoveEvent(mouseEvent));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiSubWindow::mousePressEvent(QMdiSubWindow* theWrappedObject, QMouseEvent* mouseEvent)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMdiSubWindow*)theWrappedObject)->promoted_mousePressEvent(mouseEvent));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiSubWindow::mouseReleaseEvent(QMdiSubWindow* theWrappedObject, QMouseEvent* mouseEvent)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMdiSubWindow*)theWrappedObject)->promoted_mouseReleaseEvent(mouseEvent));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiSubWindow::moveEvent(QMdiSubWindow* theWrappedObject, QMoveEvent* moveEvent)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMdiSubWindow*)theWrappedObject)->promoted_moveEvent(moveEvent));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiSubWindow::paintEvent(QMdiSubWindow* theWrappedObject, QPaintEvent* paintEvent)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMdiSubWindow*)theWrappedObject)->promoted_paintEvent(paintEvent));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiSubWindow::resizeEvent(QMdiSubWindow* theWrappedObject, QResizeEvent* resizeEvent)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMdiSubWindow*)theWrappedObject)->promoted_resizeEvent(resizeEvent));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiSubWindow::setKeyboardPageStep(QMdiSubWindow* theWrappedObject, int step)
|
|
|
{
|
|
|
( theWrappedObject->setKeyboardPageStep(step));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiSubWindow::setKeyboardSingleStep(QMdiSubWindow* theWrappedObject, int step)
|
|
|
{
|
|
|
( theWrappedObject->setKeyboardSingleStep(step));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiSubWindow::setOption(QMdiSubWindow* theWrappedObject, QMdiSubWindow::SubWindowOption option, bool on)
|
|
|
{
|
|
|
( theWrappedObject->setOption(option, on));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiSubWindow::setSystemMenu(QMdiSubWindow* theWrappedObject, QMenu* systemMenu)
|
|
|
{
|
|
|
( theWrappedObject->setSystemMenu(systemMenu));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiSubWindow::setWidget(QMdiSubWindow* theWrappedObject, QWidget* widget)
|
|
|
{
|
|
|
( theWrappedObject->setWidget(widget));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiSubWindow::showEvent(QMdiSubWindow* theWrappedObject, QShowEvent* showEvent)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMdiSubWindow*)theWrappedObject)->promoted_showEvent(showEvent));
|
|
|
}
|
|
|
|
|
|
QSize PythonQtWrapper_QMdiSubWindow::sizeHint(QMdiSubWindow* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->sizeHint());
|
|
|
}
|
|
|
|
|
|
QMenu* PythonQtWrapper_QMdiSubWindow::systemMenu(QMdiSubWindow* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->systemMenu());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMdiSubWindow::testOption(QMdiSubWindow* theWrappedObject, QMdiSubWindow::SubWindowOption arg__1) const
|
|
|
{
|
|
|
return ( theWrappedObject->testOption(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMdiSubWindow::timerEvent(QMdiSubWindow* theWrappedObject, QTimerEvent* timerEvent)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMdiSubWindow*)theWrappedObject)->promoted_timerEvent(timerEvent));
|
|
|
}
|
|
|
|
|
|
QWidget* PythonQtWrapper_QMdiSubWindow::widget(QMdiSubWindow* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->widget());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QMenu::~PythonQtShell_QMenu() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QMenu::actionEvent(QActionEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QActionEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::actionEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenu::changeEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::changeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenu::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenu::closeEvent(QCloseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QCloseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::closeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenu::contextMenuEvent(QContextMenuEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QContextMenuEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::contextMenuEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenu::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::customEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QMenu::devType() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMenu::devType();
|
|
|
}
|
|
|
void PythonQtShell_QMenu::dragEnterEvent(QDragEnterEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragEnterEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::dragEnterEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenu::dragLeaveEvent(QDragLeaveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::dragLeaveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenu::dragMoveEvent(QDragMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::dragMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenu::dropEvent(QDropEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDropEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::dropEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenu::enterEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::enterEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QMenu::event(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMenu::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QMenu::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 char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMenu::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QMenu::focusInEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::focusInEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QMenu::focusNextPrevChild(bool next)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMenu::focusNextPrevChild(next);
|
|
|
}
|
|
|
void PythonQtShell_QMenu::focusOutEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::focusOutEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QMenu::heightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMenu::heightForWidth(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenu::hideEvent(QHideEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QHideEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::hideEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenu::inputMethodEvent(QInputMethodEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QInputMethodEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::inputMethodEvent(arg__1);
|
|
|
}
|
|
|
QVariant PythonQtShell_QMenu::inputMethodQuery(Qt::InputMethodQuery arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QVariant returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QVariant*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMenu::inputMethodQuery(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenu::keyPressEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::keyPressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenu::keyReleaseEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::keyReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenu::languageChange()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "languageChange");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::languageChange();
|
|
|
}
|
|
|
void PythonQtShell_QMenu::leaveEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::leaveEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QMenu::metric(QPaintDevice::PaintDeviceMetric arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMenu::metric(arg__1);
|
|
|
}
|
|
|
QSize PythonQtShell_QMenu::minimumSizeHint() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QSize"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QSize 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QSize*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMenu::minimumSizeHint();
|
|
|
}
|
|
|
void PythonQtShell_QMenu::mouseDoubleClickEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::mouseDoubleClickEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenu::mouseMoveEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::mouseMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenu::mousePressEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::mousePressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenu::mouseReleaseEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::mouseReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenu::moveEvent(QMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::moveEvent(arg__1);
|
|
|
}
|
|
|
QPaintEngine* PythonQtShell_QMenu::paintEngine() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPaintEngine*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPaintEngine* 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintEngine**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMenu::paintEngine();
|
|
|
}
|
|
|
void PythonQtShell_QMenu::paintEvent(QPaintEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPaintEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::paintEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenu::resizeEvent(QResizeEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QResizeEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::resizeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenu::showEvent(QShowEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QShowEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::showEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenu::tabletEvent(QTabletEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTabletEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::tabletEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenu::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::timerEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenu::wheelEvent(QWheelEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWheelEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenu::wheelEvent(arg__1);
|
|
|
}
|
|
|
QMenu* PythonQtWrapper_QMenu::new_QMenu(QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QMenu(parent); }
|
|
|
|
|
|
QMenu* PythonQtWrapper_QMenu::new_QMenu(const QString& title, QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QMenu(title, parent); }
|
|
|
|
|
|
QAction* PythonQtWrapper_QMenu::actionAt(QMenu* theWrappedObject, const QPoint& arg__1) const
|
|
|
{
|
|
|
return ( theWrappedObject->actionAt(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenu::actionEvent(QMenu* theWrappedObject, QActionEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMenu*)theWrappedObject)->promoted_actionEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
QRect PythonQtWrapper_QMenu::actionGeometry(QMenu* theWrappedObject, QAction* arg__1) const
|
|
|
{
|
|
|
return ( theWrappedObject->actionGeometry(arg__1));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QMenu::activeAction(QMenu* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->activeAction());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenu::addAction(QMenu* theWrappedObject, QAction* action)
|
|
|
{
|
|
|
( theWrappedObject->addAction(action));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QMenu::addAction(QMenu* theWrappedObject, const QIcon& icon, const QString& text)
|
|
|
{
|
|
|
return ( theWrappedObject->addAction(icon, text));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QMenu::addAction(QMenu* theWrappedObject, const QIcon& icon, const QString& text, const QObject* receiver, const char* member, const QKeySequence& shortcut)
|
|
|
{
|
|
|
return ( theWrappedObject->addAction(icon, text, receiver, member, shortcut));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QMenu::addAction(QMenu* theWrappedObject, const QString& text)
|
|
|
{
|
|
|
return ( theWrappedObject->addAction(text));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QMenu::addAction(QMenu* theWrappedObject, const QString& text, const QObject* receiver, const char* member, const QKeySequence& shortcut)
|
|
|
{
|
|
|
return ( theWrappedObject->addAction(text, receiver, member, shortcut));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QMenu::addMenu(QMenu* theWrappedObject, QMenu* menu)
|
|
|
{
|
|
|
return ( theWrappedObject->addMenu(menu));
|
|
|
}
|
|
|
|
|
|
QMenu* PythonQtWrapper_QMenu::addMenu(QMenu* theWrappedObject, const QIcon& icon, const QString& title)
|
|
|
{
|
|
|
return ( theWrappedObject->addMenu(icon, title));
|
|
|
}
|
|
|
|
|
|
QMenu* PythonQtWrapper_QMenu::addMenu(QMenu* theWrappedObject, const QString& title)
|
|
|
{
|
|
|
return ( theWrappedObject->addMenu(title));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QMenu::addSeparator(QMenu* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->addSeparator());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenu::changeEvent(QMenu* theWrappedObject, QEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMenu*)theWrappedObject)->promoted_changeEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenu::clear(QMenu* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->clear());
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QMenu::defaultAction(QMenu* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->defaultAction());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenu::enterEvent(QMenu* theWrappedObject, QEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMenu*)theWrappedObject)->promoted_enterEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMenu::event(QMenu* theWrappedObject, QEvent* arg__1)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QMenu*)theWrappedObject)->promoted_event(arg__1));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QMenu::exec(QMenu* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->exec());
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QMenu::static_QMenu_exec(QList<QAction* > actions, const QPoint& pos, QAction* at)
|
|
|
{
|
|
|
return (QMenu::exec(actions, pos, at));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QMenu::static_QMenu_exec(QList<QAction* > actions, const QPoint& pos, QAction* at, QWidget* parent)
|
|
|
{
|
|
|
return (QMenu::exec(actions, pos, at, parent));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QMenu::exec(QMenu* theWrappedObject, const QPoint& pos, QAction* at)
|
|
|
{
|
|
|
return ( theWrappedObject->exec(pos, at));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMenu::focusNextPrevChild(QMenu* theWrappedObject, bool next)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QMenu*)theWrappedObject)->promoted_focusNextPrevChild(next));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenu::hideEvent(QMenu* theWrappedObject, QHideEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMenu*)theWrappedObject)->promoted_hideEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenu::hideTearOffMenu(QMenu* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->hideTearOffMenu());
|
|
|
}
|
|
|
|
|
|
QIcon PythonQtWrapper_QMenu::icon(QMenu* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->icon());
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QMenu::insertMenu(QMenu* theWrappedObject, QAction* before, QMenu* menu)
|
|
|
{
|
|
|
return ( theWrappedObject->insertMenu(before, menu));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QMenu::insertSeparator(QMenu* theWrappedObject, QAction* before)
|
|
|
{
|
|
|
return ( theWrappedObject->insertSeparator(before));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMenu::isEmpty(QMenu* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isEmpty());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMenu::isTearOffEnabled(QMenu* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isTearOffEnabled());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMenu::isTearOffMenuVisible(QMenu* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isTearOffMenuVisible());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenu::keyPressEvent(QMenu* theWrappedObject, QKeyEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMenu*)theWrappedObject)->promoted_keyPressEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenu::leaveEvent(QMenu* theWrappedObject, QEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMenu*)theWrappedObject)->promoted_leaveEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QMenu::menuAction(QMenu* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->menuAction());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenu::mouseMoveEvent(QMenu* theWrappedObject, QMouseEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMenu*)theWrappedObject)->promoted_mouseMoveEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenu::mousePressEvent(QMenu* theWrappedObject, QMouseEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMenu*)theWrappedObject)->promoted_mousePressEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenu::mouseReleaseEvent(QMenu* theWrappedObject, QMouseEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMenu*)theWrappedObject)->promoted_mouseReleaseEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenu::paintEvent(QMenu* theWrappedObject, QPaintEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMenu*)theWrappedObject)->promoted_paintEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenu::popup(QMenu* theWrappedObject, const QPoint& pos, QAction* at)
|
|
|
{
|
|
|
( theWrappedObject->popup(pos, at));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMenu::separatorsCollapsible(QMenu* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->separatorsCollapsible());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenu::setActiveAction(QMenu* theWrappedObject, QAction* act)
|
|
|
{
|
|
|
( theWrappedObject->setActiveAction(act));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenu::setDefaultAction(QMenu* theWrappedObject, QAction* arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setDefaultAction(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenu::setIcon(QMenu* theWrappedObject, const QIcon& icon)
|
|
|
{
|
|
|
( theWrappedObject->setIcon(icon));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenu::setSeparatorsCollapsible(QMenu* theWrappedObject, bool collapse)
|
|
|
{
|
|
|
( theWrappedObject->setSeparatorsCollapsible(collapse));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenu::setTearOffEnabled(QMenu* theWrappedObject, bool arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setTearOffEnabled(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenu::setTitle(QMenu* theWrappedObject, const QString& title)
|
|
|
{
|
|
|
( theWrappedObject->setTitle(title));
|
|
|
}
|
|
|
|
|
|
QSize PythonQtWrapper_QMenu::sizeHint(QMenu* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->sizeHint());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenu::timerEvent(QMenu* theWrappedObject, QTimerEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMenu*)theWrappedObject)->promoted_timerEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QMenu::title(QMenu* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->title());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenu::wheelEvent(QMenu* theWrappedObject, QWheelEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMenu*)theWrappedObject)->promoted_wheelEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QMenuBar::~PythonQtShell_QMenuBar() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::actionEvent(QActionEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QActionEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::actionEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::changeEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::changeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::closeEvent(QCloseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QCloseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::closeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::contextMenuEvent(QContextMenuEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QContextMenuEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::contextMenuEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::customEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QMenuBar::devType() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMenuBar::devType();
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::dragEnterEvent(QDragEnterEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragEnterEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::dragEnterEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::dragLeaveEvent(QDragLeaveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::dragLeaveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::dragMoveEvent(QDragMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::dragMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::dropEvent(QDropEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDropEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::dropEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::enterEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::enterEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QMenuBar::event(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMenuBar::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QMenuBar::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 char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMenuBar::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::focusInEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::focusInEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QMenuBar::focusNextPrevChild(bool next)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMenuBar::focusNextPrevChild(next);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::focusOutEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::focusOutEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QMenuBar::heightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMenuBar::heightForWidth(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::hideEvent(QHideEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QHideEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::hideEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::inputMethodEvent(QInputMethodEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QInputMethodEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::inputMethodEvent(arg__1);
|
|
|
}
|
|
|
QVariant PythonQtShell_QMenuBar::inputMethodQuery(Qt::InputMethodQuery arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QVariant returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QVariant*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMenuBar::inputMethodQuery(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::keyPressEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::keyPressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::keyReleaseEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::keyReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::languageChange()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "languageChange");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::languageChange();
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::leaveEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::leaveEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QMenuBar::metric(QPaintDevice::PaintDeviceMetric arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMenuBar::metric(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::mouseDoubleClickEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::mouseDoubleClickEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::mouseMoveEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::mouseMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::mousePressEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::mousePressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::mouseReleaseEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::mouseReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::moveEvent(QMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::moveEvent(arg__1);
|
|
|
}
|
|
|
QPaintEngine* PythonQtShell_QMenuBar::paintEngine() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPaintEngine*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPaintEngine* 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintEngine**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMenuBar::paintEngine();
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::paintEvent(QPaintEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPaintEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::paintEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::resizeEvent(QResizeEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QResizeEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::resizeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::setVisible(bool visible)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setVisible");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&visible};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::setVisible(visible);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::showEvent(QShowEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QShowEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::showEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::tabletEvent(QTabletEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTabletEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::tabletEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::timerEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMenuBar::wheelEvent(QWheelEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWheelEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMenuBar::wheelEvent(arg__1);
|
|
|
}
|
|
|
QMenuBar* PythonQtWrapper_QMenuBar::new_QMenuBar(QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QMenuBar(parent); }
|
|
|
|
|
|
QAction* PythonQtWrapper_QMenuBar::actionAt(QMenuBar* theWrappedObject, const QPoint& arg__1) const
|
|
|
{
|
|
|
return ( theWrappedObject->actionAt(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenuBar::actionEvent(QMenuBar* theWrappedObject, QActionEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMenuBar*)theWrappedObject)->promoted_actionEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
QRect PythonQtWrapper_QMenuBar::actionGeometry(QMenuBar* theWrappedObject, QAction* arg__1) const
|
|
|
{
|
|
|
return ( theWrappedObject->actionGeometry(arg__1));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QMenuBar::activeAction(QMenuBar* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->activeAction());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenuBar::addAction(QMenuBar* theWrappedObject, QAction* action)
|
|
|
{
|
|
|
( theWrappedObject->addAction(action));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QMenuBar::addAction(QMenuBar* theWrappedObject, const QString& text)
|
|
|
{
|
|
|
return ( theWrappedObject->addAction(text));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QMenuBar::addAction(QMenuBar* theWrappedObject, const QString& text, const QObject* receiver, const char* member)
|
|
|
{
|
|
|
return ( theWrappedObject->addAction(text, receiver, member));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QMenuBar::addMenu(QMenuBar* theWrappedObject, QMenu* menu)
|
|
|
{
|
|
|
return ( theWrappedObject->addMenu(menu));
|
|
|
}
|
|
|
|
|
|
QMenu* PythonQtWrapper_QMenuBar::addMenu(QMenuBar* theWrappedObject, const QIcon& icon, const QString& title)
|
|
|
{
|
|
|
return ( theWrappedObject->addMenu(icon, title));
|
|
|
}
|
|
|
|
|
|
QMenu* PythonQtWrapper_QMenuBar::addMenu(QMenuBar* theWrappedObject, const QString& title)
|
|
|
{
|
|
|
return ( theWrappedObject->addMenu(title));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QMenuBar::addSeparator(QMenuBar* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->addSeparator());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenuBar::changeEvent(QMenuBar* theWrappedObject, QEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMenuBar*)theWrappedObject)->promoted_changeEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenuBar::clear(QMenuBar* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->clear());
|
|
|
}
|
|
|
|
|
|
QWidget* PythonQtWrapper_QMenuBar::cornerWidget(QMenuBar* theWrappedObject, Qt::Corner corner) const
|
|
|
{
|
|
|
return ( theWrappedObject->cornerWidget(corner));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMenuBar::event(QMenuBar* theWrappedObject, QEvent* arg__1)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QMenuBar*)theWrappedObject)->promoted_event(arg__1));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMenuBar::eventFilter(QMenuBar* theWrappedObject, QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QMenuBar*)theWrappedObject)->promoted_eventFilter(arg__1, arg__2));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenuBar::focusInEvent(QMenuBar* theWrappedObject, QFocusEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMenuBar*)theWrappedObject)->promoted_focusInEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenuBar::focusOutEvent(QMenuBar* theWrappedObject, QFocusEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMenuBar*)theWrappedObject)->promoted_focusOutEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QMenuBar::heightForWidth(QMenuBar* theWrappedObject, int arg__1) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QMenuBar*)theWrappedObject)->promoted_heightForWidth(arg__1));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QMenuBar::insertMenu(QMenuBar* theWrappedObject, QAction* before, QMenu* menu)
|
|
|
{
|
|
|
return ( theWrappedObject->insertMenu(before, menu));
|
|
|
}
|
|
|
|
|
|
QAction* PythonQtWrapper_QMenuBar::insertSeparator(QMenuBar* theWrappedObject, QAction* before)
|
|
|
{
|
|
|
return ( theWrappedObject->insertSeparator(before));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMenuBar::isDefaultUp(QMenuBar* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isDefaultUp());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMenuBar::isNativeMenuBar(QMenuBar* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isNativeMenuBar());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenuBar::keyPressEvent(QMenuBar* theWrappedObject, QKeyEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMenuBar*)theWrappedObject)->promoted_keyPressEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenuBar::leaveEvent(QMenuBar* theWrappedObject, QEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMenuBar*)theWrappedObject)->promoted_leaveEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
QSize PythonQtWrapper_QMenuBar::minimumSizeHint(QMenuBar* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->minimumSizeHint());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenuBar::mouseMoveEvent(QMenuBar* theWrappedObject, QMouseEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMenuBar*)theWrappedObject)->promoted_mouseMoveEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenuBar::mousePressEvent(QMenuBar* theWrappedObject, QMouseEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMenuBar*)theWrappedObject)->promoted_mousePressEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenuBar::mouseReleaseEvent(QMenuBar* theWrappedObject, QMouseEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMenuBar*)theWrappedObject)->promoted_mouseReleaseEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenuBar::paintEvent(QMenuBar* theWrappedObject, QPaintEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMenuBar*)theWrappedObject)->promoted_paintEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenuBar::resizeEvent(QMenuBar* theWrappedObject, QResizeEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMenuBar*)theWrappedObject)->promoted_resizeEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenuBar::setActiveAction(QMenuBar* theWrappedObject, QAction* action)
|
|
|
{
|
|
|
( theWrappedObject->setActiveAction(action));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenuBar::setCornerWidget(QMenuBar* theWrappedObject, QWidget* w, Qt::Corner corner)
|
|
|
{
|
|
|
( theWrappedObject->setCornerWidget(w, corner));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenuBar::setDefaultUp(QMenuBar* theWrappedObject, bool arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setDefaultUp(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenuBar::setNativeMenuBar(QMenuBar* theWrappedObject, bool nativeMenuBar)
|
|
|
{
|
|
|
( theWrappedObject->setNativeMenuBar(nativeMenuBar));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenuBar::setVisible(QMenuBar* theWrappedObject, bool visible)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMenuBar*)theWrappedObject)->promoted_setVisible(visible));
|
|
|
}
|
|
|
|
|
|
QSize PythonQtWrapper_QMenuBar::sizeHint(QMenuBar* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->sizeHint());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMenuBar::timerEvent(QMenuBar* theWrappedObject, QTimerEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMenuBar*)theWrappedObject)->promoted_timerEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QMessageBox::~PythonQtShell_QMessageBox() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::accept()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "accept");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::accept();
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::actionEvent(QActionEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QActionEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::actionEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::changeEvent(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::changeEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::closeEvent(QCloseEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QCloseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::closeEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::contextMenuEvent(QContextMenuEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QContextMenuEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::contextMenuEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::customEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QMessageBox::devType() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMessageBox::devType();
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::done(int arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "done");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::done(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::dragEnterEvent(QDragEnterEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragEnterEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::dragEnterEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::dragLeaveEvent(QDragLeaveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::dragLeaveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::dragMoveEvent(QDragMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::dragMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::dropEvent(QDropEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDropEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::dropEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::enterEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::enterEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QMessageBox::event(QEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMessageBox::event(e);
|
|
|
}
|
|
|
bool PythonQtShell_QMessageBox::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 char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMessageBox::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::focusInEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::focusInEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QMessageBox::focusNextPrevChild(bool next)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMessageBox::focusNextPrevChild(next);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::focusOutEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::focusOutEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QMessageBox::heightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMessageBox::heightForWidth(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::hideEvent(QHideEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QHideEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::hideEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::inputMethodEvent(QInputMethodEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QInputMethodEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::inputMethodEvent(arg__1);
|
|
|
}
|
|
|
QVariant PythonQtShell_QMessageBox::inputMethodQuery(Qt::InputMethodQuery arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QVariant returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QVariant*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMessageBox::inputMethodQuery(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::keyPressEvent(QKeyEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::keyPressEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::keyReleaseEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::keyReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::languageChange()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "languageChange");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::languageChange();
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::leaveEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::leaveEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QMessageBox::metric(QPaintDevice::PaintDeviceMetric arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMessageBox::metric(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::mouseDoubleClickEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::mouseDoubleClickEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::mouseMoveEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::mouseMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::mousePressEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::mousePressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::mouseReleaseEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::mouseReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::moveEvent(QMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::moveEvent(arg__1);
|
|
|
}
|
|
|
QPaintEngine* PythonQtShell_QMessageBox::paintEngine() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPaintEngine*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPaintEngine* 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintEngine**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMessageBox::paintEngine();
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::paintEvent(QPaintEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPaintEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::paintEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::reject()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reject");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::reject();
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::resizeEvent(QResizeEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QResizeEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::resizeEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::showEvent(QShowEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QShowEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::showEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::tabletEvent(QTabletEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTabletEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::tabletEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::timerEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMessageBox::wheelEvent(QWheelEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWheelEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMessageBox::wheelEvent(arg__1);
|
|
|
}
|
|
|
QMessageBox* PythonQtWrapper_QMessageBox::new_QMessageBox(QMessageBox::Icon icon, const QString& title, const QString& text, QMessageBox::StandardButtons buttons, QWidget* parent, Qt::WindowFlags flags)
|
|
|
{
|
|
|
return new PythonQtShell_QMessageBox(icon, title, text, buttons, parent, flags); }
|
|
|
|
|
|
QMessageBox* PythonQtWrapper_QMessageBox::new_QMessageBox(QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QMessageBox(parent); }
|
|
|
|
|
|
void PythonQtWrapper_QMessageBox::static_QMessageBox_about(QWidget* parent, const QString& title, const QString& text)
|
|
|
{
|
|
|
(QMessageBox::about(parent, title, text));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMessageBox::static_QMessageBox_aboutQt(QWidget* parent, const QString& title)
|
|
|
{
|
|
|
(QMessageBox::aboutQt(parent, title));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMessageBox::addButton(QMessageBox* theWrappedObject, QAbstractButton* button, QMessageBox::ButtonRole role)
|
|
|
{
|
|
|
( theWrappedObject->addButton(button, role));
|
|
|
}
|
|
|
|
|
|
QPushButton* PythonQtWrapper_QMessageBox::addButton(QMessageBox* theWrappedObject, QMessageBox::StandardButton button)
|
|
|
{
|
|
|
return ( theWrappedObject->addButton(button));
|
|
|
}
|
|
|
|
|
|
QPushButton* PythonQtWrapper_QMessageBox::addButton(QMessageBox* theWrappedObject, const QString& text, QMessageBox::ButtonRole role)
|
|
|
{
|
|
|
return ( theWrappedObject->addButton(text, role));
|
|
|
}
|
|
|
|
|
|
QAbstractButton* PythonQtWrapper_QMessageBox::button(QMessageBox* theWrappedObject, QMessageBox::StandardButton which) const
|
|
|
{
|
|
|
return ( theWrappedObject->button(which));
|
|
|
}
|
|
|
|
|
|
QMessageBox::ButtonRole PythonQtWrapper_QMessageBox::buttonRole(QMessageBox* theWrappedObject, QAbstractButton* button) const
|
|
|
{
|
|
|
return ( theWrappedObject->buttonRole(button));
|
|
|
}
|
|
|
|
|
|
QList<QAbstractButton* > PythonQtWrapper_QMessageBox::buttons(QMessageBox* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->buttons());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMessageBox::changeEvent(QMessageBox* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMessageBox*)theWrappedObject)->promoted_changeEvent(event));
|
|
|
}
|
|
|
|
|
|
QAbstractButton* PythonQtWrapper_QMessageBox::clickedButton(QMessageBox* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->clickedButton());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMessageBox::closeEvent(QMessageBox* theWrappedObject, QCloseEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMessageBox*)theWrappedObject)->promoted_closeEvent(event));
|
|
|
}
|
|
|
|
|
|
QMessageBox::StandardButton PythonQtWrapper_QMessageBox::static_QMessageBox_critical(QWidget* parent, const QString& title, const QString& text, QMessageBox::StandardButtons buttons, QMessageBox::StandardButton defaultButton)
|
|
|
{
|
|
|
return (QMessageBox::critical(parent, title, text, buttons, defaultButton));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QMessageBox::static_QMessageBox_critical(QWidget* parent, const QString& title, const QString& text, QMessageBox::StandardButton button0, QMessageBox::StandardButton button1)
|
|
|
{
|
|
|
return (QMessageBox::critical(parent, title, text, button0, button1));
|
|
|
}
|
|
|
|
|
|
QPushButton* PythonQtWrapper_QMessageBox::defaultButton(QMessageBox* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->defaultButton());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QMessageBox::detailedText(QMessageBox* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->detailedText());
|
|
|
}
|
|
|
|
|
|
QAbstractButton* PythonQtWrapper_QMessageBox::escapeButton(QMessageBox* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->escapeButton());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMessageBox::event(QMessageBox* theWrappedObject, QEvent* e)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QMessageBox*)theWrappedObject)->promoted_event(e));
|
|
|
}
|
|
|
|
|
|
QMessageBox::Icon PythonQtWrapper_QMessageBox::icon(QMessageBox* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->icon());
|
|
|
}
|
|
|
|
|
|
QPixmap PythonQtWrapper_QMessageBox::iconPixmap(QMessageBox* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->iconPixmap());
|
|
|
}
|
|
|
|
|
|
QMessageBox::StandardButton PythonQtWrapper_QMessageBox::static_QMessageBox_information(QWidget* parent, const QString& title, const QString& text, QMessageBox::StandardButtons buttons, QMessageBox::StandardButton defaultButton)
|
|
|
{
|
|
|
return (QMessageBox::information(parent, title, text, buttons, defaultButton));
|
|
|
}
|
|
|
|
|
|
QMessageBox::StandardButton PythonQtWrapper_QMessageBox::static_QMessageBox_information(QWidget* parent, const QString& title, const QString& text, QMessageBox::StandardButton button0, QMessageBox::StandardButton button1)
|
|
|
{
|
|
|
return (QMessageBox::information(parent, title, text, button0, button1));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QMessageBox::informativeText(QMessageBox* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->informativeText());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMessageBox::keyPressEvent(QMessageBox* theWrappedObject, QKeyEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMessageBox*)theWrappedObject)->promoted_keyPressEvent(event));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMessageBox::open(QMessageBox* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->open());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMessageBox::open(QMessageBox* theWrappedObject, QObject* receiver, const char* member)
|
|
|
{
|
|
|
( theWrappedObject->open(receiver, member));
|
|
|
}
|
|
|
|
|
|
QMessageBox::StandardButton PythonQtWrapper_QMessageBox::static_QMessageBox_question(QWidget* parent, const QString& title, const QString& text, QMessageBox::StandardButtons buttons, QMessageBox::StandardButton defaultButton)
|
|
|
{
|
|
|
return (QMessageBox::question(parent, title, text, buttons, defaultButton));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QMessageBox::static_QMessageBox_question(QWidget* parent, const QString& title, const QString& text, QMessageBox::StandardButton button0, QMessageBox::StandardButton button1)
|
|
|
{
|
|
|
return (QMessageBox::question(parent, title, text, button0, button1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMessageBox::removeButton(QMessageBox* theWrappedObject, QAbstractButton* button)
|
|
|
{
|
|
|
( theWrappedObject->removeButton(button));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMessageBox::resizeEvent(QMessageBox* theWrappedObject, QResizeEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMessageBox*)theWrappedObject)->promoted_resizeEvent(event));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMessageBox::setDefaultButton(QMessageBox* theWrappedObject, QMessageBox::StandardButton button)
|
|
|
{
|
|
|
( theWrappedObject->setDefaultButton(button));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMessageBox::setDefaultButton(QMessageBox* theWrappedObject, QPushButton* button)
|
|
|
{
|
|
|
( theWrappedObject->setDefaultButton(button));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMessageBox::setDetailedText(QMessageBox* theWrappedObject, const QString& text)
|
|
|
{
|
|
|
( theWrappedObject->setDetailedText(text));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMessageBox::setEscapeButton(QMessageBox* theWrappedObject, QAbstractButton* button)
|
|
|
{
|
|
|
( theWrappedObject->setEscapeButton(button));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMessageBox::setEscapeButton(QMessageBox* theWrappedObject, QMessageBox::StandardButton button)
|
|
|
{
|
|
|
( theWrappedObject->setEscapeButton(button));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMessageBox::setIcon(QMessageBox* theWrappedObject, QMessageBox::Icon arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setIcon(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMessageBox::setIconPixmap(QMessageBox* theWrappedObject, const QPixmap& pixmap)
|
|
|
{
|
|
|
( theWrappedObject->setIconPixmap(pixmap));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMessageBox::setInformativeText(QMessageBox* theWrappedObject, const QString& text)
|
|
|
{
|
|
|
( theWrappedObject->setInformativeText(text));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMessageBox::setStandardButtons(QMessageBox* theWrappedObject, QMessageBox::StandardButtons buttons)
|
|
|
{
|
|
|
( theWrappedObject->setStandardButtons(buttons));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMessageBox::setText(QMessageBox* theWrappedObject, const QString& text)
|
|
|
{
|
|
|
( theWrappedObject->setText(text));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMessageBox::setTextFormat(QMessageBox* theWrappedObject, Qt::TextFormat format)
|
|
|
{
|
|
|
( theWrappedObject->setTextFormat(format));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMessageBox::showEvent(QMessageBox* theWrappedObject, QShowEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMessageBox*)theWrappedObject)->promoted_showEvent(event));
|
|
|
}
|
|
|
|
|
|
QSize PythonQtWrapper_QMessageBox::sizeHint(QMessageBox* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->sizeHint());
|
|
|
}
|
|
|
|
|
|
QMessageBox::StandardButton PythonQtWrapper_QMessageBox::standardButton(QMessageBox* theWrappedObject, QAbstractButton* button) const
|
|
|
{
|
|
|
return ( theWrappedObject->standardButton(button));
|
|
|
}
|
|
|
|
|
|
QMessageBox::StandardButtons PythonQtWrapper_QMessageBox::standardButtons(QMessageBox* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->standardButtons());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QMessageBox::text(QMessageBox* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->text());
|
|
|
}
|
|
|
|
|
|
Qt::TextFormat PythonQtWrapper_QMessageBox::textFormat(QMessageBox* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->textFormat());
|
|
|
}
|
|
|
|
|
|
QMessageBox::StandardButton PythonQtWrapper_QMessageBox::static_QMessageBox_warning(QWidget* parent, const QString& title, const QString& text, QMessageBox::StandardButtons buttons, QMessageBox::StandardButton defaultButton)
|
|
|
{
|
|
|
return (QMessageBox::warning(parent, title, text, buttons, defaultButton));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QMessageBox::static_QMessageBox_warning(QWidget* parent, const QString& title, const QString& text, QMessageBox::StandardButton button0, QMessageBox::StandardButton button1)
|
|
|
{
|
|
|
return (QMessageBox::warning(parent, title, text, button0, button1));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QMotifStyle::~PythonQtShell_QMotifStyle() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QMotifStyle::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMotifStyle::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMotifStyle::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMotifStyle::customEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMotifStyle::drawComplexControl(QStyle::ComplexControl cc, const QStyleOptionComplex* opt, QPainter* p, const QWidget* w) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawComplexControl");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QStyle::ComplexControl" , "const QStyleOptionComplex*" , "QPainter*" , "const QWidget*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
|
|
|
void* args[5] = {NULL, (void*)&cc, (void*)&opt, (void*)&p, (void*)&w};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMotifStyle::drawComplexControl(cc, opt, p, w);
|
|
|
}
|
|
|
void PythonQtShell_QMotifStyle::drawControl(QStyle::ControlElement element, const QStyleOption* opt, QPainter* p, const QWidget* w) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawControl");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QStyle::ControlElement" , "const QStyleOption*" , "QPainter*" , "const QWidget*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
|
|
|
void* args[5] = {NULL, (void*)&element, (void*)&opt, (void*)&p, (void*)&w};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMotifStyle::drawControl(element, opt, p, w);
|
|
|
}
|
|
|
void PythonQtShell_QMotifStyle::drawItemPixmap(QPainter* painter, const QRect& rect, int alignment, const QPixmap& pixmap) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawItemPixmap");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPainter*" , "const QRect&" , "int" , "const QPixmap&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
|
|
|
void* args[5] = {NULL, (void*)&painter, (void*)&rect, (void*)&alignment, (void*)&pixmap};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMotifStyle::drawItemPixmap(painter, rect, alignment, pixmap);
|
|
|
}
|
|
|
void PythonQtShell_QMotifStyle::drawItemText(QPainter* painter, const QRect& rect, int flags, const QPalette& pal, bool enabled, const QString& text, QPalette::ColorRole textRole) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawItemText");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPainter*" , "const QRect&" , "int" , "const QPalette&" , "bool" , "const QString&" , "QPalette::ColorRole"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(8, argumentList);
|
|
|
void* args[8] = {NULL, (void*)&painter, (void*)&rect, (void*)&flags, (void*)&pal, (void*)&enabled, (void*)&text, (void*)&textRole};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMotifStyle::drawItemText(painter, rect, flags, pal, enabled, text, textRole);
|
|
|
}
|
|
|
void PythonQtShell_QMotifStyle::drawPrimitive(QStyle::PrimitiveElement pe, const QStyleOption* opt, QPainter* p, const QWidget* w) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawPrimitive");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QStyle::PrimitiveElement" , "const QStyleOption*" , "QPainter*" , "const QWidget*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
|
|
|
void* args[5] = {NULL, (void*)&pe, (void*)&opt, (void*)&p, (void*)&w};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMotifStyle::drawPrimitive(pe, opt, p, w);
|
|
|
}
|
|
|
bool PythonQtShell_QMotifStyle::event(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMotifStyle::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QMotifStyle::eventFilter(QObject* o, QEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[3] = {NULL, (void*)&o, (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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMotifStyle::eventFilter(o, e);
|
|
|
}
|
|
|
QPixmap PythonQtShell_QMotifStyle::generatedIconPixmap(QIcon::Mode iconMode, const QPixmap& pixmap, const QStyleOption* opt) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "generatedIconPixmap");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPixmap" , "QIcon::Mode" , "const QPixmap&" , "const QStyleOption*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
QPixmap returnValue;
|
|
|
void* args[4] = {NULL, (void*)&iconMode, (void*)&pixmap, (void*)&opt};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("generatedIconPixmap", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPixmap*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMotifStyle::generatedIconPixmap(iconMode, pixmap, opt);
|
|
|
}
|
|
|
QStyle::SubControl PythonQtShell_QMotifStyle::hitTestComplexControl(QStyle::ComplexControl cc, const QStyleOptionComplex* opt, const QPoint& pt, const QWidget* w) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hitTestComplexControl");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QStyle::SubControl" , "QStyle::ComplexControl" , "const QStyleOptionComplex*" , "const QPoint&" , "const QWidget*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
|
|
|
QStyle::SubControl returnValue;
|
|
|
void* args[5] = {NULL, (void*)&cc, (void*)&opt, (void*)&pt, (void*)&w};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("hitTestComplexControl", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QStyle::SubControl*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMotifStyle::hitTestComplexControl(cc, opt, pt, w);
|
|
|
}
|
|
|
QRect PythonQtShell_QMotifStyle::itemPixmapRect(const QRect& r, int flags, const QPixmap& pixmap) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "itemPixmapRect");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QRect" , "const QRect&" , "int" , "const QPixmap&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
QRect returnValue;
|
|
|
void* args[4] = {NULL, (void*)&r, (void*)&flags, (void*)&pixmap};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("itemPixmapRect", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QRect*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMotifStyle::itemPixmapRect(r, flags, pixmap);
|
|
|
}
|
|
|
int PythonQtShell_QMotifStyle::pixelMetric(QStyle::PixelMetric metric, const QStyleOption* option, const QWidget* widget) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "pixelMetric");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "QStyle::PixelMetric" , "const QStyleOption*" , "const QWidget*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[4] = {NULL, (void*)&metric, (void*)&option, (void*)&widget};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("pixelMetric", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMotifStyle::pixelMetric(metric, option, widget);
|
|
|
}
|
|
|
void PythonQtShell_QMotifStyle::polish(QApplication* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "polish");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QApplication*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMotifStyle::polish(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMotifStyle::polish(QPalette& arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "polish");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPalette&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMotifStyle::polish(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMotifStyle::polish(QWidget* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "polish");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWidget*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMotifStyle::polish(arg__1);
|
|
|
}
|
|
|
QSize PythonQtShell_QMotifStyle::sizeFromContents(QStyle::ContentsType ct, const QStyleOption* opt, const QSize& contentsSize, const QWidget* widget) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sizeFromContents");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QSize" , "QStyle::ContentsType" , "const QStyleOption*" , "const QSize&" , "const QWidget*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
|
|
|
QSize returnValue;
|
|
|
void* args[5] = {NULL, (void*)&ct, (void*)&opt, (void*)&contentsSize, (void*)&widget};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("sizeFromContents", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QSize*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMotifStyle::sizeFromContents(ct, opt, contentsSize, widget);
|
|
|
}
|
|
|
QPalette PythonQtShell_QMotifStyle::standardPalette() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "standardPalette");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPalette"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPalette 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("standardPalette", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPalette*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMotifStyle::standardPalette();
|
|
|
}
|
|
|
QPixmap PythonQtShell_QMotifStyle::standardPixmap(QStyle::StandardPixmap standardPixmap, const QStyleOption* opt, const QWidget* widget) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "standardPixmap");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPixmap" , "QStyle::StandardPixmap" , "const QStyleOption*" , "const QWidget*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
QPixmap returnValue;
|
|
|
void* args[4] = {NULL, (void*)&standardPixmap, (void*)&opt, (void*)&widget};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("standardPixmap", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPixmap*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QPixmap();
|
|
|
}
|
|
|
int PythonQtShell_QMotifStyle::styleHint(QStyle::StyleHint hint, const QStyleOption* opt, const QWidget* widget, QStyleHintReturn* returnData) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "styleHint");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "QStyle::StyleHint" , "const QStyleOption*" , "const QWidget*" , "QStyleHintReturn*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[5] = {NULL, (void*)&hint, (void*)&opt, (void*)&widget, (void*)&returnData};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("styleHint", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMotifStyle::styleHint(hint, opt, widget, returnData);
|
|
|
}
|
|
|
QRect PythonQtShell_QMotifStyle::subControlRect(QStyle::ComplexControl cc, const QStyleOptionComplex* opt, QStyle::SubControl sc, const QWidget* widget) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "subControlRect");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QRect" , "QStyle::ComplexControl" , "const QStyleOptionComplex*" , "QStyle::SubControl" , "const QWidget*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
|
|
|
QRect returnValue;
|
|
|
void* args[5] = {NULL, (void*)&cc, (void*)&opt, (void*)&sc, (void*)&widget};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("subControlRect", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QRect*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMotifStyle::subControlRect(cc, opt, sc, widget);
|
|
|
}
|
|
|
QRect PythonQtShell_QMotifStyle::subElementRect(QStyle::SubElement r, const QStyleOption* opt, const QWidget* widget) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "subElementRect");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QRect" , "QStyle::SubElement" , "const QStyleOption*" , "const QWidget*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
QRect returnValue;
|
|
|
void* args[4] = {NULL, (void*)&r, (void*)&opt, (void*)&widget};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("subElementRect", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QRect*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMotifStyle::subElementRect(r, opt, widget);
|
|
|
}
|
|
|
void PythonQtShell_QMotifStyle::timerEvent(QTimerEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMotifStyle::timerEvent(event);
|
|
|
}
|
|
|
void PythonQtShell_QMotifStyle::unpolish(QApplication* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "unpolish");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QApplication*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMotifStyle::unpolish(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMotifStyle::unpolish(QWidget* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "unpolish");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWidget*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMotifStyle::unpolish(arg__1);
|
|
|
}
|
|
|
QMotifStyle* PythonQtWrapper_QMotifStyle::new_QMotifStyle(bool useHighlightCols)
|
|
|
{
|
|
|
return new PythonQtShell_QMotifStyle(useHighlightCols); }
|
|
|
|
|
|
void PythonQtWrapper_QMotifStyle::drawComplexControl(QMotifStyle* theWrappedObject, QStyle::ComplexControl cc, const QStyleOptionComplex* opt, QPainter* p, const QWidget* w) const
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMotifStyle*)theWrappedObject)->promoted_drawComplexControl(cc, opt, p, w));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMotifStyle::drawControl(QMotifStyle* theWrappedObject, QStyle::ControlElement element, const QStyleOption* opt, QPainter* p, const QWidget* w) const
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMotifStyle*)theWrappedObject)->promoted_drawControl(element, opt, p, w));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMotifStyle::drawPrimitive(QMotifStyle* theWrappedObject, QStyle::PrimitiveElement pe, const QStyleOption* opt, QPainter* p, const QWidget* w) const
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMotifStyle*)theWrappedObject)->promoted_drawPrimitive(pe, opt, p, w));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMotifStyle::event(QMotifStyle* theWrappedObject, QEvent* arg__1)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QMotifStyle*)theWrappedObject)->promoted_event(arg__1));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMotifStyle::eventFilter(QMotifStyle* theWrappedObject, QObject* o, QEvent* e)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QMotifStyle*)theWrappedObject)->promoted_eventFilter(o, e));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QMotifStyle::pixelMetric(QMotifStyle* theWrappedObject, QStyle::PixelMetric metric, const QStyleOption* option, const QWidget* widget) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QMotifStyle*)theWrappedObject)->promoted_pixelMetric(metric, option, widget));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMotifStyle::polish(QMotifStyle* theWrappedObject, QApplication* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMotifStyle*)theWrappedObject)->promoted_polish(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMotifStyle::polish(QMotifStyle* theWrappedObject, QPalette& arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMotifStyle*)theWrappedObject)->promoted_polish(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMotifStyle::polish(QMotifStyle* theWrappedObject, QWidget* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMotifStyle*)theWrappedObject)->promoted_polish(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMotifStyle::setUseHighlightColors(QMotifStyle* theWrappedObject, bool arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setUseHighlightColors(arg__1));
|
|
|
}
|
|
|
|
|
|
QSize PythonQtWrapper_QMotifStyle::sizeFromContents(QMotifStyle* theWrappedObject, QStyle::ContentsType ct, const QStyleOption* opt, const QSize& contentsSize, const QWidget* widget) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QMotifStyle*)theWrappedObject)->promoted_sizeFromContents(ct, opt, contentsSize, widget));
|
|
|
}
|
|
|
|
|
|
QPalette PythonQtWrapper_QMotifStyle::standardPalette(QMotifStyle* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QMotifStyle*)theWrappedObject)->promoted_standardPalette());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QMotifStyle::styleHint(QMotifStyle* theWrappedObject, QStyle::StyleHint hint, const QStyleOption* opt, const QWidget* widget, QStyleHintReturn* returnData) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QMotifStyle*)theWrappedObject)->promoted_styleHint(hint, opt, widget, returnData));
|
|
|
}
|
|
|
|
|
|
QRect PythonQtWrapper_QMotifStyle::subControlRect(QMotifStyle* theWrappedObject, QStyle::ComplexControl cc, const QStyleOptionComplex* opt, QStyle::SubControl sc, const QWidget* widget) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QMotifStyle*)theWrappedObject)->promoted_subControlRect(cc, opt, sc, widget));
|
|
|
}
|
|
|
|
|
|
QRect PythonQtWrapper_QMotifStyle::subElementRect(QMotifStyle* theWrappedObject, QStyle::SubElement r, const QStyleOption* opt, const QWidget* widget) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QMotifStyle*)theWrappedObject)->promoted_subElementRect(r, opt, widget));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMotifStyle::timerEvent(QMotifStyle* theWrappedObject, QTimerEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMotifStyle*)theWrappedObject)->promoted_timerEvent(event));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMotifStyle::unpolish(QMotifStyle* theWrappedObject, QApplication* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMotifStyle*)theWrappedObject)->promoted_unpolish(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMotifStyle::unpolish(QMotifStyle* theWrappedObject, QWidget* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMotifStyle*)theWrappedObject)->promoted_unpolish(arg__1));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMotifStyle::useHighlightColors(QMotifStyle* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->useHighlightColors());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QMouseEvent::~PythonQtShell_QMouseEvent() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
QMouseEvent* PythonQtWrapper_QMouseEvent::new_QMouseEvent(QEvent::Type type, const QPoint& pos, Qt::MouseButton button, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers)
|
|
|
{
|
|
|
return new PythonQtShell_QMouseEvent(type, pos, button, buttons, modifiers); }
|
|
|
|
|
|
QMouseEvent* PythonQtWrapper_QMouseEvent::new_QMouseEvent(QEvent::Type type, const QPoint& pos, const QPoint& globalPos, Qt::MouseButton button, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers)
|
|
|
{
|
|
|
return new PythonQtShell_QMouseEvent(type, pos, globalPos, button, buttons, modifiers); }
|
|
|
|
|
|
Qt::MouseButton PythonQtWrapper_QMouseEvent::button(QMouseEvent* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->button());
|
|
|
}
|
|
|
|
|
|
Qt::MouseButtons PythonQtWrapper_QMouseEvent::buttons(QMouseEvent* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->buttons());
|
|
|
}
|
|
|
|
|
|
QMouseEvent* PythonQtWrapper_QMouseEvent::static_QMouseEvent_createExtendedMouseEvent(QEvent::Type type, const QPointF& pos, const QPoint& globalPos, Qt::MouseButton button, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers)
|
|
|
{
|
|
|
return (QMouseEvent::createExtendedMouseEvent(type, pos, globalPos, button, buttons, modifiers));
|
|
|
}
|
|
|
|
|
|
const QPoint* PythonQtWrapper_QMouseEvent::globalPos(QMouseEvent* theWrappedObject) const
|
|
|
{
|
|
|
return &( theWrappedObject->globalPos());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QMouseEvent::globalX(QMouseEvent* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->globalX());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QMouseEvent::globalY(QMouseEvent* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->globalY());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMouseEvent::hasExtendedInfo(QMouseEvent* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->hasExtendedInfo());
|
|
|
}
|
|
|
|
|
|
const QPoint* PythonQtWrapper_QMouseEvent::pos(QMouseEvent* theWrappedObject) const
|
|
|
{
|
|
|
return &( theWrappedObject->pos());
|
|
|
}
|
|
|
|
|
|
QPointF PythonQtWrapper_QMouseEvent::posF(QMouseEvent* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->posF());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QMouseEvent::x(QMouseEvent* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->x());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QMouseEvent::y(QMouseEvent* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->y());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QMouseEventTransition::~PythonQtShell_QMouseEventTransition() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QMouseEventTransition::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMouseEventTransition::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMouseEventTransition::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMouseEventTransition::customEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QMouseEventTransition::event(QEvent* e)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMouseEventTransition::event(e);
|
|
|
}
|
|
|
bool PythonQtShell_QMouseEventTransition::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 char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMouseEventTransition::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
bool PythonQtShell_QMouseEventTransition::eventTest(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventTest");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventTest", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMouseEventTransition::eventTest(event);
|
|
|
}
|
|
|
void PythonQtShell_QMouseEventTransition::onTransition(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "onTransition");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMouseEventTransition::onTransition(event);
|
|
|
}
|
|
|
void PythonQtShell_QMouseEventTransition::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMouseEventTransition::timerEvent(arg__1);
|
|
|
}
|
|
|
QMouseEventTransition* PythonQtWrapper_QMouseEventTransition::new_QMouseEventTransition(QObject* object, QEvent::Type type, Qt::MouseButton button, QState* sourceState)
|
|
|
{
|
|
|
return new PythonQtShell_QMouseEventTransition(object, type, button, sourceState); }
|
|
|
|
|
|
QMouseEventTransition* PythonQtWrapper_QMouseEventTransition::new_QMouseEventTransition(QState* sourceState)
|
|
|
{
|
|
|
return new PythonQtShell_QMouseEventTransition(sourceState); }
|
|
|
|
|
|
Qt::MouseButton PythonQtWrapper_QMouseEventTransition::button(QMouseEventTransition* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->button());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMouseEventTransition::eventTest(QMouseEventTransition* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QMouseEventTransition*)theWrappedObject)->promoted_eventTest(event));
|
|
|
}
|
|
|
|
|
|
QPainterPath PythonQtWrapper_QMouseEventTransition::hitTestPath(QMouseEventTransition* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->hitTestPath());
|
|
|
}
|
|
|
|
|
|
Qt::KeyboardModifiers PythonQtWrapper_QMouseEventTransition::modifierMask(QMouseEventTransition* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->modifierMask());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMouseEventTransition::onTransition(QMouseEventTransition* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QMouseEventTransition*)theWrappedObject)->promoted_onTransition(event));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMouseEventTransition::setButton(QMouseEventTransition* theWrappedObject, Qt::MouseButton button)
|
|
|
{
|
|
|
( theWrappedObject->setButton(button));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMouseEventTransition::setHitTestPath(QMouseEventTransition* theWrappedObject, const QPainterPath& path)
|
|
|
{
|
|
|
( theWrappedObject->setHitTestPath(path));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMouseEventTransition::setModifierMask(QMouseEventTransition* theWrappedObject, Qt::KeyboardModifiers modifiers)
|
|
|
{
|
|
|
( theWrappedObject->setModifierMask(modifiers));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QMoveEvent::~PythonQtShell_QMoveEvent() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
QMoveEvent* PythonQtWrapper_QMoveEvent::new_QMoveEvent(const QPoint& pos, const QPoint& oldPos)
|
|
|
{
|
|
|
return new PythonQtShell_QMoveEvent(pos, oldPos); }
|
|
|
|
|
|
const QPoint* PythonQtWrapper_QMoveEvent::oldPos(QMoveEvent* theWrappedObject) const
|
|
|
{
|
|
|
return &( theWrappedObject->oldPos());
|
|
|
}
|
|
|
|
|
|
const QPoint* PythonQtWrapper_QMoveEvent::pos(QMoveEvent* theWrappedObject) const
|
|
|
{
|
|
|
return &( theWrappedObject->pos());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QMovie::~PythonQtShell_QMovie() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QMovie::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMovie::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QMovie::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMovie::customEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QMovie::event(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMovie::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QMovie::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 char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QMovie::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QMovie::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QMovie::timerEvent(arg__1);
|
|
|
}
|
|
|
QMovie* PythonQtWrapper_QMovie::new_QMovie(QIODevice* device, const QByteArray& format, QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QMovie(device, format, parent); }
|
|
|
|
|
|
QMovie* PythonQtWrapper_QMovie::new_QMovie(QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QMovie(parent); }
|
|
|
|
|
|
QMovie* PythonQtWrapper_QMovie::new_QMovie(const QString& fileName, const QByteArray& format, QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QMovie(fileName, format, parent); }
|
|
|
|
|
|
QColor PythonQtWrapper_QMovie::backgroundColor(QMovie* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->backgroundColor());
|
|
|
}
|
|
|
|
|
|
QMovie::CacheMode PythonQtWrapper_QMovie::cacheMode(QMovie* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->cacheMode());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QMovie::currentFrameNumber(QMovie* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->currentFrameNumber());
|
|
|
}
|
|
|
|
|
|
QImage PythonQtWrapper_QMovie::currentImage(QMovie* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->currentImage());
|
|
|
}
|
|
|
|
|
|
QPixmap PythonQtWrapper_QMovie::currentPixmap(QMovie* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->currentPixmap());
|
|
|
}
|
|
|
|
|
|
QIODevice* PythonQtWrapper_QMovie::device(QMovie* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->device());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QMovie::fileName(QMovie* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->fileName());
|
|
|
}
|
|
|
|
|
|
QByteArray PythonQtWrapper_QMovie::format(QMovie* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->format());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QMovie::frameCount(QMovie* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->frameCount());
|
|
|
}
|
|
|
|
|
|
QRect PythonQtWrapper_QMovie::frameRect(QMovie* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->frameRect());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMovie::isValid(QMovie* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isValid());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMovie::jumpToFrame(QMovie* theWrappedObject, int frameNumber)
|
|
|
{
|
|
|
return ( theWrappedObject->jumpToFrame(frameNumber));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QMovie::loopCount(QMovie* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->loopCount());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QMovie::nextFrameDelay(QMovie* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->nextFrameDelay());
|
|
|
}
|
|
|
|
|
|
QSize PythonQtWrapper_QMovie::scaledSize(QMovie* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->scaledSize());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMovie::setBackgroundColor(QMovie* theWrappedObject, const QColor& color)
|
|
|
{
|
|
|
( theWrappedObject->setBackgroundColor(color));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMovie::setCacheMode(QMovie* theWrappedObject, QMovie::CacheMode mode)
|
|
|
{
|
|
|
( theWrappedObject->setCacheMode(mode));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMovie::setDevice(QMovie* theWrappedObject, QIODevice* device)
|
|
|
{
|
|
|
( theWrappedObject->setDevice(device));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMovie::setFileName(QMovie* theWrappedObject, const QString& fileName)
|
|
|
{
|
|
|
( theWrappedObject->setFileName(fileName));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMovie::setFormat(QMovie* theWrappedObject, const QByteArray& format)
|
|
|
{
|
|
|
( theWrappedObject->setFormat(format));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMovie::setScaledSize(QMovie* theWrappedObject, const QSize& size)
|
|
|
{
|
|
|
( theWrappedObject->setScaledSize(size));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QMovie::speed(QMovie* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->speed());
|
|
|
}
|
|
|
|
|
|
QMovie::MovieState PythonQtWrapper_QMovie::state(QMovie* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->state());
|
|
|
}
|
|
|
|
|
|
QList<QByteArray > PythonQtWrapper_QMovie::static_QMovie_supportedFormats()
|
|
|
{
|
|
|
return (QMovie::supportedFormats());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QPageSetupDialog::~PythonQtShell_QPageSetupDialog() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::accept()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "accept");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::accept();
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::actionEvent(QActionEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QActionEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::actionEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::changeEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::changeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::closeEvent(QCloseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QCloseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::closeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::contextMenuEvent(QContextMenuEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QContextMenuEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::contextMenuEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::customEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QPageSetupDialog::devType() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QPageSetupDialog::devType();
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::done(int result)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "done");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&result};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::done(result);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::dragEnterEvent(QDragEnterEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragEnterEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::dragEnterEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::dragLeaveEvent(QDragLeaveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::dragLeaveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::dragMoveEvent(QDragMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDragMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::dragMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::dropEvent(QDropEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QDropEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::dropEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::enterEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::enterEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QPageSetupDialog::event(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QPageSetupDialog::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QPageSetupDialog::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 char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QPageSetupDialog::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
int PythonQtShell_QPageSetupDialog::exec()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "exec");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("exec", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QPageSetupDialog::exec();
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::focusInEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::focusInEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QPageSetupDialog::focusNextPrevChild(bool next)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QPageSetupDialog::focusNextPrevChild(next);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::focusOutEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::focusOutEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QPageSetupDialog::heightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QPageSetupDialog::heightForWidth(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::hideEvent(QHideEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QHideEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::hideEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::inputMethodEvent(QInputMethodEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QInputMethodEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::inputMethodEvent(arg__1);
|
|
|
}
|
|
|
QVariant PythonQtShell_QPageSetupDialog::inputMethodQuery(Qt::InputMethodQuery arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QVariant returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QVariant*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QPageSetupDialog::inputMethodQuery(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::keyPressEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::keyPressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::keyReleaseEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::keyReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::languageChange()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "languageChange");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::languageChange();
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::leaveEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::leaveEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QPageSetupDialog::metric(QPaintDevice::PaintDeviceMetric arg__1) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QPageSetupDialog::metric(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::mouseDoubleClickEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::mouseDoubleClickEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::mouseMoveEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::mouseMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::mousePressEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::mousePressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::mouseReleaseEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::mouseReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::moveEvent(QMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QMoveEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::moveEvent(arg__1);
|
|
|
}
|
|
|
QPaintEngine* PythonQtShell_QPageSetupDialog::paintEngine() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPaintEngine*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPaintEngine* 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintEngine**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QPageSetupDialog::paintEngine();
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::paintEvent(QPaintEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QPaintEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::paintEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::reject()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reject");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={""};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::reject();
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::resizeEvent(QResizeEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QResizeEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::resizeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::showEvent(QShowEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QShowEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::showEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::tabletEvent(QTabletEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTabletEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::tabletEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::timerEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPageSetupDialog::wheelEvent(QWheelEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QWheelEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPageSetupDialog::wheelEvent(arg__1);
|
|
|
}
|
|
|
QPageSetupDialog* PythonQtWrapper_QPageSetupDialog::new_QPageSetupDialog(QPrinter* printer, QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QPageSetupDialog(printer, parent); }
|
|
|
|
|
|
QPageSetupDialog* PythonQtWrapper_QPageSetupDialog::new_QPageSetupDialog(QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QPageSetupDialog(parent); }
|
|
|
|
|
|
void PythonQtWrapper_QPageSetupDialog::addEnabledOption(QPageSetupDialog* theWrappedObject, QPageSetupDialog::PageSetupDialogOption option)
|
|
|
{
|
|
|
( theWrappedObject->addEnabledOption(option));
|
|
|
}
|
|
|
|
|
|
QPageSetupDialog::PageSetupDialogOptions PythonQtWrapper_QPageSetupDialog::enabledOptions(QPageSetupDialog* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->enabledOptions());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QPageSetupDialog::exec(QPageSetupDialog* theWrappedObject)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QPageSetupDialog*)theWrappedObject)->promoted_exec());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPageSetupDialog::isOptionEnabled(QPageSetupDialog* theWrappedObject, QPageSetupDialog::PageSetupDialogOption option) const
|
|
|
{
|
|
|
return ( theWrappedObject->isOptionEnabled(option));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPageSetupDialog::open(QPageSetupDialog* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->open());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPageSetupDialog::open(QPageSetupDialog* theWrappedObject, QObject* receiver, const char* member)
|
|
|
{
|
|
|
( theWrappedObject->open(receiver, member));
|
|
|
}
|
|
|
|
|
|
QPageSetupDialog::PageSetupDialogOptions PythonQtWrapper_QPageSetupDialog::options(QPageSetupDialog* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->options());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPageSetupDialog::setEnabledOptions(QPageSetupDialog* theWrappedObject, QPageSetupDialog::PageSetupDialogOptions options)
|
|
|
{
|
|
|
( theWrappedObject->setEnabledOptions(options));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPageSetupDialog::setOption(QPageSetupDialog* theWrappedObject, QPageSetupDialog::PageSetupDialogOption option, bool on)
|
|
|
{
|
|
|
( theWrappedObject->setOption(option, on));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPageSetupDialog::setOptions(QPageSetupDialog* theWrappedObject, QPageSetupDialog::PageSetupDialogOptions options)
|
|
|
{
|
|
|
( theWrappedObject->setOptions(options));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPageSetupDialog::testOption(QPageSetupDialog* theWrappedObject, QPageSetupDialog::PageSetupDialogOption option) const
|
|
|
{
|
|
|
return ( theWrappedObject->testOption(option));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QPaintDevice::~PythonQtShell_QPaintDevice() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
int PythonQtShell_QPaintDevice::devType() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QPaintDevice::devType();
|
|
|
}
|
|
|
int PythonQtShell_QPaintDevice::metric(QPaintDevice::PaintDeviceMetric metric) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&metric};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QPaintDevice::metric(metric);
|
|
|
}
|
|
|
QPaintEngine* PythonQtShell_QPaintDevice::paintEngine() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPaintEngine*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPaintEngine* 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintEngine**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
QPaintDevice* PythonQtWrapper_QPaintDevice::new_QPaintDevice()
|
|
|
{
|
|
|
return new PythonQtShell_QPaintDevice(); }
|
|
|
|
|
|
int PythonQtWrapper_QPaintDevice::colorCount(QPaintDevice* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->colorCount());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QPaintDevice::depth(QPaintDevice* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->depth());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QPaintDevice::devType(QPaintDevice* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QPaintDevice*)theWrappedObject)->promoted_devType());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QPaintDevice::height(QPaintDevice* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->height());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QPaintDevice::heightMM(QPaintDevice* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->heightMM());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QPaintDevice::logicalDpiX(QPaintDevice* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->logicalDpiX());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QPaintDevice::logicalDpiY(QPaintDevice* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->logicalDpiY());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QPaintDevice::metric(QPaintDevice* theWrappedObject, QPaintDevice::PaintDeviceMetric metric) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QPaintDevice*)theWrappedObject)->promoted_metric(metric));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QPaintDevice::numColors(QPaintDevice* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->numColors());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPaintDevice::paintingActive(QPaintDevice* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->paintingActive());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QPaintDevice::physicalDpiX(QPaintDevice* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->physicalDpiX());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QPaintDevice::physicalDpiY(QPaintDevice* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->physicalDpiY());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QPaintDevice::width(QPaintDevice* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->width());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QPaintDevice::widthMM(QPaintDevice* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->widthMM());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QPaintEngine::~PythonQtShell_QPaintEngine() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
bool PythonQtShell_QPaintEngine::begin(QPaintDevice* pdev)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "begin");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QPaintDevice*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&pdev};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("begin", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return bool();
|
|
|
}
|
|
|
QPoint PythonQtShell_QPaintEngine::coordinateOffset() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "coordinateOffset");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPoint"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPoint 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("coordinateOffset", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPoint*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QPaintEngine::coordinateOffset();
|
|
|
}
|
|
|
void PythonQtShell_QPaintEngine::drawEllipse(const QRect& r)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawEllipse");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QRect&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&r};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPaintEngine::drawEllipse(r);
|
|
|
}
|
|
|
void PythonQtShell_QPaintEngine::drawEllipse(const QRectF& r)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawEllipse");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QRectF&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&r};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPaintEngine::drawEllipse(r);
|
|
|
}
|
|
|
void PythonQtShell_QPaintEngine::drawImage(const QRectF& r, const QImage& pm, const QRectF& sr, Qt::ImageConversionFlags flags)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawImage");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QRectF&" , "const QImage&" , "const QRectF&" , "Qt::ImageConversionFlags"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
|
|
|
void* args[5] = {NULL, (void*)&r, (void*)&pm, (void*)&sr, (void*)&flags};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPaintEngine::drawImage(r, pm, sr, flags);
|
|
|
}
|
|
|
void PythonQtShell_QPaintEngine::drawLines(const QLine* lines, int lineCount)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawLines");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QLine*" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&lines, (void*)&lineCount};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPaintEngine::drawLines(lines, lineCount);
|
|
|
}
|
|
|
void PythonQtShell_QPaintEngine::drawLines(const QLineF* lines, int lineCount)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawLines");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QLineF*" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&lines, (void*)&lineCount};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPaintEngine::drawLines(lines, lineCount);
|
|
|
}
|
|
|
void PythonQtShell_QPaintEngine::drawPath(const QPainterPath& path)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawPath");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QPainterPath&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&path};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPaintEngine::drawPath(path);
|
|
|
}
|
|
|
void PythonQtShell_QPaintEngine::drawPixmap(const QRectF& r, const QPixmap& pm, const QRectF& sr)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawPixmap");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QRectF&" , "const QPixmap&" , "const QRectF&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
void* args[4] = {NULL, (void*)&r, (void*)&pm, (void*)&sr};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
void PythonQtShell_QPaintEngine::drawPoints(const QPoint* points, int pointCount)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawPoints");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QPoint*" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&points, (void*)&pointCount};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPaintEngine::drawPoints(points, pointCount);
|
|
|
}
|
|
|
void PythonQtShell_QPaintEngine::drawPoints(const QPointF* points, int pointCount)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawPoints");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QPointF*" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&points, (void*)&pointCount};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPaintEngine::drawPoints(points, pointCount);
|
|
|
}
|
|
|
void PythonQtShell_QPaintEngine::drawPolygon(const QPoint* points, int pointCount, QPaintEngine::PolygonDrawMode mode)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawPolygon");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QPoint*" , "int" , "QPaintEngine::PolygonDrawMode"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
void* args[4] = {NULL, (void*)&points, (void*)&pointCount, (void*)&mode};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPaintEngine::drawPolygon(points, pointCount, mode);
|
|
|
}
|
|
|
void PythonQtShell_QPaintEngine::drawPolygon(const QPointF* points, int pointCount, QPaintEngine::PolygonDrawMode mode)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawPolygon");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QPointF*" , "int" , "QPaintEngine::PolygonDrawMode"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
void* args[4] = {NULL, (void*)&points, (void*)&pointCount, (void*)&mode};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPaintEngine::drawPolygon(points, pointCount, mode);
|
|
|
}
|
|
|
void PythonQtShell_QPaintEngine::drawRects(const QRect* rects, int rectCount)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawRects");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QRect*" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&rects, (void*)&rectCount};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPaintEngine::drawRects(rects, rectCount);
|
|
|
}
|
|
|
void PythonQtShell_QPaintEngine::drawRects(const QRectF* rects, int rectCount)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawRects");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QRectF*" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&rects, (void*)&rectCount};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPaintEngine::drawRects(rects, rectCount);
|
|
|
}
|
|
|
void PythonQtShell_QPaintEngine::drawTextItem(const QPointF& p, const QTextItem& textItem)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawTextItem");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QPointF&" , "const QTextItem&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&p, (void*)&textItem};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPaintEngine::drawTextItem(p, textItem);
|
|
|
}
|
|
|
void PythonQtShell_QPaintEngine::drawTiledPixmap(const QRectF& r, const QPixmap& pixmap, const QPointF& s)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawTiledPixmap");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QRectF&" , "const QPixmap&" , "const QPointF&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
void* args[4] = {NULL, (void*)&r, (void*)&pixmap, (void*)&s};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPaintEngine::drawTiledPixmap(r, pixmap, s);
|
|
|
}
|
|
|
bool PythonQtShell_QPaintEngine::end()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "end");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
bool 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("end", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return bool();
|
|
|
}
|
|
|
QPaintEngine::Type PythonQtShell_QPaintEngine::type() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "type");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPaintEngine::Type"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPaintEngine::Type 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("type", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintEngine::Type*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QPaintEngine::Type();
|
|
|
}
|
|
|
void PythonQtShell_QPaintEngine::updateState(const QPaintEngineState& state)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateState");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QPaintEngineState&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&state};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
QPaintEngine* PythonQtWrapper_QPaintEngine::new_QPaintEngine(QPaintEngine::PaintEngineFeatures features)
|
|
|
{
|
|
|
return new PythonQtShell_QPaintEngine(features); }
|
|
|
|
|
|
void PythonQtWrapper_QPaintEngine::clearDirty(QPaintEngine* theWrappedObject, QPaintEngine::DirtyFlags df)
|
|
|
{
|
|
|
( theWrappedObject->clearDirty(df));
|
|
|
}
|
|
|
|
|
|
QPoint PythonQtWrapper_QPaintEngine::coordinateOffset(QPaintEngine* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QPaintEngine*)theWrappedObject)->promoted_coordinateOffset());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPaintEngine::drawEllipse(QPaintEngine* theWrappedObject, const QRect& r)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QPaintEngine*)theWrappedObject)->promoted_drawEllipse(r));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPaintEngine::drawEllipse(QPaintEngine* theWrappedObject, const QRectF& r)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QPaintEngine*)theWrappedObject)->promoted_drawEllipse(r));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPaintEngine::drawImage(QPaintEngine* theWrappedObject, const QRectF& r, const QImage& pm, const QRectF& sr, Qt::ImageConversionFlags flags)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QPaintEngine*)theWrappedObject)->promoted_drawImage(r, pm, sr, flags));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPaintEngine::drawLines(QPaintEngine* theWrappedObject, const QLine* lines, int lineCount)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QPaintEngine*)theWrappedObject)->promoted_drawLines(lines, lineCount));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPaintEngine::drawLines(QPaintEngine* theWrappedObject, const QLineF* lines, int lineCount)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QPaintEngine*)theWrappedObject)->promoted_drawLines(lines, lineCount));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPaintEngine::drawPath(QPaintEngine* theWrappedObject, const QPainterPath& path)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QPaintEngine*)theWrappedObject)->promoted_drawPath(path));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPaintEngine::drawPoints(QPaintEngine* theWrappedObject, const QPoint* points, int pointCount)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QPaintEngine*)theWrappedObject)->promoted_drawPoints(points, pointCount));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPaintEngine::drawPoints(QPaintEngine* theWrappedObject, const QPointF* points, int pointCount)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QPaintEngine*)theWrappedObject)->promoted_drawPoints(points, pointCount));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPaintEngine::drawPolygon(QPaintEngine* theWrappedObject, const QPoint* points, int pointCount, QPaintEngine::PolygonDrawMode mode)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QPaintEngine*)theWrappedObject)->promoted_drawPolygon(points, pointCount, mode));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPaintEngine::drawPolygon(QPaintEngine* theWrappedObject, const QPointF* points, int pointCount, QPaintEngine::PolygonDrawMode mode)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QPaintEngine*)theWrappedObject)->promoted_drawPolygon(points, pointCount, mode));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPaintEngine::drawRects(QPaintEngine* theWrappedObject, const QRect* rects, int rectCount)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QPaintEngine*)theWrappedObject)->promoted_drawRects(rects, rectCount));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPaintEngine::drawRects(QPaintEngine* theWrappedObject, const QRectF* rects, int rectCount)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QPaintEngine*)theWrappedObject)->promoted_drawRects(rects, rectCount));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPaintEngine::drawTextItem(QPaintEngine* theWrappedObject, const QPointF& p, const QTextItem& textItem)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QPaintEngine*)theWrappedObject)->promoted_drawTextItem(p, textItem));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPaintEngine::drawTiledPixmap(QPaintEngine* theWrappedObject, const QRectF& r, const QPixmap& pixmap, const QPointF& s)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QPaintEngine*)theWrappedObject)->promoted_drawTiledPixmap(r, pixmap, s));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPaintEngine::hasFeature(QPaintEngine* theWrappedObject, QPaintEngine::PaintEngineFeatures feature) const
|
|
|
{
|
|
|
return ( theWrappedObject->hasFeature(feature));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPaintEngine::isActive(QPaintEngine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isActive());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPaintEngine::isExtended(QPaintEngine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isExtended());
|
|
|
}
|
|
|
|
|
|
QPaintDevice* PythonQtWrapper_QPaintEngine::paintDevice(QPaintEngine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->paintDevice());
|
|
|
}
|
|
|
|
|
|
QPainter* PythonQtWrapper_QPaintEngine::painter(QPaintEngine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->painter());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPaintEngine::setActive(QPaintEngine* theWrappedObject, bool newState)
|
|
|
{
|
|
|
( theWrappedObject->setActive(newState));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPaintEngine::setDirty(QPaintEngine* theWrappedObject, QPaintEngine::DirtyFlags df)
|
|
|
{
|
|
|
( theWrappedObject->setDirty(df));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPaintEngine::setSystemClip(QPaintEngine* theWrappedObject, const QRegion& baseClip)
|
|
|
{
|
|
|
( theWrappedObject->setSystemClip(baseClip));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPaintEngine::setSystemRect(QPaintEngine* theWrappedObject, const QRect& rect)
|
|
|
{
|
|
|
( theWrappedObject->setSystemRect(rect));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPaintEngine::syncState(QPaintEngine* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->syncState());
|
|
|
}
|
|
|
|
|
|
QRegion PythonQtWrapper_QPaintEngine::systemClip(QPaintEngine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->systemClip());
|
|
|
}
|
|
|
|
|
|
QRect PythonQtWrapper_QPaintEngine::systemRect(QPaintEngine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->systemRect());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPaintEngine::testDirty(QPaintEngine* theWrappedObject, QPaintEngine::DirtyFlags df)
|
|
|
{
|
|
|
return ( theWrappedObject->testDirty(df));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QPaintEngineState::~PythonQtShell_QPaintEngineState() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
QPaintEngineState* PythonQtWrapper_QPaintEngineState::new_QPaintEngineState()
|
|
|
{
|
|
|
return new PythonQtShell_QPaintEngineState(); }
|
|
|
|
|
|
QBrush PythonQtWrapper_QPaintEngineState::backgroundBrush(QPaintEngineState* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->backgroundBrush());
|
|
|
}
|
|
|
|
|
|
Qt::BGMode PythonQtWrapper_QPaintEngineState::backgroundMode(QPaintEngineState* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->backgroundMode());
|
|
|
}
|
|
|
|
|
|
QBrush PythonQtWrapper_QPaintEngineState::brush(QPaintEngineState* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->brush());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPaintEngineState::brushNeedsResolving(QPaintEngineState* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->brushNeedsResolving());
|
|
|
}
|
|
|
|
|
|
QPointF PythonQtWrapper_QPaintEngineState::brushOrigin(QPaintEngineState* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->brushOrigin());
|
|
|
}
|
|
|
|
|
|
Qt::ClipOperation PythonQtWrapper_QPaintEngineState::clipOperation(QPaintEngineState* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->clipOperation());
|
|
|
}
|
|
|
|
|
|
QPainterPath PythonQtWrapper_QPaintEngineState::clipPath(QPaintEngineState* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->clipPath());
|
|
|
}
|
|
|
|
|
|
QRegion PythonQtWrapper_QPaintEngineState::clipRegion(QPaintEngineState* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->clipRegion());
|
|
|
}
|
|
|
|
|
|
QPainter::CompositionMode PythonQtWrapper_QPaintEngineState::compositionMode(QPaintEngineState* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->compositionMode());
|
|
|
}
|
|
|
|
|
|
QFont PythonQtWrapper_QPaintEngineState::font(QPaintEngineState* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->font());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPaintEngineState::isClipEnabled(QPaintEngineState* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isClipEnabled());
|
|
|
}
|
|
|
|
|
|
QMatrix PythonQtWrapper_QPaintEngineState::matrix(QPaintEngineState* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->matrix());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QPaintEngineState::opacity(QPaintEngineState* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->opacity());
|
|
|
}
|
|
|
|
|
|
QPainter* PythonQtWrapper_QPaintEngineState::painter(QPaintEngineState* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->painter());
|
|
|
}
|
|
|
|
|
|
QPen PythonQtWrapper_QPaintEngineState::pen(QPaintEngineState* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->pen());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPaintEngineState::penNeedsResolving(QPaintEngineState* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->penNeedsResolving());
|
|
|
}
|
|
|
|
|
|
QPainter::RenderHints PythonQtWrapper_QPaintEngineState::renderHints(QPaintEngineState* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->renderHints());
|
|
|
}
|
|
|
|
|
|
QPaintEngine::DirtyFlags PythonQtWrapper_QPaintEngineState::state(QPaintEngineState* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->state());
|
|
|
}
|
|
|
|
|
|
QTransform PythonQtWrapper_QPaintEngineState::transform(QPaintEngineState* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->transform());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QPaintEvent::~PythonQtShell_QPaintEvent() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
QPaintEvent* PythonQtWrapper_QPaintEvent::new_QPaintEvent(const QRect& paintRect)
|
|
|
{
|
|
|
return new PythonQtShell_QPaintEvent(paintRect); }
|
|
|
|
|
|
QPaintEvent* PythonQtWrapper_QPaintEvent::new_QPaintEvent(const QRegion& paintRegion)
|
|
|
{
|
|
|
return new PythonQtShell_QPaintEvent(paintRegion); }
|
|
|
|
|
|
const QRect* PythonQtWrapper_QPaintEvent::rect(QPaintEvent* theWrappedObject) const
|
|
|
{
|
|
|
return &( theWrappedObject->rect());
|
|
|
}
|
|
|
|
|
|
const QRegion* PythonQtWrapper_QPaintEvent::region(QPaintEvent* theWrappedObject) const
|
|
|
{
|
|
|
return &( theWrappedObject->region());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QPainter* PythonQtWrapper_QPainter::new_QPainter()
|
|
|
{
|
|
|
return new QPainter(); }
|
|
|
|
|
|
QPainter* PythonQtWrapper_QPainter::new_QPainter(QPaintDevice* arg__1)
|
|
|
{
|
|
|
return new QPainter(arg__1); }
|
|
|
|
|
|
const QBrush* PythonQtWrapper_QPainter::background(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return &( theWrappedObject->background());
|
|
|
}
|
|
|
|
|
|
Qt::BGMode PythonQtWrapper_QPainter::backgroundMode(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->backgroundMode());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPainter::begin(QPainter* theWrappedObject, QPaintDevice* arg__1)
|
|
|
{
|
|
|
return ( theWrappedObject->begin(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::beginNativePainting(QPainter* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->beginNativePainting());
|
|
|
}
|
|
|
|
|
|
QRect PythonQtWrapper_QPainter::boundingRect(QPainter* theWrappedObject, const QRect& rect, int flags, const QString& text)
|
|
|
{
|
|
|
return ( theWrappedObject->boundingRect(rect, flags, text));
|
|
|
}
|
|
|
|
|
|
QRectF PythonQtWrapper_QPainter::boundingRect(QPainter* theWrappedObject, const QRectF& rect, const QString& text, const QTextOption& o)
|
|
|
{
|
|
|
return ( theWrappedObject->boundingRect(rect, text, o));
|
|
|
}
|
|
|
|
|
|
QRectF PythonQtWrapper_QPainter::boundingRect(QPainter* theWrappedObject, const QRectF& rect, int flags, const QString& text)
|
|
|
{
|
|
|
return ( theWrappedObject->boundingRect(rect, flags, text));
|
|
|
}
|
|
|
|
|
|
QRect PythonQtWrapper_QPainter::boundingRect(QPainter* theWrappedObject, int x, int y, int w, int h, int flags, const QString& text)
|
|
|
{
|
|
|
return ( theWrappedObject->boundingRect(x, y, w, h, flags, text));
|
|
|
}
|
|
|
|
|
|
const QBrush* PythonQtWrapper_QPainter::brush(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return &( theWrappedObject->brush());
|
|
|
}
|
|
|
|
|
|
QPoint PythonQtWrapper_QPainter::brushOrigin(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->brushOrigin());
|
|
|
}
|
|
|
|
|
|
QRectF PythonQtWrapper_QPainter::clipBoundingRect(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->clipBoundingRect());
|
|
|
}
|
|
|
|
|
|
QPainterPath PythonQtWrapper_QPainter::clipPath(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->clipPath());
|
|
|
}
|
|
|
|
|
|
QRegion PythonQtWrapper_QPainter::clipRegion(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->clipRegion());
|
|
|
}
|
|
|
|
|
|
QMatrix PythonQtWrapper_QPainter::combinedMatrix(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->combinedMatrix());
|
|
|
}
|
|
|
|
|
|
QTransform PythonQtWrapper_QPainter::combinedTransform(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->combinedTransform());
|
|
|
}
|
|
|
|
|
|
QPainter::CompositionMode PythonQtWrapper_QPainter::compositionMode(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->compositionMode());
|
|
|
}
|
|
|
|
|
|
QPaintDevice* PythonQtWrapper_QPainter::device(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->device());
|
|
|
}
|
|
|
|
|
|
const QMatrix* PythonQtWrapper_QPainter::deviceMatrix(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return &( theWrappedObject->deviceMatrix());
|
|
|
}
|
|
|
|
|
|
const QTransform* PythonQtWrapper_QPainter::deviceTransform(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return &( theWrappedObject->deviceTransform());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawArc(QPainter* theWrappedObject, const QRect& arg__1, int a, int alen)
|
|
|
{
|
|
|
( theWrappedObject->drawArc(arg__1, a, alen));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawArc(QPainter* theWrappedObject, const QRectF& rect, int a, int alen)
|
|
|
{
|
|
|
( theWrappedObject->drawArc(rect, a, alen));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawArc(QPainter* theWrappedObject, int x, int y, int w, int h, int a, int alen)
|
|
|
{
|
|
|
( theWrappedObject->drawArc(x, y, w, h, a, alen));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawChord(QPainter* theWrappedObject, const QRect& arg__1, int a, int alen)
|
|
|
{
|
|
|
( theWrappedObject->drawChord(arg__1, a, alen));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawChord(QPainter* theWrappedObject, const QRectF& rect, int a, int alen)
|
|
|
{
|
|
|
( theWrappedObject->drawChord(rect, a, alen));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawChord(QPainter* theWrappedObject, int x, int y, int w, int h, int a, int alen)
|
|
|
{
|
|
|
( theWrappedObject->drawChord(x, y, w, h, a, alen));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawConvexPolygon(QPainter* theWrappedObject, const QPolygon& polygon)
|
|
|
{
|
|
|
( theWrappedObject->drawConvexPolygon(polygon));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawConvexPolygon(QPainter* theWrappedObject, const QPolygonF& polygon)
|
|
|
{
|
|
|
( theWrappedObject->drawConvexPolygon(polygon));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawEllipse(QPainter* theWrappedObject, const QPoint& center, int rx, int ry)
|
|
|
{
|
|
|
( theWrappedObject->drawEllipse(center, rx, ry));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawEllipse(QPainter* theWrappedObject, const QPointF& center, qreal rx, qreal ry)
|
|
|
{
|
|
|
( theWrappedObject->drawEllipse(center, rx, ry));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawEllipse(QPainter* theWrappedObject, const QRect& r)
|
|
|
{
|
|
|
( theWrappedObject->drawEllipse(r));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawEllipse(QPainter* theWrappedObject, const QRectF& r)
|
|
|
{
|
|
|
( theWrappedObject->drawEllipse(r));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawEllipse(QPainter* theWrappedObject, int x, int y, int w, int h)
|
|
|
{
|
|
|
( theWrappedObject->drawEllipse(x, y, w, h));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawImage(QPainter* theWrappedObject, const QPoint& p, const QImage& image)
|
|
|
{
|
|
|
( theWrappedObject->drawImage(p, image));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawImage(QPainter* theWrappedObject, const QPoint& p, const QImage& image, const QRect& sr, Qt::ImageConversionFlags flags)
|
|
|
{
|
|
|
( theWrappedObject->drawImage(p, image, sr, flags));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawImage(QPainter* theWrappedObject, const QPointF& p, const QImage& image)
|
|
|
{
|
|
|
( theWrappedObject->drawImage(p, image));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawImage(QPainter* theWrappedObject, const QPointF& p, const QImage& image, const QRectF& sr, Qt::ImageConversionFlags flags)
|
|
|
{
|
|
|
( theWrappedObject->drawImage(p, image, sr, flags));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawImage(QPainter* theWrappedObject, const QRect& r, const QImage& image)
|
|
|
{
|
|
|
( theWrappedObject->drawImage(r, image));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawImage(QPainter* theWrappedObject, const QRect& targetRect, const QImage& image, const QRect& sourceRect, Qt::ImageConversionFlags flags)
|
|
|
{
|
|
|
( theWrappedObject->drawImage(targetRect, image, sourceRect, flags));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawImage(QPainter* theWrappedObject, const QRectF& r, const QImage& image)
|
|
|
{
|
|
|
( theWrappedObject->drawImage(r, image));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawImage(QPainter* theWrappedObject, const QRectF& targetRect, const QImage& image, const QRectF& sourceRect, Qt::ImageConversionFlags flags)
|
|
|
{
|
|
|
( theWrappedObject->drawImage(targetRect, image, sourceRect, flags));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawImage(QPainter* theWrappedObject, int x, int y, const QImage& image, int sx, int sy, int sw, int sh, Qt::ImageConversionFlags flags)
|
|
|
{
|
|
|
( theWrappedObject->drawImage(x, y, image, sx, sy, sw, sh, flags));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawLine(QPainter* theWrappedObject, const QLine& line)
|
|
|
{
|
|
|
( theWrappedObject->drawLine(line));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawLine(QPainter* theWrappedObject, const QLineF& line)
|
|
|
{
|
|
|
( theWrappedObject->drawLine(line));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawLine(QPainter* theWrappedObject, const QPoint& p1, const QPoint& p2)
|
|
|
{
|
|
|
( theWrappedObject->drawLine(p1, p2));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawLine(QPainter* theWrappedObject, const QPointF& p1, const QPointF& p2)
|
|
|
{
|
|
|
( theWrappedObject->drawLine(p1, p2));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawLine(QPainter* theWrappedObject, int x1, int y1, int x2, int y2)
|
|
|
{
|
|
|
( theWrappedObject->drawLine(x1, y1, x2, y2));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawLines(QPainter* theWrappedObject, const QVector<QLine >& lines)
|
|
|
{
|
|
|
( theWrappedObject->drawLines(lines));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawLines(QPainter* theWrappedObject, const QVector<QLineF >& lines)
|
|
|
{
|
|
|
( theWrappedObject->drawLines(lines));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawLines(QPainter* theWrappedObject, const QVector<QPoint >& pointPairs)
|
|
|
{
|
|
|
( theWrappedObject->drawLines(pointPairs));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawLines(QPainter* theWrappedObject, const QVector<QPointF >& pointPairs)
|
|
|
{
|
|
|
( theWrappedObject->drawLines(pointPairs));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPath(QPainter* theWrappedObject, const QPainterPath& path)
|
|
|
{
|
|
|
( theWrappedObject->drawPath(path));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPicture(QPainter* theWrappedObject, const QPoint& p, const QPicture& picture)
|
|
|
{
|
|
|
( theWrappedObject->drawPicture(p, picture));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPicture(QPainter* theWrappedObject, const QPointF& p, const QPicture& picture)
|
|
|
{
|
|
|
( theWrappedObject->drawPicture(p, picture));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPicture(QPainter* theWrappedObject, int x, int y, const QPicture& picture)
|
|
|
{
|
|
|
( theWrappedObject->drawPicture(x, y, picture));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPie(QPainter* theWrappedObject, const QRect& arg__1, int a, int alen)
|
|
|
{
|
|
|
( theWrappedObject->drawPie(arg__1, a, alen));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPie(QPainter* theWrappedObject, const QRectF& rect, int a, int alen)
|
|
|
{
|
|
|
( theWrappedObject->drawPie(rect, a, alen));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPie(QPainter* theWrappedObject, int x, int y, int w, int h, int a, int alen)
|
|
|
{
|
|
|
( theWrappedObject->drawPie(x, y, w, h, a, alen));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPixmap(QPainter* theWrappedObject, const QPoint& p, const QPixmap& pm)
|
|
|
{
|
|
|
( theWrappedObject->drawPixmap(p, pm));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPixmap(QPainter* theWrappedObject, const QPoint& p, const QPixmap& pm, const QRect& sr)
|
|
|
{
|
|
|
( theWrappedObject->drawPixmap(p, pm, sr));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPixmap(QPainter* theWrappedObject, const QPointF& p, const QPixmap& pm)
|
|
|
{
|
|
|
( theWrappedObject->drawPixmap(p, pm));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPixmap(QPainter* theWrappedObject, const QPointF& p, const QPixmap& pm, const QRectF& sr)
|
|
|
{
|
|
|
( theWrappedObject->drawPixmap(p, pm, sr));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPixmap(QPainter* theWrappedObject, const QRect& r, const QPixmap& pm)
|
|
|
{
|
|
|
( theWrappedObject->drawPixmap(r, pm));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPixmap(QPainter* theWrappedObject, const QRect& targetRect, const QPixmap& pixmap, const QRect& sourceRect)
|
|
|
{
|
|
|
( theWrappedObject->drawPixmap(targetRect, pixmap, sourceRect));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPixmap(QPainter* theWrappedObject, const QRectF& targetRect, const QPixmap& pixmap, const QRectF& sourceRect)
|
|
|
{
|
|
|
( theWrappedObject->drawPixmap(targetRect, pixmap, sourceRect));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPixmap(QPainter* theWrappedObject, int x, int y, const QPixmap& pm)
|
|
|
{
|
|
|
( theWrappedObject->drawPixmap(x, y, pm));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPixmap(QPainter* theWrappedObject, int x, int y, const QPixmap& pm, int sx, int sy, int sw, int sh)
|
|
|
{
|
|
|
( theWrappedObject->drawPixmap(x, y, pm, sx, sy, sw, sh));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPixmap(QPainter* theWrappedObject, int x, int y, int w, int h, const QPixmap& pm)
|
|
|
{
|
|
|
( theWrappedObject->drawPixmap(x, y, w, h, pm));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPixmap(QPainter* theWrappedObject, int x, int y, int w, int h, const QPixmap& pm, int sx, int sy, int sw, int sh)
|
|
|
{
|
|
|
( theWrappedObject->drawPixmap(x, y, w, h, pm, sx, sy, sw, sh));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPoint(QPainter* theWrappedObject, const QPoint& p)
|
|
|
{
|
|
|
( theWrappedObject->drawPoint(p));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPoint(QPainter* theWrappedObject, const QPointF& pt)
|
|
|
{
|
|
|
( theWrappedObject->drawPoint(pt));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPoint(QPainter* theWrappedObject, int x, int y)
|
|
|
{
|
|
|
( theWrappedObject->drawPoint(x, y));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPoints(QPainter* theWrappedObject, const QPolygon& points)
|
|
|
{
|
|
|
( theWrappedObject->drawPoints(points));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPoints(QPainter* theWrappedObject, const QPolygonF& points)
|
|
|
{
|
|
|
( theWrappedObject->drawPoints(points));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPolygon(QPainter* theWrappedObject, const QPolygon& polygon, Qt::FillRule fillRule)
|
|
|
{
|
|
|
( theWrappedObject->drawPolygon(polygon, fillRule));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPolygon(QPainter* theWrappedObject, const QPolygonF& polygon, Qt::FillRule fillRule)
|
|
|
{
|
|
|
( theWrappedObject->drawPolygon(polygon, fillRule));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPolyline(QPainter* theWrappedObject, const QPolygon& polygon)
|
|
|
{
|
|
|
( theWrappedObject->drawPolyline(polygon));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawPolyline(QPainter* theWrappedObject, const QPolygonF& polyline)
|
|
|
{
|
|
|
( theWrappedObject->drawPolyline(polyline));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawRect(QPainter* theWrappedObject, const QRect& rect)
|
|
|
{
|
|
|
( theWrappedObject->drawRect(rect));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawRect(QPainter* theWrappedObject, const QRectF& rect)
|
|
|
{
|
|
|
( theWrappedObject->drawRect(rect));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawRect(QPainter* theWrappedObject, int x1, int y1, int w, int h)
|
|
|
{
|
|
|
( theWrappedObject->drawRect(x1, y1, w, h));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawRects(QPainter* theWrappedObject, const QVector<QRect >& rectangles)
|
|
|
{
|
|
|
( theWrappedObject->drawRects(rectangles));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawRects(QPainter* theWrappedObject, const QVector<QRectF >& rectangles)
|
|
|
{
|
|
|
( theWrappedObject->drawRects(rectangles));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawRoundRect(QPainter* theWrappedObject, const QRect& r, int xround, int yround)
|
|
|
{
|
|
|
( theWrappedObject->drawRoundRect(r, xround, yround));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawRoundRect(QPainter* theWrappedObject, const QRectF& r, int xround, int yround)
|
|
|
{
|
|
|
( theWrappedObject->drawRoundRect(r, xround, yround));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawRoundRect(QPainter* theWrappedObject, int x, int y, int w, int h, int arg__5, int arg__6)
|
|
|
{
|
|
|
( theWrappedObject->drawRoundRect(x, y, w, h, arg__5, arg__6));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawRoundedRect(QPainter* theWrappedObject, const QRect& rect, qreal xRadius, qreal yRadius, Qt::SizeMode mode)
|
|
|
{
|
|
|
( theWrappedObject->drawRoundedRect(rect, xRadius, yRadius, mode));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawRoundedRect(QPainter* theWrappedObject, const QRectF& rect, qreal xRadius, qreal yRadius, Qt::SizeMode mode)
|
|
|
{
|
|
|
( theWrappedObject->drawRoundedRect(rect, xRadius, yRadius, mode));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawRoundedRect(QPainter* theWrappedObject, int x, int y, int w, int h, qreal xRadius, qreal yRadius, Qt::SizeMode mode)
|
|
|
{
|
|
|
( theWrappedObject->drawRoundedRect(x, y, w, h, xRadius, yRadius, mode));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawStaticText(QPainter* theWrappedObject, const QPoint& topLeftPosition, const QStaticText& staticText)
|
|
|
{
|
|
|
( theWrappedObject->drawStaticText(topLeftPosition, staticText));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawStaticText(QPainter* theWrappedObject, const QPointF& topLeftPosition, const QStaticText& staticText)
|
|
|
{
|
|
|
( theWrappedObject->drawStaticText(topLeftPosition, staticText));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawStaticText(QPainter* theWrappedObject, int left, int top, const QStaticText& staticText)
|
|
|
{
|
|
|
( theWrappedObject->drawStaticText(left, top, staticText));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawText(QPainter* theWrappedObject, const QPoint& p, const QString& s)
|
|
|
{
|
|
|
( theWrappedObject->drawText(p, s));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawText(QPainter* theWrappedObject, const QPointF& p, const QString& s)
|
|
|
{
|
|
|
( theWrappedObject->drawText(p, s));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawText(QPainter* theWrappedObject, const QRect& r, int flags, const QString& text, QRect* br)
|
|
|
{
|
|
|
( theWrappedObject->drawText(r, flags, text, br));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawText(QPainter* theWrappedObject, const QRectF& r, const QString& text, const QTextOption& o)
|
|
|
{
|
|
|
( theWrappedObject->drawText(r, text, o));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawText(QPainter* theWrappedObject, const QRectF& r, int flags, const QString& text, QRectF* br)
|
|
|
{
|
|
|
( theWrappedObject->drawText(r, flags, text, br));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawText(QPainter* theWrappedObject, int x, int y, const QString& s)
|
|
|
{
|
|
|
( theWrappedObject->drawText(x, y, s));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawText(QPainter* theWrappedObject, int x, int y, int w, int h, int flags, const QString& text, QRect* br)
|
|
|
{
|
|
|
( theWrappedObject->drawText(x, y, w, h, flags, text, br));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawTextItem(QPainter* theWrappedObject, const QPoint& p, const QTextItem& ti)
|
|
|
{
|
|
|
( theWrappedObject->drawTextItem(p, ti));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawTextItem(QPainter* theWrappedObject, const QPointF& p, const QTextItem& ti)
|
|
|
{
|
|
|
( theWrappedObject->drawTextItem(p, ti));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawTextItem(QPainter* theWrappedObject, int x, int y, const QTextItem& ti)
|
|
|
{
|
|
|
( theWrappedObject->drawTextItem(x, y, ti));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawTiledPixmap(QPainter* theWrappedObject, const QRect& arg__1, const QPixmap& arg__2, const QPoint& arg__3)
|
|
|
{
|
|
|
( theWrappedObject->drawTiledPixmap(arg__1, arg__2, arg__3));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawTiledPixmap(QPainter* theWrappedObject, const QRectF& rect, const QPixmap& pm, const QPointF& offset)
|
|
|
{
|
|
|
( theWrappedObject->drawTiledPixmap(rect, pm, offset));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::drawTiledPixmap(QPainter* theWrappedObject, int x, int y, int w, int h, const QPixmap& arg__5, int sx, int sy)
|
|
|
{
|
|
|
( theWrappedObject->drawTiledPixmap(x, y, w, h, arg__5, sx, sy));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPainter::end(QPainter* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->end());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::endNativePainting(QPainter* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->endNativePainting());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::eraseRect(QPainter* theWrappedObject, const QRect& arg__1)
|
|
|
{
|
|
|
( theWrappedObject->eraseRect(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::eraseRect(QPainter* theWrappedObject, const QRectF& arg__1)
|
|
|
{
|
|
|
( theWrappedObject->eraseRect(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::eraseRect(QPainter* theWrappedObject, int x, int y, int w, int h)
|
|
|
{
|
|
|
( theWrappedObject->eraseRect(x, y, w, h));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::fillPath(QPainter* theWrappedObject, const QPainterPath& path, const QBrush& brush)
|
|
|
{
|
|
|
( theWrappedObject->fillPath(path, brush));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::fillRect(QPainter* theWrappedObject, const QRect& arg__1, const QBrush& arg__2)
|
|
|
{
|
|
|
( theWrappedObject->fillRect(arg__1, arg__2));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::fillRect(QPainter* theWrappedObject, const QRect& arg__1, const QColor& color)
|
|
|
{
|
|
|
( theWrappedObject->fillRect(arg__1, color));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::fillRect(QPainter* theWrappedObject, const QRect& r, Qt::BrushStyle style)
|
|
|
{
|
|
|
( theWrappedObject->fillRect(r, style));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::fillRect(QPainter* theWrappedObject, const QRect& r, Qt::GlobalColor c)
|
|
|
{
|
|
|
( theWrappedObject->fillRect(r, c));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::fillRect(QPainter* theWrappedObject, const QRectF& arg__1, const QBrush& arg__2)
|
|
|
{
|
|
|
( theWrappedObject->fillRect(arg__1, arg__2));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::fillRect(QPainter* theWrappedObject, const QRectF& arg__1, const QColor& color)
|
|
|
{
|
|
|
( theWrappedObject->fillRect(arg__1, color));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::fillRect(QPainter* theWrappedObject, const QRectF& r, Qt::BrushStyle style)
|
|
|
{
|
|
|
( theWrappedObject->fillRect(r, style));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::fillRect(QPainter* theWrappedObject, const QRectF& r, Qt::GlobalColor c)
|
|
|
{
|
|
|
( theWrappedObject->fillRect(r, c));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::fillRect(QPainter* theWrappedObject, int x, int y, int w, int h, Qt::BrushStyle style)
|
|
|
{
|
|
|
( theWrappedObject->fillRect(x, y, w, h, style));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::fillRect(QPainter* theWrappedObject, int x, int y, int w, int h, Qt::GlobalColor c)
|
|
|
{
|
|
|
( theWrappedObject->fillRect(x, y, w, h, c));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::fillRect(QPainter* theWrappedObject, int x, int y, int w, int h, const QBrush& arg__5)
|
|
|
{
|
|
|
( theWrappedObject->fillRect(x, y, w, h, arg__5));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::fillRect(QPainter* theWrappedObject, int x, int y, int w, int h, const QColor& color)
|
|
|
{
|
|
|
( theWrappedObject->fillRect(x, y, w, h, color));
|
|
|
}
|
|
|
|
|
|
const QFont* PythonQtWrapper_QPainter::font(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return &( theWrappedObject->font());
|
|
|
}
|
|
|
|
|
|
QFontInfo PythonQtWrapper_QPainter::fontInfo(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->fontInfo());
|
|
|
}
|
|
|
|
|
|
QFontMetrics PythonQtWrapper_QPainter::fontMetrics(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->fontMetrics());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPainter::hasClipping(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->hasClipping());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::initFrom(QPainter* theWrappedObject, const QWidget* widget)
|
|
|
{
|
|
|
( theWrappedObject->initFrom(widget));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPainter::isActive(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isActive());
|
|
|
}
|
|
|
|
|
|
Qt::LayoutDirection PythonQtWrapper_QPainter::layoutDirection(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->layoutDirection());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QPainter::opacity(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->opacity());
|
|
|
}
|
|
|
|
|
|
QPaintEngine* PythonQtWrapper_QPainter::paintEngine(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->paintEngine());
|
|
|
}
|
|
|
|
|
|
const QPen* PythonQtWrapper_QPainter::pen(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return &( theWrappedObject->pen());
|
|
|
}
|
|
|
|
|
|
QPaintDevice* PythonQtWrapper_QPainter::static_QPainter_redirected(const QPaintDevice* device, QPoint* offset)
|
|
|
{
|
|
|
return (QPainter::redirected(device, offset));
|
|
|
}
|
|
|
|
|
|
QPainter::RenderHints PythonQtWrapper_QPainter::renderHints(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->renderHints());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::resetMatrix(QPainter* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->resetMatrix());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::resetTransform(QPainter* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->resetTransform());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::restore(QPainter* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->restore());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::static_QPainter_restoreRedirected(const QPaintDevice* device)
|
|
|
{
|
|
|
(QPainter::restoreRedirected(device));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::rotate(QPainter* theWrappedObject, qreal a)
|
|
|
{
|
|
|
( theWrappedObject->rotate(a));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::save(QPainter* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->save());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::scale(QPainter* theWrappedObject, qreal sx, qreal sy)
|
|
|
{
|
|
|
( theWrappedObject->scale(sx, sy));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setBackground(QPainter* theWrappedObject, const QBrush& bg)
|
|
|
{
|
|
|
( theWrappedObject->setBackground(bg));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setBackgroundMode(QPainter* theWrappedObject, Qt::BGMode mode)
|
|
|
{
|
|
|
( theWrappedObject->setBackgroundMode(mode));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setBrush(QPainter* theWrappedObject, const QBrush& brush)
|
|
|
{
|
|
|
( theWrappedObject->setBrush(brush));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setBrushOrigin(QPainter* theWrappedObject, const QPoint& arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setBrushOrigin(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setBrushOrigin(QPainter* theWrappedObject, const QPointF& arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setBrushOrigin(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setBrushOrigin(QPainter* theWrappedObject, int x, int y)
|
|
|
{
|
|
|
( theWrappedObject->setBrushOrigin(x, y));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setClipPath(QPainter* theWrappedObject, const QPainterPath& path, Qt::ClipOperation op)
|
|
|
{
|
|
|
( theWrappedObject->setClipPath(path, op));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setClipRect(QPainter* theWrappedObject, const QRect& arg__1, Qt::ClipOperation op)
|
|
|
{
|
|
|
( theWrappedObject->setClipRect(arg__1, op));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setClipRect(QPainter* theWrappedObject, const QRectF& arg__1, Qt::ClipOperation op)
|
|
|
{
|
|
|
( theWrappedObject->setClipRect(arg__1, op));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setClipRect(QPainter* theWrappedObject, int x, int y, int w, int h, Qt::ClipOperation op)
|
|
|
{
|
|
|
( theWrappedObject->setClipRect(x, y, w, h, op));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setClipRegion(QPainter* theWrappedObject, const QRegion& arg__1, Qt::ClipOperation op)
|
|
|
{
|
|
|
( theWrappedObject->setClipRegion(arg__1, op));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setClipping(QPainter* theWrappedObject, bool enable)
|
|
|
{
|
|
|
( theWrappedObject->setClipping(enable));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setCompositionMode(QPainter* theWrappedObject, QPainter::CompositionMode mode)
|
|
|
{
|
|
|
( theWrappedObject->setCompositionMode(mode));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setFont(QPainter* theWrappedObject, const QFont& f)
|
|
|
{
|
|
|
( theWrappedObject->setFont(f));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setLayoutDirection(QPainter* theWrappedObject, Qt::LayoutDirection direction)
|
|
|
{
|
|
|
( theWrappedObject->setLayoutDirection(direction));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setOpacity(QPainter* theWrappedObject, qreal opacity)
|
|
|
{
|
|
|
( theWrappedObject->setOpacity(opacity));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setPen(QPainter* theWrappedObject, Qt::PenStyle style)
|
|
|
{
|
|
|
( theWrappedObject->setPen(style));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setPen(QPainter* theWrappedObject, const QColor& color)
|
|
|
{
|
|
|
( theWrappedObject->setPen(color));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setPen(QPainter* theWrappedObject, const QPen& pen)
|
|
|
{
|
|
|
( theWrappedObject->setPen(pen));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::static_QPainter_setRedirected(const QPaintDevice* device, QPaintDevice* replacement, const QPoint& offset)
|
|
|
{
|
|
|
(QPainter::setRedirected(device, replacement, offset));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setRenderHint(QPainter* theWrappedObject, QPainter::RenderHint hint, bool on)
|
|
|
{
|
|
|
( theWrappedObject->setRenderHint(hint, on));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setRenderHints(QPainter* theWrappedObject, QPainter::RenderHints hints, bool on)
|
|
|
{
|
|
|
( theWrappedObject->setRenderHints(hints, on));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setTransform(QPainter* theWrappedObject, const QTransform& transform, bool combine)
|
|
|
{
|
|
|
( theWrappedObject->setTransform(transform, combine));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setViewTransformEnabled(QPainter* theWrappedObject, bool enable)
|
|
|
{
|
|
|
( theWrappedObject->setViewTransformEnabled(enable));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setViewport(QPainter* theWrappedObject, const QRect& viewport)
|
|
|
{
|
|
|
( theWrappedObject->setViewport(viewport));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setViewport(QPainter* theWrappedObject, int x, int y, int w, int h)
|
|
|
{
|
|
|
( theWrappedObject->setViewport(x, y, w, h));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setWindow(QPainter* theWrappedObject, const QRect& window)
|
|
|
{
|
|
|
( theWrappedObject->setWindow(window));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setWindow(QPainter* theWrappedObject, int x, int y, int w, int h)
|
|
|
{
|
|
|
( theWrappedObject->setWindow(x, y, w, h));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setWorldMatrix(QPainter* theWrappedObject, const QMatrix& matrix, bool combine)
|
|
|
{
|
|
|
( theWrappedObject->setWorldMatrix(matrix, combine));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setWorldMatrixEnabled(QPainter* theWrappedObject, bool enabled)
|
|
|
{
|
|
|
( theWrappedObject->setWorldMatrixEnabled(enabled));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::setWorldTransform(QPainter* theWrappedObject, const QTransform& matrix, bool combine)
|
|
|
{
|
|
|
( theWrappedObject->setWorldTransform(matrix, combine));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::shear(QPainter* theWrappedObject, qreal sh, qreal sv)
|
|
|
{
|
|
|
( theWrappedObject->shear(sh, sv));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::strokePath(QPainter* theWrappedObject, const QPainterPath& path, const QPen& pen)
|
|
|
{
|
|
|
( theWrappedObject->strokePath(path, pen));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPainter::testRenderHint(QPainter* theWrappedObject, QPainter::RenderHint hint) const
|
|
|
{
|
|
|
return ( theWrappedObject->testRenderHint(hint));
|
|
|
}
|
|
|
|
|
|
const QTransform* PythonQtWrapper_QPainter::transform(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return &( theWrappedObject->transform());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::translate(QPainter* theWrappedObject, const QPoint& offset)
|
|
|
{
|
|
|
( theWrappedObject->translate(offset));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::translate(QPainter* theWrappedObject, const QPointF& offset)
|
|
|
{
|
|
|
( theWrappedObject->translate(offset));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainter::translate(QPainter* theWrappedObject, qreal dx, qreal dy)
|
|
|
{
|
|
|
( theWrappedObject->translate(dx, dy));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPainter::viewTransformEnabled(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->viewTransformEnabled());
|
|
|
}
|
|
|
|
|
|
QRect PythonQtWrapper_QPainter::viewport(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->viewport());
|
|
|
}
|
|
|
|
|
|
QRect PythonQtWrapper_QPainter::window(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->window());
|
|
|
}
|
|
|
|
|
|
const QMatrix* PythonQtWrapper_QPainter::worldMatrix(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return &( theWrappedObject->worldMatrix());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPainter::worldMatrixEnabled(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->worldMatrixEnabled());
|
|
|
}
|
|
|
|
|
|
const QTransform* PythonQtWrapper_QPainter::worldTransform(QPainter* theWrappedObject) const
|
|
|
{
|
|
|
return &( theWrappedObject->worldTransform());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QPainterPath* PythonQtWrapper_QPainterPath::new_QPainterPath()
|
|
|
{
|
|
|
return new QPainterPath(); }
|
|
|
|
|
|
QPainterPath* PythonQtWrapper_QPainterPath::new_QPainterPath(const QPainterPath& other)
|
|
|
{
|
|
|
return new QPainterPath(other); }
|
|
|
|
|
|
QPainterPath* PythonQtWrapper_QPainterPath::new_QPainterPath(const QPointF& startPoint)
|
|
|
{
|
|
|
return new QPainterPath(startPoint); }
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::addEllipse(QPainterPath* theWrappedObject, const QPointF& center, qreal rx, qreal ry)
|
|
|
{
|
|
|
( theWrappedObject->addEllipse(center, rx, ry));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::addEllipse(QPainterPath* theWrappedObject, const QRectF& rect)
|
|
|
{
|
|
|
( theWrappedObject->addEllipse(rect));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::addEllipse(QPainterPath* theWrappedObject, qreal x, qreal y, qreal w, qreal h)
|
|
|
{
|
|
|
( theWrappedObject->addEllipse(x, y, w, h));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::addPath(QPainterPath* theWrappedObject, const QPainterPath& path)
|
|
|
{
|
|
|
( theWrappedObject->addPath(path));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::addPolygon(QPainterPath* theWrappedObject, const QPolygonF& polygon)
|
|
|
{
|
|
|
( theWrappedObject->addPolygon(polygon));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::addRect(QPainterPath* theWrappedObject, const QRectF& rect)
|
|
|
{
|
|
|
( theWrappedObject->addRect(rect));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::addRect(QPainterPath* theWrappedObject, qreal x, qreal y, qreal w, qreal h)
|
|
|
{
|
|
|
( theWrappedObject->addRect(x, y, w, h));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::addRegion(QPainterPath* theWrappedObject, const QRegion& region)
|
|
|
{
|
|
|
( theWrappedObject->addRegion(region));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::addRoundRect(QPainterPath* theWrappedObject, const QRectF& rect, int roundness)
|
|
|
{
|
|
|
( theWrappedObject->addRoundRect(rect, roundness));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::addRoundRect(QPainterPath* theWrappedObject, const QRectF& rect, int xRnd, int yRnd)
|
|
|
{
|
|
|
( theWrappedObject->addRoundRect(rect, xRnd, yRnd));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::addRoundRect(QPainterPath* theWrappedObject, qreal x, qreal y, qreal w, qreal h, int roundness)
|
|
|
{
|
|
|
( theWrappedObject->addRoundRect(x, y, w, h, roundness));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::addRoundRect(QPainterPath* theWrappedObject, qreal x, qreal y, qreal w, qreal h, int xRnd, int yRnd)
|
|
|
{
|
|
|
( theWrappedObject->addRoundRect(x, y, w, h, xRnd, yRnd));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::addRoundedRect(QPainterPath* theWrappedObject, const QRectF& rect, qreal xRadius, qreal yRadius, Qt::SizeMode mode)
|
|
|
{
|
|
|
( theWrappedObject->addRoundedRect(rect, xRadius, yRadius, mode));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::addRoundedRect(QPainterPath* theWrappedObject, qreal x, qreal y, qreal w, qreal h, qreal xRadius, qreal yRadius, Qt::SizeMode mode)
|
|
|
{
|
|
|
( theWrappedObject->addRoundedRect(x, y, w, h, xRadius, yRadius, mode));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::addText(QPainterPath* theWrappedObject, const QPointF& point, const QFont& f, const QString& text)
|
|
|
{
|
|
|
( theWrappedObject->addText(point, f, text));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::addText(QPainterPath* theWrappedObject, qreal x, qreal y, const QFont& f, const QString& text)
|
|
|
{
|
|
|
( theWrappedObject->addText(x, y, f, text));
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QPainterPath::angleAtPercent(QPainterPath* theWrappedObject, qreal t) const
|
|
|
{
|
|
|
return ( theWrappedObject->angleAtPercent(t));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::arcMoveTo(QPainterPath* theWrappedObject, const QRectF& rect, qreal angle)
|
|
|
{
|
|
|
( theWrappedObject->arcMoveTo(rect, angle));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::arcMoveTo(QPainterPath* theWrappedObject, qreal x, qreal y, qreal w, qreal h, qreal angle)
|
|
|
{
|
|
|
( theWrappedObject->arcMoveTo(x, y, w, h, angle));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::arcTo(QPainterPath* theWrappedObject, const QRectF& rect, qreal startAngle, qreal arcLength)
|
|
|
{
|
|
|
( theWrappedObject->arcTo(rect, startAngle, arcLength));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::arcTo(QPainterPath* theWrappedObject, qreal x, qreal y, qreal w, qreal h, qreal startAngle, qreal arcLength)
|
|
|
{
|
|
|
( theWrappedObject->arcTo(x, y, w, h, startAngle, arcLength));
|
|
|
}
|
|
|
|
|
|
QRectF PythonQtWrapper_QPainterPath::boundingRect(QPainterPath* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->boundingRect());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::closeSubpath(QPainterPath* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->closeSubpath());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::connectPath(QPainterPath* theWrappedObject, const QPainterPath& path)
|
|
|
{
|
|
|
( theWrappedObject->connectPath(path));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPainterPath::contains(QPainterPath* theWrappedObject, const QPainterPath& p) const
|
|
|
{
|
|
|
return ( theWrappedObject->contains(p));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPainterPath::contains(QPainterPath* theWrappedObject, const QPointF& pt) const
|
|
|
{
|
|
|
return ( theWrappedObject->contains(pt));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPainterPath::contains(QPainterPath* theWrappedObject, const QRectF& rect) const
|
|
|
{
|
|
|
return ( theWrappedObject->contains(rect));
|
|
|
}
|
|
|
|
|
|
QRectF PythonQtWrapper_QPainterPath::controlPointRect(QPainterPath* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->controlPointRect());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::cubicTo(QPainterPath* theWrappedObject, const QPointF& ctrlPt1, const QPointF& ctrlPt2, const QPointF& endPt)
|
|
|
{
|
|
|
( theWrappedObject->cubicTo(ctrlPt1, ctrlPt2, endPt));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::cubicTo(QPainterPath* theWrappedObject, qreal ctrlPt1x, qreal ctrlPt1y, qreal ctrlPt2x, qreal ctrlPt2y, qreal endPtx, qreal endPty)
|
|
|
{
|
|
|
( theWrappedObject->cubicTo(ctrlPt1x, ctrlPt1y, ctrlPt2x, ctrlPt2y, endPtx, endPty));
|
|
|
}
|
|
|
|
|
|
QPointF PythonQtWrapper_QPainterPath::currentPosition(QPainterPath* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->currentPosition());
|
|
|
}
|
|
|
|
|
|
const QPainterPath::Element* PythonQtWrapper_QPainterPath::elementAt(QPainterPath* theWrappedObject, int i) const
|
|
|
{
|
|
|
return &( theWrappedObject->elementAt(i));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QPainterPath::elementCount(QPainterPath* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->elementCount());
|
|
|
}
|
|
|
|
|
|
Qt::FillRule PythonQtWrapper_QPainterPath::fillRule(QPainterPath* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->fillRule());
|
|
|
}
|
|
|
|
|
|
QPainterPath PythonQtWrapper_QPainterPath::intersected(QPainterPath* theWrappedObject, const QPainterPath& r) const
|
|
|
{
|
|
|
return ( theWrappedObject->intersected(r));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPainterPath::intersects(QPainterPath* theWrappedObject, const QPainterPath& p) const
|
|
|
{
|
|
|
return ( theWrappedObject->intersects(p));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPainterPath::intersects(QPainterPath* theWrappedObject, const QRectF& rect) const
|
|
|
{
|
|
|
return ( theWrappedObject->intersects(rect));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPainterPath::isEmpty(QPainterPath* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isEmpty());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QPainterPath::length(QPainterPath* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->length());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::lineTo(QPainterPath* theWrappedObject, const QPointF& p)
|
|
|
{
|
|
|
( theWrappedObject->lineTo(p));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::lineTo(QPainterPath* theWrappedObject, qreal x, qreal y)
|
|
|
{
|
|
|
( theWrappedObject->lineTo(x, y));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::moveTo(QPainterPath* theWrappedObject, const QPointF& p)
|
|
|
{
|
|
|
( theWrappedObject->moveTo(p));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::moveTo(QPainterPath* theWrappedObject, qreal x, qreal y)
|
|
|
{
|
|
|
( theWrappedObject->moveTo(x, y));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPainterPath::__ne__(QPainterPath* theWrappedObject, const QPainterPath& other) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)!= other);
|
|
|
}
|
|
|
|
|
|
QPainterPath PythonQtWrapper_QPainterPath::__and__(QPainterPath* theWrappedObject, const QPainterPath& other) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)& other);
|
|
|
}
|
|
|
|
|
|
QPainterPath* PythonQtWrapper_QPainterPath::__iand__(QPainterPath* theWrappedObject, const QPainterPath& other)
|
|
|
{
|
|
|
return &( (*theWrappedObject)&= other);
|
|
|
}
|
|
|
|
|
|
QPainterPath PythonQtWrapper_QPainterPath::__mul__(QPainterPath* theWrappedObject, const QMatrix& m)
|
|
|
{
|
|
|
return ( (*theWrappedObject)* m);
|
|
|
}
|
|
|
|
|
|
QPainterPath PythonQtWrapper_QPainterPath::__mul__(QPainterPath* theWrappedObject, const QTransform& m)
|
|
|
{
|
|
|
return ( (*theWrappedObject)* m);
|
|
|
}
|
|
|
|
|
|
QPainterPath PythonQtWrapper_QPainterPath::__add__(QPainterPath* theWrappedObject, const QPainterPath& other) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)+ other);
|
|
|
}
|
|
|
|
|
|
QPainterPath* PythonQtWrapper_QPainterPath::__iadd__(QPainterPath* theWrappedObject, const QPainterPath& other)
|
|
|
{
|
|
|
return &( (*theWrappedObject)+= other);
|
|
|
}
|
|
|
|
|
|
QPainterPath PythonQtWrapper_QPainterPath::__sub__(QPainterPath* theWrappedObject, const QPainterPath& other) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)- other);
|
|
|
}
|
|
|
|
|
|
QPainterPath* PythonQtWrapper_QPainterPath::__isub__(QPainterPath* theWrappedObject, const QPainterPath& other)
|
|
|
{
|
|
|
return &( (*theWrappedObject)-= other);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::writeTo(QPainterPath* theWrappedObject, QDataStream& arg__1)
|
|
|
{
|
|
|
arg__1 << (*theWrappedObject);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPainterPath::__eq__(QPainterPath* theWrappedObject, const QPainterPath& other) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)== other);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::readFrom(QPainterPath* theWrappedObject, QDataStream& arg__1)
|
|
|
{
|
|
|
arg__1 >> (*theWrappedObject);
|
|
|
}
|
|
|
|
|
|
QPainterPath PythonQtWrapper_QPainterPath::__or__(QPainterPath* theWrappedObject, const QPainterPath& other) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)| other);
|
|
|
}
|
|
|
|
|
|
QPainterPath* PythonQtWrapper_QPainterPath::__ior__(QPainterPath* theWrappedObject, const QPainterPath& other)
|
|
|
{
|
|
|
return &( (*theWrappedObject)|= other);
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QPainterPath::percentAtLength(QPainterPath* theWrappedObject, qreal t) const
|
|
|
{
|
|
|
return ( theWrappedObject->percentAtLength(t));
|
|
|
}
|
|
|
|
|
|
QPointF PythonQtWrapper_QPainterPath::pointAtPercent(QPainterPath* theWrappedObject, qreal t) const
|
|
|
{
|
|
|
return ( theWrappedObject->pointAtPercent(t));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::quadTo(QPainterPath* theWrappedObject, const QPointF& ctrlPt, const QPointF& endPt)
|
|
|
{
|
|
|
( theWrappedObject->quadTo(ctrlPt, endPt));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::quadTo(QPainterPath* theWrappedObject, qreal ctrlPtx, qreal ctrlPty, qreal endPtx, qreal endPty)
|
|
|
{
|
|
|
( theWrappedObject->quadTo(ctrlPtx, ctrlPty, endPtx, endPty));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::setElementPositionAt(QPainterPath* theWrappedObject, int i, qreal x, qreal y)
|
|
|
{
|
|
|
( theWrappedObject->setElementPositionAt(i, x, y));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::setFillRule(QPainterPath* theWrappedObject, Qt::FillRule fillRule)
|
|
|
{
|
|
|
( theWrappedObject->setFillRule(fillRule));
|
|
|
}
|
|
|
|
|
|
QPainterPath PythonQtWrapper_QPainterPath::simplified(QPainterPath* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->simplified());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QPainterPath::slopeAtPercent(QPainterPath* theWrappedObject, qreal t) const
|
|
|
{
|
|
|
return ( theWrappedObject->slopeAtPercent(t));
|
|
|
}
|
|
|
|
|
|
QPainterPath PythonQtWrapper_QPainterPath::subtracted(QPainterPath* theWrappedObject, const QPainterPath& r) const
|
|
|
{
|
|
|
return ( theWrappedObject->subtracted(r));
|
|
|
}
|
|
|
|
|
|
QPainterPath PythonQtWrapper_QPainterPath::subtractedInverted(QPainterPath* theWrappedObject, const QPainterPath& r) const
|
|
|
{
|
|
|
return ( theWrappedObject->subtractedInverted(r));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::swap(QPainterPath* theWrappedObject, QPainterPath& other)
|
|
|
{
|
|
|
( theWrappedObject->swap(other));
|
|
|
}
|
|
|
|
|
|
QPolygonF PythonQtWrapper_QPainterPath::toFillPolygon(QPainterPath* theWrappedObject, const QMatrix& matrix) const
|
|
|
{
|
|
|
return ( theWrappedObject->toFillPolygon(matrix));
|
|
|
}
|
|
|
|
|
|
QPolygonF PythonQtWrapper_QPainterPath::toFillPolygon(QPainterPath* theWrappedObject, const QTransform& matrix) const
|
|
|
{
|
|
|
return ( theWrappedObject->toFillPolygon(matrix));
|
|
|
}
|
|
|
|
|
|
QList<QPolygonF > PythonQtWrapper_QPainterPath::toFillPolygons(QPainterPath* theWrappedObject, const QMatrix& matrix) const
|
|
|
{
|
|
|
return ( theWrappedObject->toFillPolygons(matrix));
|
|
|
}
|
|
|
|
|
|
QList<QPolygonF > PythonQtWrapper_QPainterPath::toFillPolygons(QPainterPath* theWrappedObject, const QTransform& matrix) const
|
|
|
{
|
|
|
return ( theWrappedObject->toFillPolygons(matrix));
|
|
|
}
|
|
|
|
|
|
QPainterPath PythonQtWrapper_QPainterPath::toReversed(QPainterPath* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->toReversed());
|
|
|
}
|
|
|
|
|
|
QList<QPolygonF > PythonQtWrapper_QPainterPath::toSubpathPolygons(QPainterPath* theWrappedObject, const QMatrix& matrix) const
|
|
|
{
|
|
|
return ( theWrappedObject->toSubpathPolygons(matrix));
|
|
|
}
|
|
|
|
|
|
QList<QPolygonF > PythonQtWrapper_QPainterPath::toSubpathPolygons(QPainterPath* theWrappedObject, const QTransform& matrix) const
|
|
|
{
|
|
|
return ( theWrappedObject->toSubpathPolygons(matrix));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::translate(QPainterPath* theWrappedObject, const QPointF& offset)
|
|
|
{
|
|
|
( theWrappedObject->translate(offset));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPath::translate(QPainterPath* theWrappedObject, qreal dx, qreal dy)
|
|
|
{
|
|
|
( theWrappedObject->translate(dx, dy));
|
|
|
}
|
|
|
|
|
|
QPainterPath PythonQtWrapper_QPainterPath::translated(QPainterPath* theWrappedObject, const QPointF& offset) const
|
|
|
{
|
|
|
return ( theWrappedObject->translated(offset));
|
|
|
}
|
|
|
|
|
|
QPainterPath PythonQtWrapper_QPainterPath::translated(QPainterPath* theWrappedObject, qreal dx, qreal dy) const
|
|
|
{
|
|
|
return ( theWrappedObject->translated(dx, dy));
|
|
|
}
|
|
|
|
|
|
QPainterPath PythonQtWrapper_QPainterPath::united(QPainterPath* theWrappedObject, const QPainterPath& r) const
|
|
|
{
|
|
|
return ( theWrappedObject->united(r));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QPainterPath::py_toString(QPainterPath* obj) {
|
|
|
QString result;
|
|
|
QDebug d(&result);
|
|
|
d << *obj;
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QPainterPathStroker* PythonQtWrapper_QPainterPathStroker::new_QPainterPathStroker()
|
|
|
{
|
|
|
return new QPainterPathStroker(); }
|
|
|
|
|
|
Qt::PenCapStyle PythonQtWrapper_QPainterPathStroker::capStyle(QPainterPathStroker* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->capStyle());
|
|
|
}
|
|
|
|
|
|
QPainterPath PythonQtWrapper_QPainterPathStroker::createStroke(QPainterPathStroker* theWrappedObject, const QPainterPath& path) const
|
|
|
{
|
|
|
return ( theWrappedObject->createStroke(path));
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QPainterPathStroker::curveThreshold(QPainterPathStroker* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->curveThreshold());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QPainterPathStroker::dashOffset(QPainterPathStroker* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->dashOffset());
|
|
|
}
|
|
|
|
|
|
QVector<qreal > PythonQtWrapper_QPainterPathStroker::dashPattern(QPainterPathStroker* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->dashPattern());
|
|
|
}
|
|
|
|
|
|
Qt::PenJoinStyle PythonQtWrapper_QPainterPathStroker::joinStyle(QPainterPathStroker* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->joinStyle());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QPainterPathStroker::miterLimit(QPainterPathStroker* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->miterLimit());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPathStroker::setCapStyle(QPainterPathStroker* theWrappedObject, Qt::PenCapStyle style)
|
|
|
{
|
|
|
( theWrappedObject->setCapStyle(style));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPathStroker::setCurveThreshold(QPainterPathStroker* theWrappedObject, qreal threshold)
|
|
|
{
|
|
|
( theWrappedObject->setCurveThreshold(threshold));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPathStroker::setDashOffset(QPainterPathStroker* theWrappedObject, qreal offset)
|
|
|
{
|
|
|
( theWrappedObject->setDashOffset(offset));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPathStroker::setDashPattern(QPainterPathStroker* theWrappedObject, Qt::PenStyle arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setDashPattern(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPathStroker::setDashPattern(QPainterPathStroker* theWrappedObject, const QVector<qreal >& dashPattern)
|
|
|
{
|
|
|
( theWrappedObject->setDashPattern(dashPattern));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPathStroker::setJoinStyle(QPainterPathStroker* theWrappedObject, Qt::PenJoinStyle style)
|
|
|
{
|
|
|
( theWrappedObject->setJoinStyle(style));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPathStroker::setMiterLimit(QPainterPathStroker* theWrappedObject, qreal length)
|
|
|
{
|
|
|
( theWrappedObject->setMiterLimit(length));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPainterPathStroker::setWidth(QPainterPathStroker* theWrappedObject, qreal width)
|
|
|
{
|
|
|
( theWrappedObject->setWidth(width));
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QPainterPathStroker::width(QPainterPathStroker* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->width());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QPanGesture::~PythonQtShell_QPanGesture() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QPanGesture::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QChildEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPanGesture::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPanGesture::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPanGesture::customEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QPanGesture::event(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QPanGesture::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QPanGesture::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 char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QPanGesture::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QPanGesture::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPanGesture::timerEvent(arg__1);
|
|
|
}
|
|
|
QPanGesture* PythonQtWrapper_QPanGesture::new_QPanGesture(QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QPanGesture(parent); }
|
|
|
|
|
|
qreal PythonQtWrapper_QPanGesture::acceleration(QPanGesture* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->acceleration());
|
|
|
}
|
|
|
|
|
|
QPointF PythonQtWrapper_QPanGesture::delta(QPanGesture* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->delta());
|
|
|
}
|
|
|
|
|
|
QPointF PythonQtWrapper_QPanGesture::lastOffset(QPanGesture* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->lastOffset());
|
|
|
}
|
|
|
|
|
|
QPointF PythonQtWrapper_QPanGesture::offset(QPanGesture* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->offset());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPanGesture::setAcceleration(QPanGesture* theWrappedObject, qreal value)
|
|
|
{
|
|
|
( theWrappedObject->setAcceleration(value));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPanGesture::setLastOffset(QPanGesture* theWrappedObject, const QPointF& value)
|
|
|
{
|
|
|
( theWrappedObject->setLastOffset(value));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPanGesture::setOffset(QPanGesture* theWrappedObject, const QPointF& value)
|
|
|
{
|
|
|
( theWrappedObject->setOffset(value));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QPicture::~PythonQtShell_QPicture() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
int PythonQtShell_QPicture::devType() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QPicture::devType();
|
|
|
}
|
|
|
int PythonQtShell_QPicture::metric(QPaintDevice::PaintDeviceMetric m) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&m};
|
|
|
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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QPicture::metric(m);
|
|
|
}
|
|
|
QPaintEngine* PythonQtShell_QPicture::paintEngine() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QPaintEngine*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPaintEngine* 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) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintEngine**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QPicture::paintEngine();
|
|
|
}
|
|
|
void PythonQtShell_QPicture::setData(const char* data, uint size)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setData");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const char*" , "uint"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&data, (void*)&size};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPicture::setData(data, size);
|
|
|
}
|
|
|
QPicture* PythonQtWrapper_QPicture::new_QPicture(const QPicture& arg__1)
|
|
|
{
|
|
|
return new PythonQtShell_QPicture(arg__1); }
|
|
|
|
|
|
QPicture* PythonQtWrapper_QPicture::new_QPicture(int formatVersion)
|
|
|
{
|
|
|
return new PythonQtShell_QPicture(formatVersion); }
|
|
|
|
|
|
QRect PythonQtWrapper_QPicture::boundingRect(QPicture* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->boundingRect());
|
|
|
}
|
|
|
|
|
|
const char* PythonQtWrapper_QPicture::data(QPicture* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->data());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QPicture::devType(QPicture* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QPicture*)theWrappedObject)->promoted_devType());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPicture::isNull(QPicture* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isNull());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPicture::load(QPicture* theWrappedObject, QIODevice* dev, const char* format)
|
|
|
{
|
|
|
return ( theWrappedObject->load(dev, format));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPicture::load(QPicture* theWrappedObject, const QString& fileName, const char* format)
|
|
|
{
|
|
|
return ( theWrappedObject->load(fileName, format));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QPicture::metric(QPicture* theWrappedObject, QPaintDevice::PaintDeviceMetric m) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QPicture*)theWrappedObject)->promoted_metric(m));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPicture::writeTo(QPicture* theWrappedObject, QDataStream& arg__1)
|
|
|
{
|
|
|
arg__1 << (*theWrappedObject);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPicture::readFrom(QPicture* theWrappedObject, QDataStream& arg__1)
|
|
|
{
|
|
|
arg__1 >> (*theWrappedObject);
|
|
|
}
|
|
|
|
|
|
QPaintEngine* PythonQtWrapper_QPicture::paintEngine(QPicture* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QPicture*)theWrappedObject)->promoted_paintEngine());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPicture::play(QPicture* theWrappedObject, QPainter* p)
|
|
|
{
|
|
|
return ( theWrappedObject->play(p));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPicture::save(QPicture* theWrappedObject, QIODevice* dev, const char* format)
|
|
|
{
|
|
|
return ( theWrappedObject->save(dev, format));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPicture::save(QPicture* theWrappedObject, const QString& fileName, const char* format)
|
|
|
{
|
|
|
return ( theWrappedObject->save(fileName, format));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPicture::setBoundingRect(QPicture* theWrappedObject, const QRect& r)
|
|
|
{
|
|
|
( theWrappedObject->setBoundingRect(r));
|
|
|
}
|
|
|
|
|
|
uint PythonQtWrapper_QPicture::size(QPicture* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->size());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPicture::swap(QPicture* theWrappedObject, QPicture& other)
|
|
|
{
|
|
|
( theWrappedObject->swap(other));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
