com_trolltech_qt_gui4.cpp
13880 lines
| 501.4 KiB
| text/x-c
|
CppLexer
florianlink
|
r200 | #include "com_trolltech_qt_gui4.h" | ||
#include <PythonQtConversion.h> | ||||
#include <PythonQtMethodInfo.h> | ||||
#include <PythonQtSignalReceiver.h> | ||||
#include <QColor> | ||||
#include <QImage> | ||||
#include <QRect> | ||||
#include <QSize> | ||||
#include <QStringList> | ||||
#include <QTextFormat> | ||||
#include <QVariant> | ||||
#include <qabstractanimation.h> | ||||
#include <qabstractitemdelegate.h> | ||||
#include <qabstractitemmodel.h> | ||||
#include <qabstractitemview.h> | ||||
#include <qabstractstate.h> | ||||
#include <qaction.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 <qdockwidget.h> | ||||
#include <qevent.h> | ||||
#include <qfont.h> | ||||
#include <qgraphicseffect.h> | ||||
#include <qgraphicsproxywidget.h> | ||||
#include <qicon.h> | ||||
#include <qimage.h> | ||||
#include <qimageiohandler.h> | ||||
#include <qimagereader.h> | ||||
#include <qimagewriter.h> | ||||
#include <qinputcontext.h> | ||||
#include <qinputdialog.h> | ||||
#include <qiodevice.h> | ||||
#include <qitemdelegate.h> | ||||
#include <qitemeditorfactory.h> | ||||
#include <qitemselectionmodel.h> | ||||
#include <qkeyeventtransition.h> | ||||
#include <qkeysequence.h> | ||||
#include <qlabel.h> | ||||
#include <qlayout.h> | ||||
#include <qlayoutitem.h> | ||||
#include <qlcdnumber.h> | ||||
#include <qlineedit.h> | ||||
#include <qlist.h> | ||||
#include <qlistview.h> | ||||
#include <qlistwidget.h> | ||||
#include <qlocale.h> | ||||
#include <qmainwindow.h> | ||||
#include <qmargins.h> | ||||
#include <qmenu.h> | ||||
#include <qmenubar.h> | ||||
#include <qmimedata.h> | ||||
#include <qmovie.h> | ||||
#include <qobject.h> | ||||
#include <qpaintdevice.h> | ||||
#include <qpaintengine.h> | ||||
#include <qpainter.h> | ||||
#include <qpair.h> | ||||
#include <qpalette.h> | ||||
#include <qpicture.h> | ||||
#include <qpixmap.h> | ||||
#include <qpoint.h> | ||||
#include <qrect.h> | ||||
#include <qregion.h> | ||||
#include <qscrollbar.h> | ||||
#include <qsize.h> | ||||
#include <qsizepolicy.h> | ||||
#include <qstate.h> | ||||
#include <qstatemachine.h> | ||||
#include <qstatusbar.h> | ||||
#include <qstringlist.h> | ||||
#include <qstyle.h> | ||||
#include <qstyleoption.h> | ||||
#include <qtextformat.h> | ||||
#include <qtoolbar.h> | ||||
#include <qvalidator.h> | ||||
#include <qvector.h> | ||||
#include <qwidget.h> | ||||
void PythonQtShell_QIconEnginePluginV2::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; | ||||
} | ||||
} | ||||
QIconEnginePluginV2::childEvent(arg__1); | ||||
} | ||||
QIconEngineV2* PythonQtShell_QIconEnginePluginV2::create(const QString& filename) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "create"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QIconEngineV2*" , "const QString&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QIconEngineV2* returnValue; | ||||
void* args[2] = {NULL, (void*)&filename}; | ||||
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("create", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QIconEngineV2**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return 0; | ||||
} | ||||
void PythonQtShell_QIconEnginePluginV2::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; | ||||
} | ||||
} | ||||
QIconEnginePluginV2::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QIconEnginePluginV2::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 QIconEnginePluginV2::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QIconEnginePluginV2::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 QIconEnginePluginV2::eventFilter(arg__1, arg__2); | ||||
} | ||||
QStringList PythonQtShell_QIconEnginePluginV2::keys() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keys"); | ||||
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("keys", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QStringList*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QStringList(); | ||||
} | ||||
void PythonQtShell_QIconEnginePluginV2::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; | ||||
} | ||||
} | ||||
QIconEnginePluginV2::timerEvent(arg__1); | ||||
} | ||||
QIconEnginePluginV2* PythonQtWrapper_QIconEnginePluginV2::new_QIconEnginePluginV2(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QIconEnginePluginV2(parent); } | ||||
bool PythonQtShell_QImageIOHandler::canRead() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "canRead"); | ||||
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("canRead", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return bool(); | ||||
} | ||||
int PythonQtShell_QImageIOHandler::currentImageNumber() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "currentImageNumber"); | ||||
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("currentImageNumber", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QImageIOHandler::currentImageNumber(); | ||||
} | ||||
QRect PythonQtShell_QImageIOHandler::currentImageRect() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "currentImageRect"); | ||||
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("currentImageRect", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QRect*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QImageIOHandler::currentImageRect(); | ||||
} | ||||
int PythonQtShell_QImageIOHandler::imageCount() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "imageCount"); | ||||
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("imageCount", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QImageIOHandler::imageCount(); | ||||
} | ||||
bool PythonQtShell_QImageIOHandler::jumpToImage(int imageNumber) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "jumpToImage"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&imageNumber}; | ||||
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("jumpToImage", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QImageIOHandler::jumpToImage(imageNumber); | ||||
} | ||||
bool PythonQtShell_QImageIOHandler::jumpToNextImage() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "jumpToNextImage"); | ||||
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("jumpToNextImage", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QImageIOHandler::jumpToNextImage(); | ||||
} | ||||
int PythonQtShell_QImageIOHandler::loopCount() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "loopCount"); | ||||
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("loopCount", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QImageIOHandler::loopCount(); | ||||
} | ||||
QByteArray PythonQtShell_QImageIOHandler::name() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "name"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QByteArray"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QByteArray 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("name", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QByteArray*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QImageIOHandler::name(); | ||||
} | ||||
int PythonQtShell_QImageIOHandler::nextImageDelay() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nextImageDelay"); | ||||
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("nextImageDelay", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QImageIOHandler::nextImageDelay(); | ||||
} | ||||
QVariant PythonQtShell_QImageIOHandler::option(QImageIOHandler::ImageOption option) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "option"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QVariant" , "QImageIOHandler::ImageOption"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QVariant returnValue; | ||||
void* args[2] = {NULL, (void*)&option}; | ||||
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("option", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QVariant*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QImageIOHandler::option(option); | ||||
} | ||||
bool PythonQtShell_QImageIOHandler::read(QImage* image) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "read"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QImage*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&image}; | ||||
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("read", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return bool(); | ||||
} | ||||
void PythonQtShell_QImageIOHandler::setOption(QImageIOHandler::ImageOption option, const QVariant& value) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setOption"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QImageIOHandler::ImageOption" , "const QVariant&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&option, (void*)&value}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QImageIOHandler::setOption(option, value); | ||||
} | ||||
bool PythonQtShell_QImageIOHandler::supportsOption(QImageIOHandler::ImageOption option) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "supportsOption"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QImageIOHandler::ImageOption"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&option}; | ||||
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("supportsOption", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QImageIOHandler::supportsOption(option); | ||||
} | ||||
bool PythonQtShell_QImageIOHandler::write(const QImage& image) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "write"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "const QImage&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&image}; | ||||
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("write", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QImageIOHandler::write(image); | ||||
} | ||||
QImageIOHandler* PythonQtWrapper_QImageIOHandler::new_QImageIOHandler() | ||||
{ | ||||
return new PythonQtShell_QImageIOHandler(); } | ||||
int PythonQtWrapper_QImageIOHandler::currentImageNumber(QImageIOHandler* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QImageIOHandler*)theWrappedObject)->promoted_currentImageNumber()); | ||||
} | ||||
QRect PythonQtWrapper_QImageIOHandler::currentImageRect(QImageIOHandler* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QImageIOHandler*)theWrappedObject)->promoted_currentImageRect()); | ||||
} | ||||
QIODevice* PythonQtWrapper_QImageIOHandler::device(QImageIOHandler* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->device()); | ||||
} | ||||
QByteArray PythonQtWrapper_QImageIOHandler::format(QImageIOHandler* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->format()); | ||||
} | ||||
int PythonQtWrapper_QImageIOHandler::imageCount(QImageIOHandler* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QImageIOHandler*)theWrappedObject)->promoted_imageCount()); | ||||
} | ||||
bool PythonQtWrapper_QImageIOHandler::jumpToImage(QImageIOHandler* theWrappedObject, int imageNumber) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QImageIOHandler*)theWrappedObject)->promoted_jumpToImage(imageNumber)); | ||||
} | ||||
bool PythonQtWrapper_QImageIOHandler::jumpToNextImage(QImageIOHandler* theWrappedObject) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QImageIOHandler*)theWrappedObject)->promoted_jumpToNextImage()); | ||||
} | ||||
int PythonQtWrapper_QImageIOHandler::loopCount(QImageIOHandler* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QImageIOHandler*)theWrappedObject)->promoted_loopCount()); | ||||
} | ||||
int PythonQtWrapper_QImageIOHandler::nextImageDelay(QImageIOHandler* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QImageIOHandler*)theWrappedObject)->promoted_nextImageDelay()); | ||||
} | ||||
QVariant PythonQtWrapper_QImageIOHandler::option(QImageIOHandler* theWrappedObject, QImageIOHandler::ImageOption option) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QImageIOHandler*)theWrappedObject)->promoted_option(option)); | ||||
} | ||||
void PythonQtWrapper_QImageIOHandler::setDevice(QImageIOHandler* theWrappedObject, QIODevice* device) | ||||
{ | ||||
( theWrappedObject->setDevice(device)); | ||||
} | ||||
void PythonQtWrapper_QImageIOHandler::setFormat(QImageIOHandler* theWrappedObject, const QByteArray& format) | ||||
{ | ||||
( theWrappedObject->setFormat(format)); | ||||
} | ||||
void PythonQtWrapper_QImageIOHandler::setOption(QImageIOHandler* theWrappedObject, QImageIOHandler::ImageOption option, const QVariant& value) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QImageIOHandler*)theWrappedObject)->promoted_setOption(option, value)); | ||||
} | ||||
bool PythonQtWrapper_QImageIOHandler::supportsOption(QImageIOHandler* theWrappedObject, QImageIOHandler::ImageOption option) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QImageIOHandler*)theWrappedObject)->promoted_supportsOption(option)); | ||||
} | ||||
bool PythonQtWrapper_QImageIOHandler::write(QImageIOHandler* theWrappedObject, const QImage& image) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QImageIOHandler*)theWrappedObject)->promoted_write(image)); | ||||
} | ||||
QImageIOPlugin::Capabilities PythonQtShell_QImageIOPlugin::capabilities(QIODevice* device, const QByteArray& format) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "capabilities"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QImageIOPlugin::Capabilities" , "QIODevice*" , "const QByteArray&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
QImageIOPlugin::Capabilities returnValue; | ||||
void* args[3] = {NULL, (void*)&device, (void*)&format}; | ||||
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("capabilities", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QImageIOPlugin::Capabilities*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QImageIOPlugin::Capabilities(); | ||||
} | ||||
void PythonQtShell_QImageIOPlugin::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; | ||||
} | ||||
} | ||||
QImageIOPlugin::childEvent(arg__1); | ||||
} | ||||
QImageIOHandler* PythonQtShell_QImageIOPlugin::create(QIODevice* device, const QByteArray& format) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "create"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QImageIOHandler*" , "QIODevice*" , "const QByteArray&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
QImageIOHandler* returnValue; | ||||
void* args[3] = {NULL, (void*)&device, (void*)&format}; | ||||
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("create", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QImageIOHandler**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return 0; | ||||
} | ||||
void PythonQtShell_QImageIOPlugin::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; | ||||
} | ||||
} | ||||
QImageIOPlugin::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QImageIOPlugin::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 QImageIOPlugin::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QImageIOPlugin::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 QImageIOPlugin::eventFilter(arg__1, arg__2); | ||||
} | ||||
QStringList PythonQtShell_QImageIOPlugin::keys() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keys"); | ||||
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("keys", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QStringList*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QStringList(); | ||||
} | ||||
void PythonQtShell_QImageIOPlugin::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; | ||||
} | ||||
} | ||||
QImageIOPlugin::timerEvent(arg__1); | ||||
} | ||||
QImageIOPlugin* PythonQtWrapper_QImageIOPlugin::new_QImageIOPlugin(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QImageIOPlugin(parent); } | ||||
QImageReader* PythonQtWrapper_QImageReader::new_QImageReader() | ||||
{ | ||||
return new QImageReader(); } | ||||
QImageReader* PythonQtWrapper_QImageReader::new_QImageReader(QIODevice* device, const QByteArray& format) | ||||
{ | ||||
return new QImageReader(device, format); } | ||||
QImageReader* PythonQtWrapper_QImageReader::new_QImageReader(const QString& fileName, const QByteArray& format) | ||||
{ | ||||
return new QImageReader(fileName, format); } | ||||
bool PythonQtWrapper_QImageReader::autoDetectImageFormat(QImageReader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->autoDetectImageFormat()); | ||||
} | ||||
QColor PythonQtWrapper_QImageReader::backgroundColor(QImageReader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->backgroundColor()); | ||||
} | ||||
bool PythonQtWrapper_QImageReader::canRead(QImageReader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->canRead()); | ||||
} | ||||
QRect PythonQtWrapper_QImageReader::clipRect(QImageReader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->clipRect()); | ||||
} | ||||
int PythonQtWrapper_QImageReader::currentImageNumber(QImageReader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->currentImageNumber()); | ||||
} | ||||
QRect PythonQtWrapper_QImageReader::currentImageRect(QImageReader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->currentImageRect()); | ||||
} | ||||
bool PythonQtWrapper_QImageReader::decideFormatFromContent(QImageReader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->decideFormatFromContent()); | ||||
} | ||||
QIODevice* PythonQtWrapper_QImageReader::device(QImageReader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->device()); | ||||
} | ||||
QImageReader::ImageReaderError PythonQtWrapper_QImageReader::error(QImageReader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->error()); | ||||
} | ||||
QString PythonQtWrapper_QImageReader::errorString(QImageReader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->errorString()); | ||||
} | ||||
QString PythonQtWrapper_QImageReader::fileName(QImageReader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->fileName()); | ||||
} | ||||
QByteArray PythonQtWrapper_QImageReader::format(QImageReader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->format()); | ||||
} | ||||
int PythonQtWrapper_QImageReader::imageCount(QImageReader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->imageCount()); | ||||
} | ||||
QImage::Format PythonQtWrapper_QImageReader::imageFormat(QImageReader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->imageFormat()); | ||||
} | ||||
QByteArray PythonQtWrapper_QImageReader::static_QImageReader_imageFormat(QIODevice* device) | ||||
{ | ||||
return (QImageReader::imageFormat(device)); | ||||
} | ||||
QByteArray PythonQtWrapper_QImageReader::static_QImageReader_imageFormat(const QString& fileName) | ||||
{ | ||||
return (QImageReader::imageFormat(fileName)); | ||||
} | ||||
bool PythonQtWrapper_QImageReader::jumpToImage(QImageReader* theWrappedObject, int imageNumber) | ||||
{ | ||||
return ( theWrappedObject->jumpToImage(imageNumber)); | ||||
} | ||||
bool PythonQtWrapper_QImageReader::jumpToNextImage(QImageReader* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->jumpToNextImage()); | ||||
} | ||||
int PythonQtWrapper_QImageReader::loopCount(QImageReader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->loopCount()); | ||||
} | ||||
int PythonQtWrapper_QImageReader::nextImageDelay(QImageReader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->nextImageDelay()); | ||||
} | ||||
int PythonQtWrapper_QImageReader::quality(QImageReader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->quality()); | ||||
} | ||||
QImage PythonQtWrapper_QImageReader::read(QImageReader* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->read()); | ||||
} | ||||
QRect PythonQtWrapper_QImageReader::scaledClipRect(QImageReader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->scaledClipRect()); | ||||
} | ||||
QSize PythonQtWrapper_QImageReader::scaledSize(QImageReader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->scaledSize()); | ||||
} | ||||
void PythonQtWrapper_QImageReader::setAutoDetectImageFormat(QImageReader* theWrappedObject, bool enabled) | ||||
{ | ||||
( theWrappedObject->setAutoDetectImageFormat(enabled)); | ||||
} | ||||
void PythonQtWrapper_QImageReader::setBackgroundColor(QImageReader* theWrappedObject, const QColor& color) | ||||
{ | ||||
( theWrappedObject->setBackgroundColor(color)); | ||||
} | ||||
void PythonQtWrapper_QImageReader::setClipRect(QImageReader* theWrappedObject, const QRect& rect) | ||||
{ | ||||
( theWrappedObject->setClipRect(rect)); | ||||
} | ||||
void PythonQtWrapper_QImageReader::setDecideFormatFromContent(QImageReader* theWrappedObject, bool ignored) | ||||
{ | ||||
( theWrappedObject->setDecideFormatFromContent(ignored)); | ||||
} | ||||
void PythonQtWrapper_QImageReader::setDevice(QImageReader* theWrappedObject, QIODevice* device) | ||||
{ | ||||
( theWrappedObject->setDevice(device)); | ||||
} | ||||
void PythonQtWrapper_QImageReader::setFileName(QImageReader* theWrappedObject, const QString& fileName) | ||||
{ | ||||
( theWrappedObject->setFileName(fileName)); | ||||
} | ||||
void PythonQtWrapper_QImageReader::setFormat(QImageReader* theWrappedObject, const QByteArray& format) | ||||
{ | ||||
( theWrappedObject->setFormat(format)); | ||||
} | ||||
void PythonQtWrapper_QImageReader::setQuality(QImageReader* theWrappedObject, int quality) | ||||
{ | ||||
( theWrappedObject->setQuality(quality)); | ||||
} | ||||
void PythonQtWrapper_QImageReader::setScaledClipRect(QImageReader* theWrappedObject, const QRect& rect) | ||||
{ | ||||
( theWrappedObject->setScaledClipRect(rect)); | ||||
} | ||||
void PythonQtWrapper_QImageReader::setScaledSize(QImageReader* theWrappedObject, const QSize& size) | ||||
{ | ||||
( theWrappedObject->setScaledSize(size)); | ||||
} | ||||
QSize PythonQtWrapper_QImageReader::size(QImageReader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->size()); | ||||
} | ||||
QList<QByteArray > PythonQtWrapper_QImageReader::static_QImageReader_supportedImageFormats() | ||||
{ | ||||
return (QImageReader::supportedImageFormats()); | ||||
} | ||||
bool PythonQtWrapper_QImageReader::supportsAnimation(QImageReader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->supportsAnimation()); | ||||
} | ||||
bool PythonQtWrapper_QImageReader::supportsOption(QImageReader* theWrappedObject, QImageIOHandler::ImageOption option) const | ||||
{ | ||||
return ( theWrappedObject->supportsOption(option)); | ||||
} | ||||
QString PythonQtWrapper_QImageReader::text(QImageReader* theWrappedObject, const QString& key) const | ||||
{ | ||||
return ( theWrappedObject->text(key)); | ||||
} | ||||
QStringList PythonQtWrapper_QImageReader::textKeys(QImageReader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->textKeys()); | ||||
} | ||||
QImageWriter* PythonQtWrapper_QImageWriter::new_QImageWriter() | ||||
{ | ||||
return new QImageWriter(); } | ||||
QImageWriter* PythonQtWrapper_QImageWriter::new_QImageWriter(QIODevice* device, const QByteArray& format) | ||||
{ | ||||
return new QImageWriter(device, format); } | ||||
QImageWriter* PythonQtWrapper_QImageWriter::new_QImageWriter(const QString& fileName, const QByteArray& format) | ||||
{ | ||||
return new QImageWriter(fileName, format); } | ||||
bool PythonQtWrapper_QImageWriter::canWrite(QImageWriter* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->canWrite()); | ||||
} | ||||
int PythonQtWrapper_QImageWriter::compression(QImageWriter* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->compression()); | ||||
} | ||||
QIODevice* PythonQtWrapper_QImageWriter::device(QImageWriter* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->device()); | ||||
} | ||||
QImageWriter::ImageWriterError PythonQtWrapper_QImageWriter::error(QImageWriter* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->error()); | ||||
} | ||||
QString PythonQtWrapper_QImageWriter::errorString(QImageWriter* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->errorString()); | ||||
} | ||||
QString PythonQtWrapper_QImageWriter::fileName(QImageWriter* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->fileName()); | ||||
} | ||||
QByteArray PythonQtWrapper_QImageWriter::format(QImageWriter* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->format()); | ||||
} | ||||
float PythonQtWrapper_QImageWriter::gamma(QImageWriter* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->gamma()); | ||||
} | ||||
int PythonQtWrapper_QImageWriter::quality(QImageWriter* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->quality()); | ||||
} | ||||
void PythonQtWrapper_QImageWriter::setCompression(QImageWriter* theWrappedObject, int compression) | ||||
{ | ||||
( theWrappedObject->setCompression(compression)); | ||||
} | ||||
void PythonQtWrapper_QImageWriter::setDevice(QImageWriter* theWrappedObject, QIODevice* device) | ||||
{ | ||||
( theWrappedObject->setDevice(device)); | ||||
} | ||||
void PythonQtWrapper_QImageWriter::setFileName(QImageWriter* theWrappedObject, const QString& fileName) | ||||
{ | ||||
( theWrappedObject->setFileName(fileName)); | ||||
} | ||||
void PythonQtWrapper_QImageWriter::setFormat(QImageWriter* theWrappedObject, const QByteArray& format) | ||||
{ | ||||
( theWrappedObject->setFormat(format)); | ||||
} | ||||
void PythonQtWrapper_QImageWriter::setGamma(QImageWriter* theWrappedObject, float gamma) | ||||
{ | ||||
( theWrappedObject->setGamma(gamma)); | ||||
} | ||||
void PythonQtWrapper_QImageWriter::setQuality(QImageWriter* theWrappedObject, int quality) | ||||
{ | ||||
( theWrappedObject->setQuality(quality)); | ||||
} | ||||
void PythonQtWrapper_QImageWriter::setText(QImageWriter* theWrappedObject, const QString& key, const QString& text) | ||||
{ | ||||
( theWrappedObject->setText(key, text)); | ||||
} | ||||
QList<QByteArray > PythonQtWrapper_QImageWriter::static_QImageWriter_supportedImageFormats() | ||||
{ | ||||
return (QImageWriter::supportedImageFormats()); | ||||
} | ||||
bool PythonQtWrapper_QImageWriter::supportsOption(QImageWriter* theWrappedObject, QImageIOHandler::ImageOption option) const | ||||
{ | ||||
return ( theWrappedObject->supportsOption(option)); | ||||
} | ||||
bool PythonQtWrapper_QImageWriter::write(QImageWriter* theWrappedObject, const QImage& image) | ||||
{ | ||||
return ( theWrappedObject->write(image)); | ||||
} | ||||
QList<QAction* > PythonQtShell_QInputContext::actions() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actions"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QList<QAction* >"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QList<QAction* > 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("actions", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QList<QAction* >*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QInputContext::actions(); | ||||
} | ||||
void PythonQtShell_QInputContext::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; | ||||
} | ||||
} | ||||
QInputContext::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QInputContext::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; | ||||
} | ||||
} | ||||
QInputContext::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QInputContext::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 QInputContext::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QInputContext::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 QInputContext::eventFilter(arg__1, arg__2); | ||||
} | ||||
bool PythonQtShell_QInputContext::filterEvent(const QEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "filterEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "const 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("filterEvent", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QInputContext::filterEvent(event); | ||||
} | ||||
QFont PythonQtShell_QInputContext::font() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "font"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QFont"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QFont 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("font", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QFont*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QInputContext::font(); | ||||
} | ||||
QString PythonQtShell_QInputContext::identifierName() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "identifierName"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QString"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QString 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("identifierName", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QString*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QString(); | ||||
} | ||||
bool PythonQtShell_QInputContext::isComposing() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isComposing"); | ||||
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("isComposing", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return bool(); | ||||
} | ||||
QString PythonQtShell_QInputContext::language() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "language"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QString"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QString 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("language", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QString*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QString(); | ||||
} | ||||
void PythonQtShell_QInputContext::mouseHandler(int x, QMouseEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseHandler"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "int" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&x, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QInputContext::mouseHandler(x, event); | ||||
} | ||||
void PythonQtShell_QInputContext::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; | ||||
} | ||||
} | ||||
} | ||||
void PythonQtShell_QInputContext::setFocusWidget(QWidget* w) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFocusWidget"); | ||||
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*)&w}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QInputContext::setFocusWidget(w); | ||||
} | ||||
void PythonQtShell_QInputContext::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; | ||||
} | ||||
} | ||||
QInputContext::timerEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QInputContext::update() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "update"); | ||||
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; | ||||
} | ||||
} | ||||
QInputContext::update(); | ||||
} | ||||
void PythonQtShell_QInputContext::widgetDestroyed(QWidget* w) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "widgetDestroyed"); | ||||
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*)&w}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QInputContext::widgetDestroyed(w); | ||||
} | ||||
QInputContext* PythonQtWrapper_QInputContext::new_QInputContext(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QInputContext(parent); } | ||||
QList<QAction* > PythonQtWrapper_QInputContext::actions(QInputContext* theWrappedObject) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QInputContext*)theWrappedObject)->promoted_actions()); | ||||
} | ||||
bool PythonQtWrapper_QInputContext::filterEvent(QInputContext* theWrappedObject, const QEvent* event) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QInputContext*)theWrappedObject)->promoted_filterEvent(event)); | ||||
} | ||||
QWidget* PythonQtWrapper_QInputContext::focusWidget(QInputContext* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->focusWidget()); | ||||
} | ||||
QFont PythonQtWrapper_QInputContext::font(QInputContext* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QInputContext*)theWrappedObject)->promoted_font()); | ||||
} | ||||
void PythonQtWrapper_QInputContext::mouseHandler(QInputContext* theWrappedObject, int x, QMouseEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QInputContext*)theWrappedObject)->promoted_mouseHandler(x, event)); | ||||
} | ||||
void PythonQtWrapper_QInputContext::sendEvent(QInputContext* theWrappedObject, const QInputMethodEvent& event) | ||||
{ | ||||
( theWrappedObject->sendEvent(event)); | ||||
} | ||||
QTextFormat PythonQtWrapper_QInputContext::standardFormat(QInputContext* theWrappedObject, QInputContext::StandardFormat s) const | ||||
{ | ||||
return ( theWrappedObject->standardFormat(s)); | ||||
} | ||||
void PythonQtWrapper_QInputContext::update(QInputContext* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QInputContext*)theWrappedObject)->promoted_update()); | ||||
} | ||||
void PythonQtWrapper_QInputContext::widgetDestroyed(QInputContext* theWrappedObject, QWidget* w) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QInputContext*)theWrappedObject)->promoted_widgetDestroyed(w)); | ||||
} | ||||
QInputContextFactory* PythonQtWrapper_QInputContextFactory::new_QInputContextFactory() | ||||
{ | ||||
return new PythonQtShell_QInputContextFactory(); } | ||||
QInputContext* PythonQtWrapper_QInputContextFactory::static_QInputContextFactory_create(const QString& key, QObject* parent) | ||||
{ | ||||
return (QInputContextFactory::create(key, parent)); | ||||
} | ||||
QString PythonQtWrapper_QInputContextFactory::static_QInputContextFactory_description(const QString& key) | ||||
{ | ||||
return (QInputContextFactory::description(key)); | ||||
} | ||||
QString PythonQtWrapper_QInputContextFactory::static_QInputContextFactory_displayName(const QString& key) | ||||
{ | ||||
return (QInputContextFactory::displayName(key)); | ||||
} | ||||
QStringList PythonQtWrapper_QInputContextFactory::static_QInputContextFactory_keys() | ||||
{ | ||||
return (QInputContextFactory::keys()); | ||||
} | ||||
QStringList PythonQtWrapper_QInputContextFactory::static_QInputContextFactory_languages(const QString& key) | ||||
{ | ||||
return (QInputContextFactory::languages(key)); | ||||
} | ||||
void PythonQtShell_QInputContextPlugin::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; | ||||
} | ||||
} | ||||
QInputContextPlugin::childEvent(arg__1); | ||||
} | ||||
QInputContext* PythonQtShell_QInputContextPlugin::create(const QString& key) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "create"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QInputContext*" , "const QString&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QInputContext* returnValue; | ||||
void* args[2] = {NULL, (void*)&key}; | ||||
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("create", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QInputContext**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return 0; | ||||
} | ||||
void PythonQtShell_QInputContextPlugin::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; | ||||
} | ||||
} | ||||
QInputContextPlugin::customEvent(arg__1); | ||||
} | ||||
QString PythonQtShell_QInputContextPlugin::description(const QString& key) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "description"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QString" , "const QString&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QString returnValue; | ||||
void* args[2] = {NULL, (void*)&key}; | ||||
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("description", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QString*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QString(); | ||||
} | ||||
QString PythonQtShell_QInputContextPlugin::displayName(const QString& key) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "displayName"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QString" , "const QString&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QString returnValue; | ||||
void* args[2] = {NULL, (void*)&key}; | ||||
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("displayName", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QString*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QString(); | ||||
} | ||||
bool PythonQtShell_QInputContextPlugin::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 QInputContextPlugin::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QInputContextPlugin::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 QInputContextPlugin::eventFilter(arg__1, arg__2); | ||||
} | ||||
QStringList PythonQtShell_QInputContextPlugin::keys() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keys"); | ||||
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("keys", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QStringList*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QStringList(); | ||||
} | ||||
QStringList PythonQtShell_QInputContextPlugin::languages(const QString& key) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "languages"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QStringList" , "const QString&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QStringList returnValue; | ||||
void* args[2] = {NULL, (void*)&key}; | ||||
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("languages", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QStringList*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QStringList(); | ||||
} | ||||
void PythonQtShell_QInputContextPlugin::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; | ||||
} | ||||
} | ||||
QInputContextPlugin::timerEvent(arg__1); | ||||
} | ||||
QInputContextPlugin* PythonQtWrapper_QInputContextPlugin::new_QInputContextPlugin(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QInputContextPlugin(parent); } | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::accept(); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::actionEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::changeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::closeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::contextMenuEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::customEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QInputDialog::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 QInputDialog::devType(); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::done(result); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::dragEnterEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::dragLeaveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::dragMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::dropEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::enterEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QInputDialog::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 QInputDialog::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QInputDialog::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 QInputDialog::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::focusInEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QInputDialog::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 QInputDialog::focusNextPrevChild(next); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::focusOutEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QInputDialog::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 QInputDialog::heightForWidth(arg__1); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::hideEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::inputMethodEvent(arg__1); | ||||
} | ||||
QVariant PythonQtShell_QInputDialog::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 QInputDialog::inputMethodQuery(arg__1); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::keyPressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::keyReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::languageChange(); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::leaveEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QInputDialog::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 QInputDialog::metric(arg__1); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::mouseDoubleClickEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::mouseMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::mousePressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::mouseReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::moveEvent(arg__1); | ||||
} | ||||
QPaintEngine* PythonQtShell_QInputDialog::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 QInputDialog::paintEngine(); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::paintEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::reject(); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::resizeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::showEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::tabletEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::timerEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QInputDialog::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; | ||||
} | ||||
} | ||||
QInputDialog::wheelEvent(arg__1); | ||||
} | ||||
QInputDialog* PythonQtWrapper_QInputDialog::new_QInputDialog(QWidget* parent, Qt::WindowFlags flags) | ||||
{ | ||||
return new PythonQtShell_QInputDialog(parent, flags); } | ||||
QString PythonQtWrapper_QInputDialog::cancelButtonText(QInputDialog* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->cancelButtonText()); | ||||
} | ||||
QStringList PythonQtWrapper_QInputDialog::comboBoxItems(QInputDialog* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->comboBoxItems()); | ||||
} | ||||
void PythonQtWrapper_QInputDialog::done(QInputDialog* theWrappedObject, int result) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QInputDialog*)theWrappedObject)->promoted_done(result)); | ||||
} | ||||
int PythonQtWrapper_QInputDialog::doubleDecimals(QInputDialog* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->doubleDecimals()); | ||||
} | ||||
double PythonQtWrapper_QInputDialog::doubleMaximum(QInputDialog* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->doubleMaximum()); | ||||
} | ||||
double PythonQtWrapper_QInputDialog::doubleMinimum(QInputDialog* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->doubleMinimum()); | ||||
} | ||||
double PythonQtWrapper_QInputDialog::doubleValue(QInputDialog* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->doubleValue()); | ||||
} | ||||
double PythonQtWrapper_QInputDialog::static_QInputDialog_getDouble(QWidget* parent, const QString& title, const QString& label, double value, double minValue, double maxValue, int decimals, bool* ok, Qt::WindowFlags flags) | ||||
{ | ||||
return (QInputDialog::getDouble(parent, title, label, value, minValue, maxValue, decimals, ok, flags)); | ||||
} | ||||
int PythonQtWrapper_QInputDialog::static_QInputDialog_getInt(QWidget* parent, const QString& title, const QString& label, int value, int minValue, int maxValue, int step, bool* ok, Qt::WindowFlags flags) | ||||
{ | ||||
return (QInputDialog::getInt(parent, title, label, value, minValue, maxValue, step, ok, flags)); | ||||
} | ||||
int PythonQtWrapper_QInputDialog::static_QInputDialog_getInteger(QWidget* parent, const QString& title, const QString& label, int value, int minValue, int maxValue, int step, bool* ok, Qt::WindowFlags flags) | ||||
{ | ||||
return (QInputDialog::getInteger(parent, title, label, value, minValue, maxValue, step, ok, flags)); | ||||
} | ||||
QString PythonQtWrapper_QInputDialog::static_QInputDialog_getItem(QWidget* parent, const QString& title, const QString& label, const QStringList& items, int current, bool editable, bool* ok, Qt::WindowFlags flags) | ||||
{ | ||||
return (QInputDialog::getItem(parent, title, label, items, current, editable, ok, flags)); | ||||
} | ||||
QString PythonQtWrapper_QInputDialog::static_QInputDialog_getText(QWidget* parent, const QString& title, const QString& label, QLineEdit::EchoMode echo, const QString& text, bool* ok, Qt::WindowFlags flags) | ||||
{ | ||||
return (QInputDialog::getText(parent, title, label, echo, text, ok, flags)); | ||||
} | ||||
QInputDialog::InputMode PythonQtWrapper_QInputDialog::inputMode(QInputDialog* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->inputMode()); | ||||
} | ||||
int PythonQtWrapper_QInputDialog::intMaximum(QInputDialog* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->intMaximum()); | ||||
} | ||||
int PythonQtWrapper_QInputDialog::intMinimum(QInputDialog* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->intMinimum()); | ||||
} | ||||
int PythonQtWrapper_QInputDialog::intStep(QInputDialog* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->intStep()); | ||||
} | ||||
int PythonQtWrapper_QInputDialog::intValue(QInputDialog* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->intValue()); | ||||
} | ||||
bool PythonQtWrapper_QInputDialog::isComboBoxEditable(QInputDialog* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isComboBoxEditable()); | ||||
} | ||||
QString PythonQtWrapper_QInputDialog::labelText(QInputDialog* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->labelText()); | ||||
} | ||||
QSize PythonQtWrapper_QInputDialog::minimumSizeHint(QInputDialog* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->minimumSizeHint()); | ||||
} | ||||
QString PythonQtWrapper_QInputDialog::okButtonText(QInputDialog* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->okButtonText()); | ||||
} | ||||
void PythonQtWrapper_QInputDialog::open(QInputDialog* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->open()); | ||||
} | ||||
void PythonQtWrapper_QInputDialog::open(QInputDialog* theWrappedObject, QObject* receiver, const char* member) | ||||
{ | ||||
( theWrappedObject->open(receiver, member)); | ||||
} | ||||
QInputDialog::InputDialogOptions PythonQtWrapper_QInputDialog::options(QInputDialog* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->options()); | ||||
} | ||||
void PythonQtWrapper_QInputDialog::setCancelButtonText(QInputDialog* theWrappedObject, const QString& text) | ||||
{ | ||||
( theWrappedObject->setCancelButtonText(text)); | ||||
} | ||||
void PythonQtWrapper_QInputDialog::setComboBoxEditable(QInputDialog* theWrappedObject, bool editable) | ||||
{ | ||||
( theWrappedObject->setComboBoxEditable(editable)); | ||||
} | ||||
void PythonQtWrapper_QInputDialog::setComboBoxItems(QInputDialog* theWrappedObject, const QStringList& items) | ||||
{ | ||||
( theWrappedObject->setComboBoxItems(items)); | ||||
} | ||||
void PythonQtWrapper_QInputDialog::setDoubleDecimals(QInputDialog* theWrappedObject, int decimals) | ||||
{ | ||||
( theWrappedObject->setDoubleDecimals(decimals)); | ||||
} | ||||
void PythonQtWrapper_QInputDialog::setDoubleMaximum(QInputDialog* theWrappedObject, double max) | ||||
{ | ||||
( theWrappedObject->setDoubleMaximum(max)); | ||||
} | ||||
void PythonQtWrapper_QInputDialog::setDoubleMinimum(QInputDialog* theWrappedObject, double min) | ||||
{ | ||||
( theWrappedObject->setDoubleMinimum(min)); | ||||
} | ||||
void PythonQtWrapper_QInputDialog::setDoubleRange(QInputDialog* theWrappedObject, double min, double max) | ||||
{ | ||||
( theWrappedObject->setDoubleRange(min, max)); | ||||
} | ||||
void PythonQtWrapper_QInputDialog::setDoubleValue(QInputDialog* theWrappedObject, double value) | ||||
{ | ||||
( theWrappedObject->setDoubleValue(value)); | ||||
} | ||||
void PythonQtWrapper_QInputDialog::setInputMode(QInputDialog* theWrappedObject, QInputDialog::InputMode mode) | ||||
{ | ||||
( theWrappedObject->setInputMode(mode)); | ||||
} | ||||
void PythonQtWrapper_QInputDialog::setIntMaximum(QInputDialog* theWrappedObject, int max) | ||||
{ | ||||
( theWrappedObject->setIntMaximum(max)); | ||||
} | ||||
void PythonQtWrapper_QInputDialog::setIntMinimum(QInputDialog* theWrappedObject, int min) | ||||
{ | ||||
( theWrappedObject->setIntMinimum(min)); | ||||
} | ||||
void PythonQtWrapper_QInputDialog::setIntRange(QInputDialog* theWrappedObject, int min, int max) | ||||
{ | ||||
( theWrappedObject->setIntRange(min, max)); | ||||
} | ||||
void PythonQtWrapper_QInputDialog::setIntStep(QInputDialog* theWrappedObject, int step) | ||||
{ | ||||
( theWrappedObject->setIntStep(step)); | ||||
} | ||||
void PythonQtWrapper_QInputDialog::setIntValue(QInputDialog* theWrappedObject, int value) | ||||
{ | ||||
( theWrappedObject->setIntValue(value)); | ||||
} | ||||
void PythonQtWrapper_QInputDialog::setLabelText(QInputDialog* theWrappedObject, const QString& text) | ||||
{ | ||||
( theWrappedObject->setLabelText(text)); | ||||
} | ||||
void PythonQtWrapper_QInputDialog::setOkButtonText(QInputDialog* theWrappedObject, const QString& text) | ||||
{ | ||||
( theWrappedObject->setOkButtonText(text)); | ||||
} | ||||
void PythonQtWrapper_QInputDialog::setOption(QInputDialog* theWrappedObject, QInputDialog::InputDialogOption option, bool on) | ||||
{ | ||||
( theWrappedObject->setOption(option, on)); | ||||
} | ||||
void PythonQtWrapper_QInputDialog::setOptions(QInputDialog* theWrappedObject, QInputDialog::InputDialogOptions options) | ||||
{ | ||||
( theWrappedObject->setOptions(options)); | ||||
} | ||||
void PythonQtWrapper_QInputDialog::setTextEchoMode(QInputDialog* theWrappedObject, QLineEdit::EchoMode mode) | ||||
{ | ||||
( theWrappedObject->setTextEchoMode(mode)); | ||||
} | ||||
void PythonQtWrapper_QInputDialog::setTextValue(QInputDialog* theWrappedObject, const QString& text) | ||||
{ | ||||
( theWrappedObject->setTextValue(text)); | ||||
} | ||||
void PythonQtWrapper_QInputDialog::setVisible(QInputDialog* theWrappedObject, bool visible) | ||||
{ | ||||
( theWrappedObject->setVisible(visible)); | ||||
} | ||||
QSize PythonQtWrapper_QInputDialog::sizeHint(QInputDialog* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->sizeHint()); | ||||
} | ||||
bool PythonQtWrapper_QInputDialog::testOption(QInputDialog* theWrappedObject, QInputDialog::InputDialogOption option) const | ||||
{ | ||||
return ( theWrappedObject->testOption(option)); | ||||
} | ||||
QLineEdit::EchoMode PythonQtWrapper_QInputDialog::textEchoMode(QInputDialog* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->textEchoMode()); | ||||
} | ||||
QString PythonQtWrapper_QInputDialog::textValue(QInputDialog* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->textValue()); | ||||
} | ||||
QInputEvent* PythonQtWrapper_QInputEvent::new_QInputEvent(QEvent::Type type, Qt::KeyboardModifiers modifiers) | ||||
{ | ||||
return new PythonQtShell_QInputEvent(type, modifiers); } | ||||
Qt::KeyboardModifiers PythonQtWrapper_QInputEvent::modifiers(QInputEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->modifiers()); | ||||
} | ||||
void PythonQtWrapper_QInputEvent::setModifiers(QInputEvent* theWrappedObject, Qt::KeyboardModifiers amodifiers) | ||||
{ | ||||
( theWrappedObject->setModifiers(amodifiers)); | ||||
} | ||||
void PythonQtShell_QIntValidator::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; | ||||
} | ||||
} | ||||
QIntValidator::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QIntValidator::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; | ||||
} | ||||
} | ||||
QIntValidator::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QIntValidator::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 QIntValidator::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QIntValidator::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 QIntValidator::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QIntValidator::fixup(QString& arg__1) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "fixup"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QString&"}; | ||||
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; | ||||
} | ||||
} | ||||
QIntValidator::fixup(arg__1); | ||||
} | ||||
void PythonQtShell_QIntValidator::setRange(int bottom, int top) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setRange"); | ||||
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*)&bottom, (void*)&top}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QIntValidator::setRange(bottom, top); | ||||
} | ||||
void PythonQtShell_QIntValidator::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; | ||||
} | ||||
} | ||||
QIntValidator::timerEvent(arg__1); | ||||
} | ||||
QValidator::State PythonQtShell_QIntValidator::validate(QString& arg__1, int& arg__2) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "validate"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QValidator::State" , "QString&" , "int&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
QValidator::State 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("validate", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QValidator::State*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QIntValidator::validate(arg__1, arg__2); | ||||
} | ||||
QIntValidator* PythonQtWrapper_QIntValidator::new_QIntValidator(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QIntValidator(parent); } | ||||
QIntValidator* PythonQtWrapper_QIntValidator::new_QIntValidator(int bottom, int top, QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QIntValidator(bottom, top, parent); } | ||||
int PythonQtWrapper_QIntValidator::bottom(QIntValidator* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->bottom()); | ||||
} | ||||
void PythonQtWrapper_QIntValidator::setBottom(QIntValidator* theWrappedObject, int arg__1) | ||||
{ | ||||
( theWrappedObject->setBottom(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QIntValidator::setRange(QIntValidator* theWrappedObject, int bottom, int top) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QIntValidator*)theWrappedObject)->promoted_setRange(bottom, top)); | ||||
} | ||||
void PythonQtWrapper_QIntValidator::setTop(QIntValidator* theWrappedObject, int arg__1) | ||||
{ | ||||
( theWrappedObject->setTop(arg__1)); | ||||
} | ||||
int PythonQtWrapper_QIntValidator::top(QIntValidator* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->top()); | ||||
} | ||||
QValidator::State PythonQtWrapper_QIntValidator::validate(QIntValidator* theWrappedObject, QString& arg__1, int& arg__2) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QIntValidator*)theWrappedObject)->promoted_validate(arg__1, arg__2)); | ||||
} | ||||
void PythonQtShell_QItemDelegate::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; | ||||
} | ||||
} | ||||
QItemDelegate::childEvent(arg__1); | ||||
} | ||||
QWidget* PythonQtShell_QItemDelegate::createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "createEditor"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QWidget*" , "QWidget*" , "const QStyleOptionViewItem&" , "const QModelIndex&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
QWidget* returnValue; | ||||
void* args[4] = {NULL, (void*)&parent, (void*)&option, (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("createEditor", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QWidget**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QItemDelegate::createEditor(parent, option, index); | ||||
} | ||||
void PythonQtShell_QItemDelegate::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; | ||||
} | ||||
} | ||||
QItemDelegate::customEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QItemDelegate::drawCheck(QPainter* painter, const QStyleOptionViewItem& option, const QRect& rect, Qt::CheckState state) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawCheck"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPainter*" , "const QStyleOptionViewItem&" , "const QRect&" , "Qt::CheckState"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
void* args[5] = {NULL, (void*)&painter, (void*)&option, (void*)&rect, (void*)&state}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QItemDelegate::drawCheck(painter, option, rect, state); | ||||
} | ||||
void PythonQtShell_QItemDelegate::drawDecoration(QPainter* painter, const QStyleOptionViewItem& option, const QRect& rect, const QPixmap& pixmap) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawDecoration"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPainter*" , "const QStyleOptionViewItem&" , "const QRect&" , "const QPixmap&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
void* args[5] = {NULL, (void*)&painter, (void*)&option, (void*)&rect, (void*)&pixmap}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QItemDelegate::drawDecoration(painter, option, rect, pixmap); | ||||
} | ||||
void PythonQtShell_QItemDelegate::drawDisplay(QPainter* painter, const QStyleOptionViewItem& option, const QRect& rect, const QString& text) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawDisplay"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPainter*" , "const QStyleOptionViewItem&" , "const QRect&" , "const QString&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
void* args[5] = {NULL, (void*)&painter, (void*)&option, (void*)&rect, (void*)&text}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QItemDelegate::drawDisplay(painter, option, rect, text); | ||||
} | ||||
void PythonQtShell_QItemDelegate::drawFocus(QPainter* painter, const QStyleOptionViewItem& option, const QRect& rect) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawFocus"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPainter*" , "const QStyleOptionViewItem&" , "const QRect&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
void* args[4] = {NULL, (void*)&painter, (void*)&option, (void*)&rect}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QItemDelegate::drawFocus(painter, option, rect); | ||||
} | ||||
bool PythonQtShell_QItemDelegate::editorEvent(QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& option, const QModelIndex& index) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "editorEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QEvent*" , "QAbstractItemModel*" , "const QStyleOptionViewItem&" , "const QModelIndex&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
bool returnValue; | ||||
void* args[5] = {NULL, (void*)&event, (void*)&model, (void*)&option, (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("editorEvent", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QItemDelegate::editorEvent(event, model, option, index); | ||||
} | ||||
bool PythonQtShell_QItemDelegate::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 QItemDelegate::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QItemDelegate::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 QItemDelegate::eventFilter(object, event); | ||||
} | ||||
void PythonQtShell_QItemDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paint"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPainter*" , "const QStyleOptionViewItem&" , "const QModelIndex&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
void* args[4] = {NULL, (void*)&painter, (void*)&option, (void*)&index}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QItemDelegate::paint(painter, option, index); | ||||
} | ||||
void PythonQtShell_QItemDelegate::setEditorData(QWidget* editor, const QModelIndex& index) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setEditorData"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QWidget*" , "const QModelIndex&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&editor, (void*)&index}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QItemDelegate::setEditorData(editor, index); | ||||
} | ||||
void PythonQtShell_QItemDelegate::setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setModelData"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QWidget*" , "QAbstractItemModel*" , "const QModelIndex&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
void* args[4] = {NULL, (void*)&editor, (void*)&model, (void*)&index}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QItemDelegate::setModelData(editor, model, index); | ||||
} | ||||
QSize PythonQtShell_QItemDelegate::sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sizeHint"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QSize" , "const QStyleOptionViewItem&" , "const QModelIndex&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
QSize returnValue; | ||||
void* args[3] = {NULL, (void*)&option, (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("sizeHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QItemDelegate::sizeHint(option, index); | ||||
} | ||||
void PythonQtShell_QItemDelegate::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; | ||||
} | ||||
} | ||||
QItemDelegate::timerEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QItemDelegate::updateEditorGeometry(QWidget* editor, const QStyleOptionViewItem& option, const QModelIndex& index) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateEditorGeometry"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QWidget*" , "const QStyleOptionViewItem&" , "const QModelIndex&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
void* args[4] = {NULL, (void*)&editor, (void*)&option, (void*)&index}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QItemDelegate::updateEditorGeometry(editor, option, index); | ||||
} | ||||
QItemDelegate* PythonQtWrapper_QItemDelegate::new_QItemDelegate(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QItemDelegate(parent); } | ||||
QWidget* PythonQtWrapper_QItemDelegate::createEditor(QItemDelegate* theWrappedObject, QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QItemDelegate*)theWrappedObject)->promoted_createEditor(parent, option, index)); | ||||
} | ||||
void PythonQtWrapper_QItemDelegate::drawCheck(QItemDelegate* theWrappedObject, QPainter* painter, const QStyleOptionViewItem& option, const QRect& rect, Qt::CheckState state) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QItemDelegate*)theWrappedObject)->promoted_drawCheck(painter, option, rect, state)); | ||||
} | ||||
void PythonQtWrapper_QItemDelegate::drawDecoration(QItemDelegate* theWrappedObject, QPainter* painter, const QStyleOptionViewItem& option, const QRect& rect, const QPixmap& pixmap) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QItemDelegate*)theWrappedObject)->promoted_drawDecoration(painter, option, rect, pixmap)); | ||||
} | ||||
void PythonQtWrapper_QItemDelegate::drawDisplay(QItemDelegate* theWrappedObject, QPainter* painter, const QStyleOptionViewItem& option, const QRect& rect, const QString& text) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QItemDelegate*)theWrappedObject)->promoted_drawDisplay(painter, option, rect, text)); | ||||
} | ||||
void PythonQtWrapper_QItemDelegate::drawFocus(QItemDelegate* theWrappedObject, QPainter* painter, const QStyleOptionViewItem& option, const QRect& rect) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QItemDelegate*)theWrappedObject)->promoted_drawFocus(painter, option, rect)); | ||||
} | ||||
bool PythonQtWrapper_QItemDelegate::editorEvent(QItemDelegate* theWrappedObject, QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& option, const QModelIndex& index) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QItemDelegate*)theWrappedObject)->promoted_editorEvent(event, model, option, index)); | ||||
} | ||||
bool PythonQtWrapper_QItemDelegate::eventFilter(QItemDelegate* theWrappedObject, QObject* object, QEvent* event) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QItemDelegate*)theWrappedObject)->promoted_eventFilter(object, event)); | ||||
} | ||||
bool PythonQtWrapper_QItemDelegate::hasClipping(QItemDelegate* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->hasClipping()); | ||||
} | ||||
QItemEditorFactory* PythonQtWrapper_QItemDelegate::itemEditorFactory(QItemDelegate* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->itemEditorFactory()); | ||||
} | ||||
void PythonQtWrapper_QItemDelegate::paint(QItemDelegate* theWrappedObject, QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QItemDelegate*)theWrappedObject)->promoted_paint(painter, option, index)); | ||||
} | ||||
void PythonQtWrapper_QItemDelegate::setClipping(QItemDelegate* theWrappedObject, bool clip) | ||||
{ | ||||
( theWrappedObject->setClipping(clip)); | ||||
} | ||||
void PythonQtWrapper_QItemDelegate::setEditorData(QItemDelegate* theWrappedObject, QWidget* editor, const QModelIndex& index) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QItemDelegate*)theWrappedObject)->promoted_setEditorData(editor, index)); | ||||
} | ||||
void PythonQtWrapper_QItemDelegate::setItemEditorFactory(QItemDelegate* theWrappedObject, QItemEditorFactory* factory) | ||||
{ | ||||
( theWrappedObject->setItemEditorFactory(factory)); | ||||
} | ||||
void PythonQtWrapper_QItemDelegate::setModelData(QItemDelegate* theWrappedObject, QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QItemDelegate*)theWrappedObject)->promoted_setModelData(editor, model, index)); | ||||
} | ||||
QSize PythonQtWrapper_QItemDelegate::sizeHint(QItemDelegate* theWrappedObject, const QStyleOptionViewItem& option, const QModelIndex& index) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QItemDelegate*)theWrappedObject)->promoted_sizeHint(option, index)); | ||||
} | ||||
void PythonQtWrapper_QItemDelegate::updateEditorGeometry(QItemDelegate* theWrappedObject, QWidget* editor, const QStyleOptionViewItem& option, const QModelIndex& index) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QItemDelegate*)theWrappedObject)->promoted_updateEditorGeometry(editor, option, index)); | ||||
} | ||||
QWidget* PythonQtShell_QItemEditorCreatorBase::createWidget(QWidget* parent) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "createWidget"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QWidget*" , "QWidget*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QWidget* returnValue; | ||||
void* args[2] = {NULL, (void*)&parent}; | ||||
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("createWidget", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QWidget**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return 0; | ||||
} | ||||
QByteArray PythonQtShell_QItemEditorCreatorBase::valuePropertyName() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "valuePropertyName"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QByteArray"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QByteArray 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("valuePropertyName", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QByteArray*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QByteArray(); | ||||
} | ||||
QItemEditorCreatorBase* PythonQtWrapper_QItemEditorCreatorBase::new_QItemEditorCreatorBase() | ||||
{ | ||||
return new PythonQtShell_QItemEditorCreatorBase(); } | ||||
QWidget* PythonQtShell_QItemEditorFactory::createEditor(QVariant::Type type, QWidget* parent) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "createEditor"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QWidget*" , "QVariant::Type" , "QWidget*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
QWidget* returnValue; | ||||
void* args[3] = {NULL, (void*)&type, (void*)&parent}; | ||||
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("createEditor", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QWidget**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QItemEditorFactory::createEditor(type, parent); | ||||
} | ||||
QByteArray PythonQtShell_QItemEditorFactory::valuePropertyName(QVariant::Type type) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "valuePropertyName"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QByteArray" , "QVariant::Type"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QByteArray returnValue; | ||||
void* args[2] = {NULL, (void*)&type}; | ||||
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("valuePropertyName", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QByteArray*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QItemEditorFactory::valuePropertyName(type); | ||||
} | ||||
QItemEditorFactory* PythonQtWrapper_QItemEditorFactory::new_QItemEditorFactory() | ||||
{ | ||||
return new PythonQtShell_QItemEditorFactory(); } | ||||
QWidget* PythonQtWrapper_QItemEditorFactory::createEditor(QItemEditorFactory* theWrappedObject, QVariant::Type type, QWidget* parent) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QItemEditorFactory*)theWrappedObject)->promoted_createEditor(type, parent)); | ||||
} | ||||
const QItemEditorFactory* PythonQtWrapper_QItemEditorFactory::static_QItemEditorFactory_defaultFactory() | ||||
{ | ||||
return (QItemEditorFactory::defaultFactory()); | ||||
} | ||||
void PythonQtWrapper_QItemEditorFactory::registerEditor(QItemEditorFactory* theWrappedObject, QVariant::Type type, QItemEditorCreatorBase* creator) | ||||
{ | ||||
( theWrappedObject->registerEditor(type, creator)); | ||||
} | ||||
void PythonQtWrapper_QItemEditorFactory::static_QItemEditorFactory_setDefaultFactory(QItemEditorFactory* factory) | ||||
{ | ||||
(QItemEditorFactory::setDefaultFactory(factory)); | ||||
} | ||||
QByteArray PythonQtWrapper_QItemEditorFactory::valuePropertyName(QItemEditorFactory* theWrappedObject, QVariant::Type type) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QItemEditorFactory*)theWrappedObject)->promoted_valuePropertyName(type)); | ||||
} | ||||
QItemSelection* PythonQtWrapper_QItemSelection::new_QItemSelection() | ||||
{ | ||||
return new QItemSelection(); } | ||||
QItemSelection* PythonQtWrapper_QItemSelection::new_QItemSelection(const QModelIndex& topLeft, const QModelIndex& bottomRight) | ||||
{ | ||||
return new QItemSelection(topLeft, bottomRight); } | ||||
void PythonQtWrapper_QItemSelection::append(QItemSelection* theWrappedObject, const QItemSelectionRange& t) | ||||
{ | ||||
( theWrappedObject->append(t)); | ||||
} | ||||
void PythonQtWrapper_QItemSelection::append(QItemSelection* theWrappedObject, const QList<QItemSelectionRange >& t) | ||||
{ | ||||
( theWrappedObject->append(t)); | ||||
} | ||||
const QItemSelectionRange* PythonQtWrapper_QItemSelection::at(QItemSelection* theWrappedObject, int i) const | ||||
{ | ||||
return &( theWrappedObject->at(i)); | ||||
} | ||||
const QItemSelectionRange* PythonQtWrapper_QItemSelection::back(QItemSelection* theWrappedObject) const | ||||
{ | ||||
return &( theWrappedObject->back()); | ||||
} | ||||
void PythonQtWrapper_QItemSelection::clear(QItemSelection* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->clear()); | ||||
} | ||||
bool PythonQtWrapper_QItemSelection::contains(QItemSelection* theWrappedObject, const QModelIndex& index) const | ||||
{ | ||||
return ( theWrappedObject->contains(index)); | ||||
} | ||||
int PythonQtWrapper_QItemSelection::count(QItemSelection* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->count()); | ||||
} | ||||
int PythonQtWrapper_QItemSelection::count(QItemSelection* theWrappedObject, const QItemSelectionRange& t) const | ||||
{ | ||||
return ( theWrappedObject->count(t)); | ||||
} | ||||
void PythonQtWrapper_QItemSelection::detachShared(QItemSelection* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->detachShared()); | ||||
} | ||||
bool PythonQtWrapper_QItemSelection::empty(QItemSelection* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->empty()); | ||||
} | ||||
bool PythonQtWrapper_QItemSelection::endsWith(QItemSelection* theWrappedObject, const QItemSelectionRange& t) const | ||||
{ | ||||
return ( theWrappedObject->endsWith(t)); | ||||
} | ||||
const QItemSelectionRange* PythonQtWrapper_QItemSelection::first(QItemSelection* theWrappedObject) const | ||||
{ | ||||
return &( theWrappedObject->first()); | ||||
} | ||||
QList<QItemSelectionRange > PythonQtWrapper_QItemSelection::static_QItemSelection_fromVector(const QVector<QItemSelectionRange >& vector) | ||||
{ | ||||
return (QItemSelection::fromVector(vector)); | ||||
} | ||||
const QItemSelectionRange* PythonQtWrapper_QItemSelection::front(QItemSelection* theWrappedObject) const | ||||
{ | ||||
return &( theWrappedObject->front()); | ||||
} | ||||
int PythonQtWrapper_QItemSelection::indexOf(QItemSelection* theWrappedObject, const QItemSelectionRange& t, int from) const | ||||
{ | ||||
return ( theWrappedObject->indexOf(t, from)); | ||||
} | ||||
QList<QModelIndex > PythonQtWrapper_QItemSelection::indexes(QItemSelection* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->indexes()); | ||||
} | ||||
bool PythonQtWrapper_QItemSelection::isEmpty(QItemSelection* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isEmpty()); | ||||
} | ||||
const QItemSelectionRange* PythonQtWrapper_QItemSelection::last(QItemSelection* theWrappedObject) const | ||||
{ | ||||
return &( theWrappedObject->last()); | ||||
} | ||||
int PythonQtWrapper_QItemSelection::lastIndexOf(QItemSelection* theWrappedObject, const QItemSelectionRange& t, int from) const | ||||
{ | ||||
return ( theWrappedObject->lastIndexOf(t, from)); | ||||
} | ||||
int PythonQtWrapper_QItemSelection::length(QItemSelection* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->length()); | ||||
} | ||||
void PythonQtWrapper_QItemSelection::merge(QItemSelection* theWrappedObject, const QItemSelection& other, QItemSelectionModel::SelectionFlags command) | ||||
{ | ||||
( theWrappedObject->merge(other, command)); | ||||
} | ||||
QList<QItemSelectionRange > PythonQtWrapper_QItemSelection::mid(QItemSelection* theWrappedObject, int pos, int length) const | ||||
{ | ||||
return ( theWrappedObject->mid(pos, length)); | ||||
} | ||||
void PythonQtWrapper_QItemSelection::move(QItemSelection* theWrappedObject, int from, int to) | ||||
{ | ||||
( theWrappedObject->move(from, to)); | ||||
} | ||||
bool PythonQtWrapper_QItemSelection::__ne__(QItemSelection* theWrappedObject, const QList<QItemSelectionRange >& l) const | ||||
{ | ||||
return ( (*theWrappedObject)!= l); | ||||
} | ||||
bool PythonQtWrapper_QItemSelection::__eq__(QItemSelection* theWrappedObject, const QList<QItemSelectionRange >& l) const | ||||
{ | ||||
return ( (*theWrappedObject)== l); | ||||
} | ||||
void PythonQtWrapper_QItemSelection::pop_back(QItemSelection* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->pop_back()); | ||||
} | ||||
void PythonQtWrapper_QItemSelection::pop_front(QItemSelection* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->pop_front()); | ||||
} | ||||
void PythonQtWrapper_QItemSelection::prepend(QItemSelection* theWrappedObject, const QItemSelectionRange& t) | ||||
{ | ||||
( theWrappedObject->prepend(t)); | ||||
} | ||||
void PythonQtWrapper_QItemSelection::push_back(QItemSelection* theWrappedObject, const QItemSelectionRange& t) | ||||
{ | ||||
( theWrappedObject->push_back(t)); | ||||
} | ||||
void PythonQtWrapper_QItemSelection::push_front(QItemSelection* theWrappedObject, const QItemSelectionRange& t) | ||||
{ | ||||
( theWrappedObject->push_front(t)); | ||||
} | ||||
int PythonQtWrapper_QItemSelection::removeAll(QItemSelection* theWrappedObject, const QItemSelectionRange& t) | ||||
{ | ||||
return ( theWrappedObject->removeAll(t)); | ||||
} | ||||
void PythonQtWrapper_QItemSelection::removeAt(QItemSelection* theWrappedObject, int i) | ||||
{ | ||||
( theWrappedObject->removeAt(i)); | ||||
} | ||||
void PythonQtWrapper_QItemSelection::removeFirst(QItemSelection* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->removeFirst()); | ||||
} | ||||
void PythonQtWrapper_QItemSelection::removeLast(QItemSelection* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->removeLast()); | ||||
} | ||||
bool PythonQtWrapper_QItemSelection::removeOne(QItemSelection* theWrappedObject, const QItemSelectionRange& t) | ||||
{ | ||||
return ( theWrappedObject->removeOne(t)); | ||||
} | ||||
void PythonQtWrapper_QItemSelection::replace(QItemSelection* theWrappedObject, int i, const QItemSelectionRange& t) | ||||
{ | ||||
( theWrappedObject->replace(i, t)); | ||||
} | ||||
void PythonQtWrapper_QItemSelection::select(QItemSelection* theWrappedObject, const QModelIndex& topLeft, const QModelIndex& bottomRight) | ||||
{ | ||||
( theWrappedObject->select(topLeft, bottomRight)); | ||||
} | ||||
void PythonQtWrapper_QItemSelection::setSharable(QItemSelection* theWrappedObject, bool sharable) | ||||
{ | ||||
( theWrappedObject->setSharable(sharable)); | ||||
} | ||||
int PythonQtWrapper_QItemSelection::size(QItemSelection* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->size()); | ||||
} | ||||
void PythonQtWrapper_QItemSelection::static_QItemSelection_split(const QItemSelectionRange& range, const QItemSelectionRange& other, QItemSelection* result) | ||||
{ | ||||
(QItemSelection::split(range, other, result)); | ||||
} | ||||
bool PythonQtWrapper_QItemSelection::startsWith(QItemSelection* theWrappedObject, const QItemSelectionRange& t) const | ||||
{ | ||||
return ( theWrappedObject->startsWith(t)); | ||||
} | ||||
void PythonQtWrapper_QItemSelection::swap(QItemSelection* theWrappedObject, int i, int j) | ||||
{ | ||||
( theWrappedObject->swap(i, j)); | ||||
} | ||||
QItemSelectionRange PythonQtWrapper_QItemSelection::takeAt(QItemSelection* theWrappedObject, int i) | ||||
{ | ||||
return ( theWrappedObject->takeAt(i)); | ||||
} | ||||
QItemSelectionRange PythonQtWrapper_QItemSelection::takeFirst(QItemSelection* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->takeFirst()); | ||||
} | ||||
QItemSelectionRange PythonQtWrapper_QItemSelection::takeLast(QItemSelection* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->takeLast()); | ||||
} | ||||
QVector<QItemSelectionRange > PythonQtWrapper_QItemSelection::toVector(QItemSelection* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toVector()); | ||||
} | ||||
QItemSelectionRange PythonQtWrapper_QItemSelection::value(QItemSelection* theWrappedObject, int i) const | ||||
{ | ||||
return ( theWrappedObject->value(i)); | ||||
} | ||||
QItemSelectionRange PythonQtWrapper_QItemSelection::value(QItemSelection* theWrappedObject, int i, const QItemSelectionRange& defaultValue) const | ||||
{ | ||||
return ( theWrappedObject->value(i, defaultValue)); | ||||
} | ||||
void PythonQtShell_QItemSelectionModel::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; | ||||
} | ||||
} | ||||
QItemSelectionModel::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QItemSelectionModel::clear() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "clear"); | ||||
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; | ||||
} | ||||
} | ||||
QItemSelectionModel::clear(); | ||||
} | ||||
void PythonQtShell_QItemSelectionModel::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; | ||||
} | ||||
} | ||||
QItemSelectionModel::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QItemSelectionModel::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 QItemSelectionModel::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QItemSelectionModel::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 QItemSelectionModel::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QItemSelectionModel::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; | ||||
} | ||||
} | ||||
QItemSelectionModel::reset(); | ||||
} | ||||
void PythonQtShell_QItemSelectionModel::select(const QItemSelection& selection, QItemSelectionModel::SelectionFlags command) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "select"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QItemSelection&" , "QItemSelectionModel::SelectionFlags"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&selection, (void*)&command}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QItemSelectionModel::select(selection, command); | ||||
} | ||||
void PythonQtShell_QItemSelectionModel::select(const QModelIndex& index, QItemSelectionModel::SelectionFlags command) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "select"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QModelIndex&" , "QItemSelectionModel::SelectionFlags"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&index, (void*)&command}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QItemSelectionModel::select(index, command); | ||||
} | ||||
void PythonQtShell_QItemSelectionModel::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; | ||||
} | ||||
} | ||||
QItemSelectionModel::timerEvent(arg__1); | ||||
} | ||||
QItemSelectionModel* PythonQtWrapper_QItemSelectionModel::new_QItemSelectionModel(QAbstractItemModel* model) | ||||
{ | ||||
return new PythonQtShell_QItemSelectionModel(model); } | ||||
QItemSelectionModel* PythonQtWrapper_QItemSelectionModel::new_QItemSelectionModel(QAbstractItemModel* model, QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QItemSelectionModel(model, parent); } | ||||
bool PythonQtWrapper_QItemSelectionModel::columnIntersectsSelection(QItemSelectionModel* theWrappedObject, int column, const QModelIndex& parent) const | ||||
{ | ||||
return ( theWrappedObject->columnIntersectsSelection(column, parent)); | ||||
} | ||||
QModelIndex PythonQtWrapper_QItemSelectionModel::currentIndex(QItemSelectionModel* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->currentIndex()); | ||||
} | ||||
bool PythonQtWrapper_QItemSelectionModel::hasSelection(QItemSelectionModel* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->hasSelection()); | ||||
} | ||||
bool PythonQtWrapper_QItemSelectionModel::isColumnSelected(QItemSelectionModel* theWrappedObject, int column, const QModelIndex& parent) const | ||||
{ | ||||
return ( theWrappedObject->isColumnSelected(column, parent)); | ||||
} | ||||
bool PythonQtWrapper_QItemSelectionModel::isRowSelected(QItemSelectionModel* theWrappedObject, int row, const QModelIndex& parent) const | ||||
{ | ||||
return ( theWrappedObject->isRowSelected(row, parent)); | ||||
} | ||||
bool PythonQtWrapper_QItemSelectionModel::isSelected(QItemSelectionModel* theWrappedObject, const QModelIndex& index) const | ||||
{ | ||||
return ( theWrappedObject->isSelected(index)); | ||||
} | ||||
const QAbstractItemModel* PythonQtWrapper_QItemSelectionModel::model(QItemSelectionModel* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->model()); | ||||
} | ||||
bool PythonQtWrapper_QItemSelectionModel::rowIntersectsSelection(QItemSelectionModel* theWrappedObject, int row, const QModelIndex& parent) const | ||||
{ | ||||
return ( theWrappedObject->rowIntersectsSelection(row, parent)); | ||||
} | ||||
QList<QModelIndex > PythonQtWrapper_QItemSelectionModel::selectedColumns(QItemSelectionModel* theWrappedObject, int row) const | ||||
{ | ||||
return ( theWrappedObject->selectedColumns(row)); | ||||
} | ||||
QList<QModelIndex > PythonQtWrapper_QItemSelectionModel::selectedIndexes(QItemSelectionModel* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selectedIndexes()); | ||||
} | ||||
QList<QModelIndex > PythonQtWrapper_QItemSelectionModel::selectedRows(QItemSelectionModel* theWrappedObject, int column) const | ||||
{ | ||||
return ( theWrappedObject->selectedRows(column)); | ||||
} | ||||
const QItemSelection PythonQtWrapper_QItemSelectionModel::selection(QItemSelectionModel* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->selection()); | ||||
} | ||||
QItemSelectionRange* PythonQtWrapper_QItemSelectionRange::new_QItemSelectionRange() | ||||
{ | ||||
return new QItemSelectionRange(); } | ||||
QItemSelectionRange* PythonQtWrapper_QItemSelectionRange::new_QItemSelectionRange(const QItemSelectionRange& other) | ||||
{ | ||||
return new QItemSelectionRange(other); } | ||||
QItemSelectionRange* PythonQtWrapper_QItemSelectionRange::new_QItemSelectionRange(const QModelIndex& index) | ||||
{ | ||||
return new QItemSelectionRange(index); } | ||||
QItemSelectionRange* PythonQtWrapper_QItemSelectionRange::new_QItemSelectionRange(const QModelIndex& topLeft, const QModelIndex& bottomRight) | ||||
{ | ||||
return new QItemSelectionRange(topLeft, bottomRight); } | ||||
int PythonQtWrapper_QItemSelectionRange::bottom(QItemSelectionRange* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->bottom()); | ||||
} | ||||
QModelIndex PythonQtWrapper_QItemSelectionRange::bottomRight(QItemSelectionRange* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->bottomRight()); | ||||
} | ||||
bool PythonQtWrapper_QItemSelectionRange::contains(QItemSelectionRange* theWrappedObject, const QModelIndex& index) const | ||||
{ | ||||
return ( theWrappedObject->contains(index)); | ||||
} | ||||
bool PythonQtWrapper_QItemSelectionRange::contains(QItemSelectionRange* theWrappedObject, int row, int column, const QModelIndex& parentIndex) const | ||||
{ | ||||
return ( theWrappedObject->contains(row, column, parentIndex)); | ||||
} | ||||
int PythonQtWrapper_QItemSelectionRange::height(QItemSelectionRange* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->height()); | ||||
} | ||||
QList<QModelIndex > PythonQtWrapper_QItemSelectionRange::indexes(QItemSelectionRange* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->indexes()); | ||||
} | ||||
QItemSelectionRange PythonQtWrapper_QItemSelectionRange::intersected(QItemSelectionRange* theWrappedObject, const QItemSelectionRange& other) const | ||||
{ | ||||
return ( theWrappedObject->intersected(other)); | ||||
} | ||||
bool PythonQtWrapper_QItemSelectionRange::intersects(QItemSelectionRange* theWrappedObject, const QItemSelectionRange& other) const | ||||
{ | ||||
return ( theWrappedObject->intersects(other)); | ||||
} | ||||
bool PythonQtWrapper_QItemSelectionRange::isValid(QItemSelectionRange* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isValid()); | ||||
} | ||||
int PythonQtWrapper_QItemSelectionRange::left(QItemSelectionRange* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->left()); | ||||
} | ||||
const QAbstractItemModel* PythonQtWrapper_QItemSelectionRange::model(QItemSelectionRange* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->model()); | ||||
} | ||||
bool PythonQtWrapper_QItemSelectionRange::__ne__(QItemSelectionRange* theWrappedObject, const QItemSelectionRange& other) const | ||||
{ | ||||
return ( (*theWrappedObject)!= other); | ||||
} | ||||
bool PythonQtWrapper_QItemSelectionRange::__eq__(QItemSelectionRange* theWrappedObject, const QItemSelectionRange& other) const | ||||
{ | ||||
return ( (*theWrappedObject)== other); | ||||
} | ||||
QModelIndex PythonQtWrapper_QItemSelectionRange::parent(QItemSelectionRange* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->parent()); | ||||
} | ||||
int PythonQtWrapper_QItemSelectionRange::right(QItemSelectionRange* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->right()); | ||||
} | ||||
int PythonQtWrapper_QItemSelectionRange::top(QItemSelectionRange* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->top()); | ||||
} | ||||
QModelIndex PythonQtWrapper_QItemSelectionRange::topLeft(QItemSelectionRange* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->topLeft()); | ||||
} | ||||
int PythonQtWrapper_QItemSelectionRange::width(QItemSelectionRange* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->width()); | ||||
} | ||||
QString PythonQtWrapper_QItemSelectionRange::py_toString(QItemSelectionRange* obj) { | ||||
QString result; | ||||
QDebug d(&result); | ||||
d << *obj; | ||||
return result; | ||||
} | ||||
QKeyEvent* PythonQtWrapper_QKeyEvent::new_QKeyEvent(QEvent::Type type, int key, Qt::KeyboardModifiers modifiers, const QString& text, bool autorep, ushort count) | ||||
{ | ||||
return new PythonQtShell_QKeyEvent(type, key, modifiers, text, autorep, count); } | ||||
int PythonQtWrapper_QKeyEvent::count(QKeyEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->count()); | ||||
} | ||||
QKeyEvent* PythonQtWrapper_QKeyEvent::static_QKeyEvent_createExtendedKeyEvent(QEvent::Type type, int key, Qt::KeyboardModifiers modifiers, unsigned int nativeScanCode, unsigned int nativeVirtualKey, unsigned int nativeModifiers, const QString& text, bool autorep, ushort count) | ||||
{ | ||||
return (QKeyEvent::createExtendedKeyEvent(type, key, modifiers, nativeScanCode, nativeVirtualKey, nativeModifiers, text, autorep, count)); | ||||
} | ||||
bool PythonQtWrapper_QKeyEvent::hasExtendedInfo(QKeyEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->hasExtendedInfo()); | ||||
} | ||||
bool PythonQtWrapper_QKeyEvent::isAutoRepeat(QKeyEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isAutoRepeat()); | ||||
} | ||||
int PythonQtWrapper_QKeyEvent::key(QKeyEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->key()); | ||||
} | ||||
bool PythonQtWrapper_QKeyEvent::matches(QKeyEvent* theWrappedObject, QKeySequence::StandardKey key) const | ||||
{ | ||||
return ( theWrappedObject->matches(key)); | ||||
} | ||||
Qt::KeyboardModifiers PythonQtWrapper_QKeyEvent::modifiers(QKeyEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->modifiers()); | ||||
} | ||||
unsigned int PythonQtWrapper_QKeyEvent::nativeModifiers(QKeyEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->nativeModifiers()); | ||||
} | ||||
unsigned int PythonQtWrapper_QKeyEvent::nativeScanCode(QKeyEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->nativeScanCode()); | ||||
} | ||||
unsigned int PythonQtWrapper_QKeyEvent::nativeVirtualKey(QKeyEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->nativeVirtualKey()); | ||||
} | ||||
QString PythonQtWrapper_QKeyEvent::text(QKeyEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->text()); | ||||
} | ||||
void PythonQtShell_QKeyEventTransition::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; | ||||
} | ||||
} | ||||
QKeyEventTransition::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QKeyEventTransition::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; | ||||
} | ||||
} | ||||
QKeyEventTransition::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QKeyEventTransition::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 QKeyEventTransition::event(e); | ||||
} | ||||
bool PythonQtShell_QKeyEventTransition::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 QKeyEventTransition::eventFilter(arg__1, arg__2); | ||||
} | ||||
bool PythonQtShell_QKeyEventTransition::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 QKeyEventTransition::eventTest(event); | ||||
} | ||||
void PythonQtShell_QKeyEventTransition::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; | ||||
} | ||||
} | ||||
QKeyEventTransition::onTransition(event); | ||||
} | ||||
void PythonQtShell_QKeyEventTransition::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; | ||||
} | ||||
} | ||||
QKeyEventTransition::timerEvent(arg__1); | ||||
} | ||||
QKeyEventTransition* PythonQtWrapper_QKeyEventTransition::new_QKeyEventTransition(QObject* object, QEvent::Type type, int key, QState* sourceState) | ||||
{ | ||||
return new PythonQtShell_QKeyEventTransition(object, type, key, sourceState); } | ||||
QKeyEventTransition* PythonQtWrapper_QKeyEventTransition::new_QKeyEventTransition(QState* sourceState) | ||||
{ | ||||
return new PythonQtShell_QKeyEventTransition(sourceState); } | ||||
bool PythonQtWrapper_QKeyEventTransition::eventTest(QKeyEventTransition* theWrappedObject, QEvent* event) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QKeyEventTransition*)theWrappedObject)->promoted_eventTest(event)); | ||||
} | ||||
int PythonQtWrapper_QKeyEventTransition::key(QKeyEventTransition* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->key()); | ||||
} | ||||
Qt::KeyboardModifiers PythonQtWrapper_QKeyEventTransition::modifierMask(QKeyEventTransition* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->modifierMask()); | ||||
} | ||||
void PythonQtWrapper_QKeyEventTransition::onTransition(QKeyEventTransition* theWrappedObject, QEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QKeyEventTransition*)theWrappedObject)->promoted_onTransition(event)); | ||||
} | ||||
void PythonQtWrapper_QKeyEventTransition::setKey(QKeyEventTransition* theWrappedObject, int key) | ||||
{ | ||||
( theWrappedObject->setKey(key)); | ||||
} | ||||
void PythonQtWrapper_QKeyEventTransition::setModifierMask(QKeyEventTransition* theWrappedObject, Qt::KeyboardModifiers modifiers) | ||||
{ | ||||
( theWrappedObject->setModifierMask(modifiers)); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::actionEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::changeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::closeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::contextMenuEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::customEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QLCDNumber::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 QLCDNumber::devType(); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::dragEnterEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::dragLeaveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::dragMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::dropEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::enterEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QLCDNumber::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 QLCDNumber::event(e); | ||||
} | ||||
bool PythonQtShell_QLCDNumber::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 QLCDNumber::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::focusInEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QLCDNumber::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 QLCDNumber::focusNextPrevChild(next); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::focusOutEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QLCDNumber::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 QLCDNumber::heightForWidth(arg__1); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::hideEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::inputMethodEvent(arg__1); | ||||
} | ||||
QVariant PythonQtShell_QLCDNumber::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 QLCDNumber::inputMethodQuery(arg__1); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::keyPressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::keyReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::languageChange(); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::leaveEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QLCDNumber::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 QLCDNumber::metric(arg__1); | ||||
} | ||||
QSize PythonQtShell_QLCDNumber::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 QLCDNumber::minimumSizeHint(); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::mouseDoubleClickEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::mouseMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::mousePressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::mouseReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::moveEvent(arg__1); | ||||
} | ||||
QPaintEngine* PythonQtShell_QLCDNumber::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 QLCDNumber::paintEngine(); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::paintEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::resizeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::showEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::tabletEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::timerEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLCDNumber::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; | ||||
} | ||||
} | ||||
QLCDNumber::wheelEvent(arg__1); | ||||
} | ||||
QLCDNumber* PythonQtWrapper_QLCDNumber::new_QLCDNumber(QWidget* parent) | ||||
{ | ||||
return new PythonQtShell_QLCDNumber(parent); } | ||||
QLCDNumber* PythonQtWrapper_QLCDNumber::new_QLCDNumber(uint numDigits, QWidget* parent) | ||||
{ | ||||
return new PythonQtShell_QLCDNumber(numDigits, parent); } | ||||
bool PythonQtWrapper_QLCDNumber::checkOverflow(QLCDNumber* theWrappedObject, double num) const | ||||
{ | ||||
return ( theWrappedObject->checkOverflow(num)); | ||||
} | ||||
bool PythonQtWrapper_QLCDNumber::checkOverflow(QLCDNumber* theWrappedObject, int num) const | ||||
{ | ||||
return ( theWrappedObject->checkOverflow(num)); | ||||
} | ||||
int PythonQtWrapper_QLCDNumber::digitCount(QLCDNumber* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->digitCount()); | ||||
} | ||||
bool PythonQtWrapper_QLCDNumber::event(QLCDNumber* theWrappedObject, QEvent* e) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QLCDNumber*)theWrappedObject)->promoted_event(e)); | ||||
} | ||||
int PythonQtWrapper_QLCDNumber::intValue(QLCDNumber* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->intValue()); | ||||
} | ||||
QLCDNumber::Mode PythonQtWrapper_QLCDNumber::mode(QLCDNumber* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->mode()); | ||||
} | ||||
int PythonQtWrapper_QLCDNumber::numDigits(QLCDNumber* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->numDigits()); | ||||
} | ||||
void PythonQtWrapper_QLCDNumber::paintEvent(QLCDNumber* theWrappedObject, QPaintEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QLCDNumber*)theWrappedObject)->promoted_paintEvent(arg__1)); | ||||
} | ||||
QLCDNumber::SegmentStyle PythonQtWrapper_QLCDNumber::segmentStyle(QLCDNumber* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->segmentStyle()); | ||||
} | ||||
void PythonQtWrapper_QLCDNumber::setDigitCount(QLCDNumber* theWrappedObject, int nDigits) | ||||
{ | ||||
( theWrappedObject->setDigitCount(nDigits)); | ||||
} | ||||
void PythonQtWrapper_QLCDNumber::setMode(QLCDNumber* theWrappedObject, QLCDNumber::Mode arg__1) | ||||
{ | ||||
( theWrappedObject->setMode(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QLCDNumber::setNumDigits(QLCDNumber* theWrappedObject, int nDigits) | ||||
{ | ||||
( theWrappedObject->setNumDigits(nDigits)); | ||||
} | ||||
void PythonQtWrapper_QLCDNumber::setSegmentStyle(QLCDNumber* theWrappedObject, QLCDNumber::SegmentStyle arg__1) | ||||
{ | ||||
( theWrappedObject->setSegmentStyle(arg__1)); | ||||
} | ||||
QSize PythonQtWrapper_QLCDNumber::sizeHint(QLCDNumber* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->sizeHint()); | ||||
} | ||||
bool PythonQtWrapper_QLCDNumber::smallDecimalPoint(QLCDNumber* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->smallDecimalPoint()); | ||||
} | ||||
double PythonQtWrapper_QLCDNumber::value(QLCDNumber* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->value()); | ||||
} | ||||
void PythonQtShell_QLabel::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; | ||||
} | ||||
} | ||||
QLabel::actionEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLabel::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; | ||||
} | ||||
} | ||||
QLabel::changeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLabel::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; | ||||
} | ||||
} | ||||
QLabel::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLabel::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; | ||||
} | ||||
} | ||||
QLabel::closeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLabel::contextMenuEvent(QContextMenuEvent* ev) | ||||
{ | ||||
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*)&ev}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QLabel::contextMenuEvent(ev); | ||||
} | ||||
void PythonQtShell_QLabel::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; | ||||
} | ||||
} | ||||
QLabel::customEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QLabel::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 QLabel::devType(); | ||||
} | ||||
void PythonQtShell_QLabel::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; | ||||
} | ||||
} | ||||
QLabel::dragEnterEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLabel::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; | ||||
} | ||||
} | ||||
QLabel::dragLeaveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLabel::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; | ||||
} | ||||
} | ||||
QLabel::dragMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLabel::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; | ||||
} | ||||
} | ||||
QLabel::dropEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLabel::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; | ||||
} | ||||
} | ||||
QLabel::enterEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QLabel::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 QLabel::event(e); | ||||
} | ||||
bool PythonQtShell_QLabel::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 QLabel::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QLabel::focusInEvent(QFocusEvent* ev) | ||||
{ | ||||
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*)&ev}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QLabel::focusInEvent(ev); | ||||
} | ||||
bool PythonQtShell_QLabel::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 QLabel::focusNextPrevChild(next); | ||||
} | ||||
void PythonQtShell_QLabel::focusOutEvent(QFocusEvent* ev) | ||||
{ | ||||
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*)&ev}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QLabel::focusOutEvent(ev); | ||||
} | ||||
int PythonQtShell_QLabel::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 QLabel::heightForWidth(arg__1); | ||||
} | ||||
void PythonQtShell_QLabel::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; | ||||
} | ||||
} | ||||
QLabel::hideEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLabel::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; | ||||
} | ||||
} | ||||
QLabel::inputMethodEvent(arg__1); | ||||
} | ||||
QVariant PythonQtShell_QLabel::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 QLabel::inputMethodQuery(arg__1); | ||||
} | ||||
void PythonQtShell_QLabel::keyPressEvent(QKeyEvent* ev) | ||||
{ | ||||
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*)&ev}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QLabel::keyPressEvent(ev); | ||||
} | ||||
void PythonQtShell_QLabel::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; | ||||
} | ||||
} | ||||
QLabel::keyReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLabel::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; | ||||
} | ||||
} | ||||
QLabel::languageChange(); | ||||
} | ||||
void PythonQtShell_QLabel::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; | ||||
} | ||||
} | ||||
QLabel::leaveEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QLabel::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 QLabel::metric(arg__1); | ||||
} | ||||
void PythonQtShell_QLabel::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; | ||||
} | ||||
} | ||||
QLabel::mouseDoubleClickEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLabel::mouseMoveEvent(QMouseEvent* ev) | ||||
{ | ||||
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*)&ev}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QLabel::mouseMoveEvent(ev); | ||||
} | ||||
void PythonQtShell_QLabel::mousePressEvent(QMouseEvent* ev) | ||||
{ | ||||
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*)&ev}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QLabel::mousePressEvent(ev); | ||||
} | ||||
void PythonQtShell_QLabel::mouseReleaseEvent(QMouseEvent* ev) | ||||
{ | ||||
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*)&ev}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QLabel::mouseReleaseEvent(ev); | ||||
} | ||||
void PythonQtShell_QLabel::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; | ||||
} | ||||
} | ||||
QLabel::moveEvent(arg__1); | ||||
} | ||||
QPaintEngine* PythonQtShell_QLabel::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 QLabel::paintEngine(); | ||||
} | ||||
void PythonQtShell_QLabel::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; | ||||
} | ||||
} | ||||
QLabel::paintEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLabel::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; | ||||
} | ||||
} | ||||
QLabel::resizeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLabel::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; | ||||
} | ||||
} | ||||
QLabel::showEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLabel::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; | ||||
} | ||||
} | ||||
QLabel::tabletEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLabel::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; | ||||
} | ||||
} | ||||
QLabel::timerEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QLabel::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; | ||||
} | ||||
} | ||||
QLabel::wheelEvent(arg__1); | ||||
} | ||||
QLabel* PythonQtWrapper_QLabel::new_QLabel(QWidget* parent, Qt::WindowFlags f) | ||||
{ | ||||
return new PythonQtShell_QLabel(parent, f); } | ||||
QLabel* PythonQtWrapper_QLabel::new_QLabel(const QString& text, QWidget* parent, Qt::WindowFlags f) | ||||
{ | ||||
return new PythonQtShell_QLabel(text, parent, f); } | ||||
Qt::Alignment PythonQtWrapper_QLabel::alignment(QLabel* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->alignment()); | ||||
} | ||||
QWidget* PythonQtWrapper_QLabel::buddy(QLabel* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->buddy()); | ||||
} | ||||
void PythonQtWrapper_QLabel::changeEvent(QLabel* theWrappedObject, QEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QLabel*)theWrappedObject)->promoted_changeEvent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QLabel::contextMenuEvent(QLabel* theWrappedObject, QContextMenuEvent* ev) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QLabel*)theWrappedObject)->promoted_contextMenuEvent(ev)); | ||||
} | ||||
bool PythonQtWrapper_QLabel::event(QLabel* theWrappedObject, QEvent* e) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QLabel*)theWrappedObject)->promoted_event(e)); | ||||
} | ||||
void PythonQtWrapper_QLabel::focusInEvent(QLabel* theWrappedObject, QFocusEvent* ev) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QLabel*)theWrappedObject)->promoted_focusInEvent(ev)); | ||||
} | ||||
bool PythonQtWrapper_QLabel::focusNextPrevChild(QLabel* theWrappedObject, bool next) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QLabel*)theWrappedObject)->promoted_focusNextPrevChild(next)); | ||||
} | ||||
void PythonQtWrapper_QLabel::focusOutEvent(QLabel* theWrappedObject, QFocusEvent* ev) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QLabel*)theWrappedObject)->promoted_focusOutEvent(ev)); | ||||
} | ||||
bool PythonQtWrapper_QLabel::hasScaledContents(QLabel* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->hasScaledContents()); | ||||
} | ||||
int PythonQtWrapper_QLabel::heightForWidth(QLabel* theWrappedObject, int arg__1) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QLabel*)theWrappedObject)->promoted_heightForWidth(arg__1)); | ||||
} | ||||
int PythonQtWrapper_QLabel::indent(QLabel* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->indent()); | ||||
} | ||||
void PythonQtWrapper_QLabel::keyPressEvent(QLabel* theWrappedObject, QKeyEvent* ev) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QLabel*)theWrappedObject)->promoted_keyPressEvent(ev)); | ||||
} | ||||
int PythonQtWrapper_QLabel::margin(QLabel* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->margin()); | ||||
} | ||||
QSize PythonQtWrapper_QLabel::minimumSizeHint(QLabel* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->minimumSizeHint()); | ||||
} | ||||
void PythonQtWrapper_QLabel::mouseMoveEvent(QLabel* theWrappedObject, QMouseEvent* ev) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QLabel*)theWrappedObject)->promoted_mouseMoveEvent(ev)); | ||||
} | ||||
void PythonQtWrapper_QLabel::mousePressEvent(QLabel* theWrappedObject, QMouseEvent* ev) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QLabel*)theWrappedObject)->promoted_mousePressEvent(ev)); | ||||
} | ||||
void PythonQtWrapper_QLabel::mouseReleaseEvent(QLabel* theWrappedObject, QMouseEvent* ev) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QLabel*)theWrappedObject)->promoted_mouseReleaseEvent(ev)); | ||||
} | ||||
QMovie* PythonQtWrapper_QLabel::movie(QLabel* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->movie()); | ||||
} | ||||
bool PythonQtWrapper_QLabel::openExternalLinks(QLabel* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->openExternalLinks()); | ||||
} | ||||
void PythonQtWrapper_QLabel::paintEvent(QLabel* theWrappedObject, QPaintEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QLabel*)theWrappedObject)->promoted_paintEvent(arg__1)); | ||||
} | ||||
const QPicture* PythonQtWrapper_QLabel::picture(QLabel* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->picture()); | ||||
} | ||||
const QPixmap* PythonQtWrapper_QLabel::pixmap(QLabel* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->pixmap()); | ||||
} | ||||
void PythonQtWrapper_QLabel::setAlignment(QLabel* theWrappedObject, Qt::Alignment arg__1) | ||||
{ | ||||
( theWrappedObject->setAlignment(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QLabel::setBuddy(QLabel* theWrappedObject, QWidget* arg__1) | ||||
{ | ||||
( theWrappedObject->setBuddy(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QLabel::setIndent(QLabel* theWrappedObject, int arg__1) | ||||
{ | ||||
( theWrappedObject->setIndent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QLabel::setMargin(QLabel* theWrappedObject, int arg__1) | ||||
{ | ||||
( theWrappedObject->setMargin(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QLabel::setOpenExternalLinks(QLabel* theWrappedObject, bool open) | ||||
{ | ||||
( theWrappedObject->setOpenExternalLinks(open)); | ||||
} | ||||
void PythonQtWrapper_QLabel::setScaledContents(QLabel* theWrappedObject, bool arg__1) | ||||
{ | ||||
( theWrappedObject->setScaledContents(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QLabel::setTextFormat(QLabel* theWrappedObject, Qt::TextFormat arg__1) | ||||
{ | ||||
( theWrappedObject->setTextFormat(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QLabel::setTextInteractionFlags(QLabel* theWrappedObject, Qt::TextInteractionFlags flags) | ||||
{ | ||||
( theWrappedObject->setTextInteractionFlags(flags)); | ||||
} | ||||
void PythonQtWrapper_QLabel::setWordWrap(QLabel* theWrappedObject, bool on) | ||||
{ | ||||
( theWrappedObject->setWordWrap(on)); | ||||
} | ||||
QSize PythonQtWrapper_QLabel::sizeHint(QLabel* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->sizeHint()); | ||||
} | ||||
QString PythonQtWrapper_QLabel::text(QLabel* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->text()); | ||||
} | ||||
Qt::TextFormat PythonQtWrapper_QLabel::textFormat(QLabel* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->textFormat()); | ||||
} | ||||
Qt::TextInteractionFlags PythonQtWrapper_QLabel::textInteractionFlags(QLabel* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->textInteractionFlags()); | ||||
} | ||||
bool PythonQtWrapper_QLabel::wordWrap(QLabel* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->wordWrap()); | ||||
} | ||||
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()); | ||||
} | ||||
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()); | ||||
} | ||||
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)); | ||||
} | ||||
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::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::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::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()); | ||||
} | ||||
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()); | ||||
} | ||||
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)); | ||||
} | ||||
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()); | ||||
} | ||||
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; | ||||
} | ||||