|
|
#include "PySocExplorer0.h"
|
|
|
#include <PythonQtConversion.h>
|
|
|
#include <PythonQtMethodInfo.h>
|
|
|
#include <PythonQtSignalReceiver.h>
|
|
|
#include <QVariant>
|
|
|
#include <abstractbinfile.h>
|
|
|
#include <elfparser.h>
|
|
|
#include <qaction.h>
|
|
|
#include <qbackingstore.h>
|
|
|
#include <qbitmap.h>
|
|
|
#include <qbytearray.h>
|
|
|
#include <qcolor.h>
|
|
|
#include <qcoreevent.h>
|
|
|
#include <qcursor.h>
|
|
|
#include <qevent.h>
|
|
|
#include <qfile.h>
|
|
|
#include <qfont.h>
|
|
|
#include <qgraphicseffect.h>
|
|
|
#include <qgraphicsproxywidget.h>
|
|
|
#include <qicon.h>
|
|
|
#include <qkeysequence.h>
|
|
|
#include <qlayout.h>
|
|
|
#include <qlineedit.h>
|
|
|
#include <qlist.h>
|
|
|
#include <qlocale.h>
|
|
|
#include <qmargins.h>
|
|
|
#include <qmetaobject.h>
|
|
|
#include <qobject.h>
|
|
|
#include <qpaintdevice.h>
|
|
|
#include <qpaintengine.h>
|
|
|
#include <qpainter.h>
|
|
|
#include <qpalette.h>
|
|
|
#include <qpen.h>
|
|
|
#include <qpixmap.h>
|
|
|
#include <qpoint.h>
|
|
|
#include <qrect.h>
|
|
|
#include <qregion.h>
|
|
|
#include <qscrollarea.h>
|
|
|
#include <qscrollbar.h>
|
|
|
#include <qsize.h>
|
|
|
#include <qsizepolicy.h>
|
|
|
#include <qspinbox.h>
|
|
|
#include <qstringlist.h>
|
|
|
#include <qstyle.h>
|
|
|
#include <qstyleoption.h>
|
|
|
#include <qwidget.h>
|
|
|
#include <qwindow.h>
|
|
|
|
|
|
PythonQtShell_ElfFile::~PythonQtShell_ElfFile() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
int PythonQtShell_ElfFile::closeFile()
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("closeFile");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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("closeFile", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return ElfFile::closeFile();
|
|
|
}
|
|
|
QList<codeFragment* > PythonQtShell_ElfFile::getFragments()
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("getFragments");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"QList<codeFragment* >"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QList<codeFragment* > 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("getFragments", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QList<codeFragment* >*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return ElfFile::getFragments();
|
|
|
}
|
|
|
bool PythonQtShell_ElfFile::isopened()
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("isopened");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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("isopened", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return ElfFile::isopened();
|
|
|
}
|
|
|
bool PythonQtShell_ElfFile::openFile(const QString& File0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("openFile");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "const QString&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&File0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return ElfFile::openFile(File0);
|
|
|
}
|
|
|
bool PythonQtShell_ElfFile::toBinary(const QString& File0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("toBinary");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "const QString&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&File0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return ElfFile::toBinary(File0);
|
|
|
}
|
|
|
bool PythonQtShell_ElfFile::toSrec(const QString& File0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("toSrec");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "const QString&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&File0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return ElfFile::toSrec(File0);
|
|
|
}
|
|
|
ElfFile* PythonQtWrapper_ElfFile::new_ElfFile()
|
|
|
{
|
|
|
return new PythonQtShell_ElfFile(); }
|
|
|
|
|
|
ElfFile* PythonQtWrapper_ElfFile::new_ElfFile(const QString& File)
|
|
|
{
|
|
|
return new PythonQtShell_ElfFile(File); }
|
|
|
|
|
|
int PythonQtWrapper_ElfFile::closeFile(ElfFile* theWrappedObject)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_closeFile());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_ElfFile::getABI(ElfFile* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->getABI());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_ElfFile::getArchitecture(ElfFile* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->getArchitecture());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_ElfFile::getClass(ElfFile* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->getClass());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_ElfFile::getEndianness(ElfFile* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->getEndianness());
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_ElfFile::getEntryPointAddress(ElfFile* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->getEntryPointAddress());
|
|
|
}
|
|
|
|
|
|
QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_getFragments());
|
|
|
}
|
|
|
|
|
|
QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject, QStringList fragmentList)
|
|
|
{
|
|
|
return ( theWrappedObject->getFragments(fragmentList));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_ElfFile::getSectionCount(ElfFile* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->getSectionCount());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_ElfFile::getSectionData(ElfFile* theWrappedObject, int index, char** buffer)
|
|
|
{
|
|
|
return ( theWrappedObject->getSectionData(index, buffer));
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_ElfFile::getSectionDatasz(ElfFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSectionDatasz(index));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_ElfFile::getSectionIndex(ElfFile* theWrappedObject, QString name)
|
|
|
{
|
|
|
return ( theWrappedObject->getSectionIndex(name));
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_ElfFile::getSectionMemsz(ElfFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSectionMemsz(index));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_ElfFile::getSectionName(ElfFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSectionName(index));
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_ElfFile::getSectionPaddr(ElfFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSectionPaddr(index));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_ElfFile::getSectionType(ElfFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSectionType(index));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_ElfFile::getSegmentCount(ElfFile* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->getSegmentCount());
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_ElfFile::getSegmentFilesz(ElfFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSegmentFilesz(index));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_ElfFile::getSegmentFlags(ElfFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSegmentFlags(index));
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_ElfFile::getSegmentMemsz(ElfFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSegmentMemsz(index));
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_ElfFile::getSegmentOffset(ElfFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSegmentOffset(index));
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_ElfFile::getSegmentPaddr(ElfFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSegmentPaddr(index));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_ElfFile::getSegmentType(ElfFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSegmentType(index));
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_ElfFile::getSegmentVaddr(ElfFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSegmentVaddr(index));
|
|
|
}
|
|
|
|
|
|
quint64 PythonQtWrapper_ElfFile::getSymbolAddress(ElfFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSymbolAddress(index));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_ElfFile::getSymbolCount(ElfFile* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->getSymbolCount());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_ElfFile::getSymbolLinkType(ElfFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSymbolLinkType(index));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_ElfFile::getSymbolName(ElfFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSymbolName(index));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_ElfFile::getSymbolSectionIndex(ElfFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSymbolSectionIndex(index));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_ElfFile::getSymbolSectionName(ElfFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSymbolSectionName(index));
|
|
|
}
|
|
|
|
|
|
quint64 PythonQtWrapper_ElfFile::getSymbolSize(ElfFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSymbolSize(index));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_ElfFile::getSymbolType(ElfFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSymbolType(index));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_ElfFile::getType(ElfFile* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->getType());
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_ElfFile::getVersion(ElfFile* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->getVersion());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_ElfFile::isBigEndian(ElfFile* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->isBigEndian());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_ElfFile::static_ElfFile_isElf(const QString& File)
|
|
|
{
|
|
|
return (ElfFile::isElf(File));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_ElfFile::isLitleEndian(ElfFile* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->isLitleEndian());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_ElfFile::iself(ElfFile* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->iself());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_ElfFile::isopened(ElfFile* theWrappedObject)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_isopened());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_ElfFile::openFile(ElfFile* theWrappedObject, const QString& File)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_openFile(File));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_ElfFile::sectionIsNobits(ElfFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->sectionIsNobits(index));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_ElfFile::toBinary(ElfFile* theWrappedObject, const QString& File)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_toBinary(File));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_ElfFile::toSrec(ElfFile* theWrappedObject, const QString& File)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_toSrec(File));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_MemSizeWdgt::~PythonQtShell_MemSizeWdgt() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::actionEvent(QActionEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("actionEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::actionEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::changeEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("changeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::changeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("childEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::closeEvent(QCloseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("closeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::closeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("contextMenuEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::contextMenuEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("customEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::customEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_MemSizeWdgt::devType() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("devType");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return MemSizeWdgt::devType();
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dragEnterEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::dragEnterEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dragLeaveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::dragLeaveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dragMoveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::dragMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::dropEvent(QDropEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dropEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::dropEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::enterEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("enterEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::enterEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_MemSizeWdgt::event(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("event");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return MemSizeWdgt::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_MemSizeWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("eventFilter");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return MemSizeWdgt::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::focusInEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("focusInEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::focusInEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_MemSizeWdgt::focusNextPrevChild(bool next0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("focusNextPrevChild");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&next0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return MemSizeWdgt::focusNextPrevChild(next0);
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::focusOutEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("focusOutEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::focusOutEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_MemSizeWdgt::hasHeightForWidth() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("hasHeightForWidth");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return MemSizeWdgt::hasHeightForWidth();
|
|
|
}
|
|
|
int PythonQtShell_MemSizeWdgt::heightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("heightForWidth");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return MemSizeWdgt::heightForWidth(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::hideEvent(QHideEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("hideEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::hideEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::initPainter(QPainter* painter0) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("initPainter");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&painter0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::initPainter(painter0);
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("inputMethodEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::inputMethodEvent(arg__1);
|
|
|
}
|
|
|
QVariant PythonQtShell_MemSizeWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("inputMethodQuery");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return MemSizeWdgt::inputMethodQuery(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::keyPressEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("keyPressEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::keyPressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::keyReleaseEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("keyReleaseEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::keyReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::leaveEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("leaveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::leaveEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_MemSizeWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("metric");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return MemSizeWdgt::metric(arg__1);
|
|
|
}
|
|
|
QSize PythonQtShell_MemSizeWdgt::minimumSizeHint() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("getMinimumSizeHint");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return MemSizeWdgt::minimumSizeHint();
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::mouseDoubleClickEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::mouseMoveEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mouseMoveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::mouseMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::mousePressEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mousePressEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::mousePressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mouseReleaseEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::mouseReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::moveEvent(QMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("moveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::moveEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_MemSizeWdgt::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("nativeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return MemSizeWdgt::nativeEvent(eventType0, message1, result2);
|
|
|
}
|
|
|
QPaintEngine* PythonQtShell_MemSizeWdgt::paintEngine() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("paintEngine");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return MemSizeWdgt::paintEngine();
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::paintEvent(QPaintEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("paintEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::paintEvent(arg__1);
|
|
|
}
|
|
|
QPaintDevice* PythonQtShell_MemSizeWdgt::redirected(QPoint* offset0) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("redirected");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QPaintDevice* returnValue;
|
|
|
void* args[2] = {NULL, (void*)&offset0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintDevice**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return MemSizeWdgt::redirected(offset0);
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::resizeEvent(QResizeEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("resizeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::resizeEvent(arg__1);
|
|
|
}
|
|
|
QPainter* PythonQtShell_MemSizeWdgt::sharedPainter() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("sharedPainter");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPainter* 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("sharedPainter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPainter**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return MemSizeWdgt::sharedPainter();
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::showEvent(QShowEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("showEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::showEvent(arg__1);
|
|
|
}
|
|
|
QSize PythonQtShell_MemSizeWdgt::sizeHint() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("getSizeHint");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return MemSizeWdgt::sizeHint();
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::tabletEvent(QTabletEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("tabletEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::tabletEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("timerEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::timerEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_MemSizeWdgt::wheelEvent(QWheelEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("wheelEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
MemSizeWdgt::wheelEvent(arg__1);
|
|
|
}
|
|
|
MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_MemSizeWdgt(parent); }
|
|
|
|
|
|
MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(int defaultSize, QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_MemSizeWdgt(defaultSize, parent); }
|
|
|
|
|
|
int PythonQtWrapper_MemSizeWdgt::getsize(MemSizeWdgt* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->getsize());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_MemSizeWdgt::setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max)
|
|
|
{
|
|
|
( theWrappedObject->setMaximum(max));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_MemSizeWdgt::show(MemSizeWdgt* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->show());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_MemSizeWdgt::updateSizeValue(MemSizeWdgt* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->updateSizeValue());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QHexEdit::~PythonQtShell_QHexEdit() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::actionEvent(QActionEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("actionEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::actionEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::changeEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("changeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::changeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("childEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::closeEvent(QCloseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("closeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::closeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::contextMenuEvent(QContextMenuEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("contextMenuEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::contextMenuEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("customEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::customEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QHexEdit::devType() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("devType");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexEdit::devType();
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::dragEnterEvent(QDragEnterEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dragEnterEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::dragEnterEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::dragLeaveEvent(QDragLeaveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dragLeaveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::dragLeaveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::dragMoveEvent(QDragMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dragMoveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::dragMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::dropEvent(QDropEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dropEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::dropEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::enterEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("enterEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::enterEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QHexEdit::event(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("event");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexEdit::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QHexEdit::eventFilter(QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("eventFilter");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexEdit::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::focusInEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("focusInEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::focusInEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QHexEdit::focusNextPrevChild(bool next0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("focusNextPrevChild");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&next0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexEdit::focusNextPrevChild(next0);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::focusOutEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("focusOutEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::focusOutEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QHexEdit::hasHeightForWidth() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("hasHeightForWidth");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexEdit::hasHeightForWidth();
|
|
|
}
|
|
|
int PythonQtShell_QHexEdit::heightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("heightForWidth");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexEdit::heightForWidth(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::hideEvent(QHideEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("hideEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::hideEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::initPainter(QPainter* painter0) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("initPainter");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&painter0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::initPainter(painter0);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::inputMethodEvent(QInputMethodEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("inputMethodEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::inputMethodEvent(arg__1);
|
|
|
}
|
|
|
QVariant PythonQtShell_QHexEdit::inputMethodQuery(Qt::InputMethodQuery arg__1) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("inputMethodQuery");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexEdit::inputMethodQuery(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::keyPressEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("keyPressEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::keyPressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::keyReleaseEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("keyReleaseEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::keyReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::leaveEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("leaveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::leaveEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QHexEdit::metric(QPaintDevice::PaintDeviceMetric arg__1) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("metric");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexEdit::metric(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::mouseDoubleClickEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::mouseDoubleClickEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::mouseMoveEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mouseMoveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::mouseMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::mousePressEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mousePressEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::mousePressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::mouseReleaseEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mouseReleaseEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::mouseReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::moveEvent(QMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("moveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::moveEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QHexEdit::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("nativeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexEdit::nativeEvent(eventType0, message1, result2);
|
|
|
}
|
|
|
QPaintEngine* PythonQtShell_QHexEdit::paintEngine() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("paintEngine");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexEdit::paintEngine();
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::paintEvent(QPaintEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("paintEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::paintEvent(arg__1);
|
|
|
}
|
|
|
QPaintDevice* PythonQtShell_QHexEdit::redirected(QPoint* offset0) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("redirected");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QPaintDevice* returnValue;
|
|
|
void* args[2] = {NULL, (void*)&offset0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintDevice**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexEdit::redirected(offset0);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::resizeEvent(QResizeEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("resizeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::resizeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::scrollContentsBy(int dx0, int dy1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("scrollContentsBy");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "int" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&dx0, (void*)&dy1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::scrollContentsBy(dx0, dy1);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::setupViewport(QWidget* viewport0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("setupViewport");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "QWidget*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&viewport0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::setupViewport(viewport0);
|
|
|
}
|
|
|
QPainter* PythonQtShell_QHexEdit::sharedPainter() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("sharedPainter");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPainter* 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("sharedPainter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPainter**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexEdit::sharedPainter();
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::showEvent(QShowEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("showEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::showEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::tabletEvent(QTabletEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("tabletEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::tabletEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("timerEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::timerEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QHexEdit::viewportEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("viewportEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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("viewportEvent", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexEdit::viewportEvent(arg__1);
|
|
|
}
|
|
|
QSize PythonQtShell_QHexEdit::viewportSizeHint() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("viewportSizeHint");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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("viewportSizeHint", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QSize*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexEdit::viewportSizeHint();
|
|
|
}
|
|
|
void PythonQtShell_QHexEdit::wheelEvent(QWheelEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("wheelEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexEdit::wheelEvent(arg__1);
|
|
|
}
|
|
|
QHexEdit* PythonQtWrapper_QHexEdit::new_QHexEdit(QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QHexEdit(parent); }
|
|
|
|
|
|
QColor PythonQtWrapper_QHexEdit::addressAreaColor(QHexEdit* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->addressAreaColor());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QHexEdit::addressOffset(QHexEdit* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->addressOffset());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QHexEdit::cursorPosition(QHexEdit* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->cursorPosition());
|
|
|
}
|
|
|
|
|
|
QByteArray PythonQtWrapper_QHexEdit::data(QHexEdit* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->data());
|
|
|
}
|
|
|
|
|
|
const QFont* PythonQtWrapper_QHexEdit::font(QHexEdit* theWrappedObject) const
|
|
|
{
|
|
|
return &( theWrappedObject->font());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QHexEdit::getSelectionBegin(QHexEdit* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->getSelectionBegin());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QHexEdit::getSelectionEnd(QHexEdit* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->getSelectionEnd());
|
|
|
}
|
|
|
|
|
|
QColor PythonQtWrapper_QHexEdit::highlightingColor(QHexEdit* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->highlightingColor());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QHexEdit::indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
|
|
|
{
|
|
|
return ( theWrappedObject->indexOf(ba, from));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, char ch)
|
|
|
{
|
|
|
( theWrappedObject->insert(i, ch));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba)
|
|
|
{
|
|
|
( theWrappedObject->insert(i, ba));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QHexEdit::isReadOnly(QHexEdit* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->isReadOnly());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QHexEdit::lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
|
|
|
{
|
|
|
return ( theWrappedObject->lastIndexOf(ba, from));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QHexEdit::overwriteMode(QHexEdit* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->overwriteMode());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QHexEdit::remove(QHexEdit* theWrappedObject, int pos, int len)
|
|
|
{
|
|
|
( theWrappedObject->remove(pos, len));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QHexEdit::replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after)
|
|
|
{
|
|
|
( theWrappedObject->replace(pos, len, after));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QHexEdit::resetSelection(QHexEdit* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->resetSelection());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QHexEdit::resetSelection(QHexEdit* theWrappedObject, int pos)
|
|
|
{
|
|
|
( theWrappedObject->resetSelection(pos));
|
|
|
}
|
|
|
|
|
|
QColor PythonQtWrapper_QHexEdit::selectionColor(QHexEdit* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->selectionColor());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QHexEdit::selectionToReadableString(QHexEdit* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->selectionToReadableString());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QHexEdit::setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color)
|
|
|
{
|
|
|
( theWrappedObject->setAddressAreaColor(color));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QHexEdit::setAddressOffset(QHexEdit* theWrappedObject, int offset)
|
|
|
{
|
|
|
( theWrappedObject->setAddressOffset(offset));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QHexEdit::setCursorPosition(QHexEdit* theWrappedObject, int cusorPos)
|
|
|
{
|
|
|
( theWrappedObject->setCursorPosition(cusorPos));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QHexEdit::setData(QHexEdit* theWrappedObject, const QByteArray& data)
|
|
|
{
|
|
|
( theWrappedObject->setData(data));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QHexEdit::setFont(QHexEdit* theWrappedObject, const QFont& arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setFont(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QHexEdit::setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color)
|
|
|
{
|
|
|
( theWrappedObject->setHighlightingColor(color));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QHexEdit::setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setOverwriteMode(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QHexEdit::setReadOnly(QHexEdit* theWrappedObject, bool arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setReadOnly(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QHexEdit::setSelection(QHexEdit* theWrappedObject, int pos)
|
|
|
{
|
|
|
( theWrappedObject->setSelection(pos));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QHexEdit::setSelectionColor(QHexEdit* theWrappedObject, const QColor& color)
|
|
|
{
|
|
|
( theWrappedObject->setSelectionColor(color));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QHexEdit::toReadableString(QHexEdit* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->toReadableString());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QHexSpinBox::~PythonQtShell_QHexSpinBox() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::actionEvent(QActionEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("actionEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::actionEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::changeEvent(QEvent* event0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("changeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::changeEvent(event0);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("childEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::clear()
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("clear");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::clear();
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::closeEvent(QCloseEvent* event0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("closeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "QCloseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::closeEvent(event0);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::contextMenuEvent(QContextMenuEvent* event0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("contextMenuEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "QContextMenuEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::contextMenuEvent(event0);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("customEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::customEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QHexSpinBox::devType() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("devType");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexSpinBox::devType();
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::dragEnterEvent(QDragEnterEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dragEnterEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::dragEnterEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::dragLeaveEvent(QDragLeaveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dragLeaveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::dragLeaveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::dragMoveEvent(QDragMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dragMoveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::dragMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::dropEvent(QDropEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dropEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::dropEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::enterEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("enterEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::enterEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QHexSpinBox::event(QEvent* event0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("event");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "QEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&event0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexSpinBox::event(event0);
|
|
|
}
|
|
|
bool PythonQtShell_QHexSpinBox::eventFilter(QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("eventFilter");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexSpinBox::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::fixup(QString& str0) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("fixup");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "QString&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&str0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::fixup(str0);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::focusInEvent(QFocusEvent* event0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("focusInEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::focusInEvent(event0);
|
|
|
}
|
|
|
bool PythonQtShell_QHexSpinBox::focusNextPrevChild(bool next0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("focusNextPrevChild");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&next0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexSpinBox::focusNextPrevChild(next0);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::focusOutEvent(QFocusEvent* event0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("focusOutEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "QFocusEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::focusOutEvent(event0);
|
|
|
}
|
|
|
bool PythonQtShell_QHexSpinBox::hasHeightForWidth() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("hasHeightForWidth");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexSpinBox::hasHeightForWidth();
|
|
|
}
|
|
|
int PythonQtShell_QHexSpinBox::heightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("heightForWidth");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexSpinBox::heightForWidth(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::hideEvent(QHideEvent* event0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("hideEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "QHideEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::hideEvent(event0);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::initPainter(QPainter* painter0) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("initPainter");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&painter0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::initPainter(painter0);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::inputMethodEvent(QInputMethodEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("inputMethodEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::inputMethodEvent(arg__1);
|
|
|
}
|
|
|
QVariant PythonQtShell_QHexSpinBox::inputMethodQuery(Qt::InputMethodQuery arg__1) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("inputMethodQuery");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexSpinBox::inputMethodQuery(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::keyPressEvent(QKeyEvent* event0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("keyPressEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::keyPressEvent(event0);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::keyReleaseEvent(QKeyEvent* event0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("keyReleaseEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "QKeyEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::keyReleaseEvent(event0);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::leaveEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("leaveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::leaveEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QHexSpinBox::metric(QPaintDevice::PaintDeviceMetric arg__1) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("metric");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexSpinBox::metric(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::mouseDoubleClickEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::mouseDoubleClickEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::mouseMoveEvent(QMouseEvent* event0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mouseMoveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::mouseMoveEvent(event0);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::mousePressEvent(QMouseEvent* event0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mousePressEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::mousePressEvent(event0);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::mouseReleaseEvent(QMouseEvent* event0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mouseReleaseEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "QMouseEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::mouseReleaseEvent(event0);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::moveEvent(QMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("moveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::moveEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QHexSpinBox::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("nativeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexSpinBox::nativeEvent(eventType0, message1, result2);
|
|
|
}
|
|
|
QPaintEngine* PythonQtShell_QHexSpinBox::paintEngine() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("paintEngine");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexSpinBox::paintEngine();
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::paintEvent(QPaintEvent* event0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("paintEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "QPaintEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::paintEvent(event0);
|
|
|
}
|
|
|
QPaintDevice* PythonQtShell_QHexSpinBox::redirected(QPoint* offset0) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("redirected");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QPaintDevice* returnValue;
|
|
|
void* args[2] = {NULL, (void*)&offset0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintDevice**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexSpinBox::redirected(offset0);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::resizeEvent(QResizeEvent* event0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("resizeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "QResizeEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::resizeEvent(event0);
|
|
|
}
|
|
|
QPainter* PythonQtShell_QHexSpinBox::sharedPainter() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("sharedPainter");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPainter* 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("sharedPainter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPainter**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexSpinBox::sharedPainter();
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::showEvent(QShowEvent* event0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("showEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "QShowEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::showEvent(event0);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::stepBy(int steps0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("stepBy");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&steps0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::stepBy(steps0);
|
|
|
}
|
|
|
QAbstractSpinBox::StepEnabled PythonQtShell_QHexSpinBox::stepEnabled() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("stepEnabled");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"QAbstractSpinBox::StepEnabled"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QAbstractSpinBox::StepEnabled 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("stepEnabled", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QAbstractSpinBox::StepEnabled*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexSpinBox::stepEnabled();
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::tabletEvent(QTabletEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("tabletEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::tabletEvent(arg__1);
|
|
|
}
|
|
|
QString PythonQtShell_QHexSpinBox::textFromValue(int value0) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("textFromValue");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"QString" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QString returnValue;
|
|
|
void* args[2] = {NULL, (void*)&value0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("textFromValue", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QString*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexSpinBox::textFromValue(value0);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::timerEvent(QTimerEvent* event0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("timerEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "QTimerEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::timerEvent(event0);
|
|
|
}
|
|
|
QValidator::State PythonQtShell_QHexSpinBox::validate(QString& input0, int& pos1) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("validate");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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*)&input0, (void*)&pos1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexSpinBox::validate(input0, pos1);
|
|
|
}
|
|
|
int PythonQtShell_QHexSpinBox::valueFromText(const QString& text0) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("valueFromText");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"int" , "const QString&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
int returnValue;
|
|
|
void* args[2] = {NULL, (void*)&text0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("valueFromText", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QHexSpinBox::valueFromText(text0);
|
|
|
}
|
|
|
void PythonQtShell_QHexSpinBox::wheelEvent(QWheelEvent* event0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("wheelEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "QWheelEvent*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&event0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
QHexSpinBox::wheelEvent(event0);
|
|
|
}
|
|
|
QHexSpinBox* PythonQtWrapper_QHexSpinBox::new_QHexSpinBox(QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QHexSpinBox(parent); }
|
|
|
|
|
|
void PythonQtWrapper_QHexSpinBox::show(QHexSpinBox* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->show());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QHexSpinBox::textFromValue(QHexSpinBox* theWrappedObject, int value) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_textFromValue(value));
|
|
|
}
|
|
|
|
|
|
QValidator::State PythonQtWrapper_QHexSpinBox::validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_validate(input, pos));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QHexSpinBox::valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_valueFromText(text));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_SocExplorerPlot::~PythonQtShell_SocExplorerPlot() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::actionEvent(QActionEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("actionEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::actionEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::changeEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("changeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::changeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("childEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::closeEvent(QCloseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("closeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::closeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::contextMenuEvent(QContextMenuEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("contextMenuEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::contextMenuEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("customEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::customEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_SocExplorerPlot::devType() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("devType");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return SocExplorerPlot::devType();
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::dragEnterEvent(QDragEnterEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dragEnterEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::dragEnterEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::dragLeaveEvent(QDragLeaveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dragLeaveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::dragLeaveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::dragMoveEvent(QDragMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dragMoveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::dragMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::dropEvent(QDropEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dropEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::dropEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::enterEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("enterEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::enterEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_SocExplorerPlot::event(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("event");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return SocExplorerPlot::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_SocExplorerPlot::eventFilter(QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("eventFilter");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return SocExplorerPlot::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::focusInEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("focusInEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::focusInEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_SocExplorerPlot::focusNextPrevChild(bool next0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("focusNextPrevChild");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&next0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return SocExplorerPlot::focusNextPrevChild(next0);
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::focusOutEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("focusOutEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::focusOutEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_SocExplorerPlot::hasHeightForWidth() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("hasHeightForWidth");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return SocExplorerPlot::hasHeightForWidth();
|
|
|
}
|
|
|
int PythonQtShell_SocExplorerPlot::heightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("heightForWidth");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return SocExplorerPlot::heightForWidth(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::hideEvent(QHideEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("hideEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::hideEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::initPainter(QPainter* painter0) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("initPainter");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&painter0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::initPainter(painter0);
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::inputMethodEvent(QInputMethodEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("inputMethodEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::inputMethodEvent(arg__1);
|
|
|
}
|
|
|
QVariant PythonQtShell_SocExplorerPlot::inputMethodQuery(Qt::InputMethodQuery arg__1) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("inputMethodQuery");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return SocExplorerPlot::inputMethodQuery(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::keyPressEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("keyPressEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::keyPressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::keyReleaseEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("keyReleaseEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::keyReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::leaveEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("leaveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::leaveEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_SocExplorerPlot::metric(QPaintDevice::PaintDeviceMetric arg__1) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("metric");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return SocExplorerPlot::metric(arg__1);
|
|
|
}
|
|
|
QSize PythonQtShell_SocExplorerPlot::minimumSizeHint() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("getMinimumSizeHint");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return SocExplorerPlot::minimumSizeHint();
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::mouseDoubleClickEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::mouseDoubleClickEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::mouseMoveEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mouseMoveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::mouseMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::mousePressEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mousePressEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::mousePressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::mouseReleaseEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mouseReleaseEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::mouseReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::moveEvent(QMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("moveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::moveEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_SocExplorerPlot::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("nativeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return SocExplorerPlot::nativeEvent(eventType0, message1, result2);
|
|
|
}
|
|
|
QPaintEngine* PythonQtShell_SocExplorerPlot::paintEngine() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("paintEngine");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return SocExplorerPlot::paintEngine();
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::paintEvent(QPaintEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("paintEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::paintEvent(arg__1);
|
|
|
}
|
|
|
QPaintDevice* PythonQtShell_SocExplorerPlot::redirected(QPoint* offset0) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("redirected");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QPaintDevice* returnValue;
|
|
|
void* args[2] = {NULL, (void*)&offset0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintDevice**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return SocExplorerPlot::redirected(offset0);
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::resizeEvent(QResizeEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("resizeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::resizeEvent(arg__1);
|
|
|
}
|
|
|
QPainter* PythonQtShell_SocExplorerPlot::sharedPainter() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("sharedPainter");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPainter* 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("sharedPainter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPainter**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return SocExplorerPlot::sharedPainter();
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::showEvent(QShowEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("showEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::showEvent(arg__1);
|
|
|
}
|
|
|
QSize PythonQtShell_SocExplorerPlot::sizeHint() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("getSizeHint");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return SocExplorerPlot::sizeHint();
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::tabletEvent(QTabletEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("tabletEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::tabletEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("timerEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::timerEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_SocExplorerPlot::wheelEvent(QWheelEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("wheelEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
SocExplorerPlot::wheelEvent(arg__1);
|
|
|
}
|
|
|
SocExplorerPlot* PythonQtWrapper_SocExplorerPlot::new_SocExplorerPlot(QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_SocExplorerPlot(parent); }
|
|
|
|
|
|
int PythonQtWrapper_SocExplorerPlot::addGraph(SocExplorerPlot* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->addGraph());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
|
|
|
{
|
|
|
( theWrappedObject->addGraphData(graphIndex, x, y));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y)
|
|
|
{
|
|
|
( theWrappedObject->addGraphData(graphIndex, x, y));
|
|
|
}
|
|
|
|
|
|
QPen PythonQtWrapper_SocExplorerPlot::getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex)
|
|
|
{
|
|
|
return ( theWrappedObject->getGraphPen(graphIndex));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_SocExplorerPlot::keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyPressEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_SocExplorerPlot::keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyReleaseEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_SocExplorerPlot::mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseMoveEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_SocExplorerPlot::mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mousePressEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_SocExplorerPlot::mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseReleaseEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_SocExplorerPlot::rescaleAxis(SocExplorerPlot* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->rescaleAxis());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_SocExplorerPlot::setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable)
|
|
|
{
|
|
|
( theWrappedObject->setAdaptativeSampling(graphIndex, enable));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_SocExplorerPlot::setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
|
|
|
{
|
|
|
( theWrappedObject->setGraphData(graphIndex, x, y));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_SocExplorerPlot::setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle)
|
|
|
{
|
|
|
( theWrappedObject->setGraphLineStyle(graphIndex, lineStyle));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_SocExplorerPlot::setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name)
|
|
|
{
|
|
|
( theWrappedObject->setGraphName(graphIndex, name));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_SocExplorerPlot::setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen)
|
|
|
{
|
|
|
( theWrappedObject->setGraphPen(graphIndex, pen));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_SocExplorerPlot::setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle)
|
|
|
{
|
|
|
( theWrappedObject->setGraphScatterStyle(graphIndex, scatterStyle));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_SocExplorerPlot::setLegendFont(SocExplorerPlot* theWrappedObject, QFont font)
|
|
|
{
|
|
|
( theWrappedObject->setLegendFont(font));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_SocExplorerPlot::setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font)
|
|
|
{
|
|
|
( theWrappedObject->setLegendSelectedFont(font));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_SocExplorerPlot::setTitle(SocExplorerPlot* theWrappedObject, QString title)
|
|
|
{
|
|
|
( theWrappedObject->setTitle(title));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_SocExplorerPlot::setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
|
|
|
{
|
|
|
( theWrappedObject->setXaxisLabel(label));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_SocExplorerPlot::setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
|
|
|
{
|
|
|
( theWrappedObject->setXaxisRange(lower, upper));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_SocExplorerPlot::setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
|
|
|
{
|
|
|
( theWrappedObject->setYaxisLabel(label));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_SocExplorerPlot::setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
|
|
|
{
|
|
|
( theWrappedObject->setYaxisRange(lower, upper));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_SocExplorerPlot::show(SocExplorerPlot* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->show());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_SocExplorerPlot::wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_wheelEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_TCP_Terminal_Client::~PythonQtShell_TCP_Terminal_Client() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_TCP_Terminal_Client::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("childEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
TCP_Terminal_Client::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_TCP_Terminal_Client::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("customEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
TCP_Terminal_Client::customEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_TCP_Terminal_Client::event(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("event");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return TCP_Terminal_Client::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_TCP_Terminal_Client::eventFilter(QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("eventFilter");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return TCP_Terminal_Client::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_TCP_Terminal_Client::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("timerEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
TCP_Terminal_Client::timerEvent(arg__1);
|
|
|
}
|
|
|
TCP_Terminal_Client* PythonQtWrapper_TCP_Terminal_Client::new_TCP_Terminal_Client(QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_TCP_Terminal_Client(parent); }
|
|
|
|
|
|
void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->connectToServer());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port)
|
|
|
{
|
|
|
( theWrappedObject->connectToServer(IP, port));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_TCP_Terminal_Client::isConnected(TCP_Terminal_Client* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->isConnected());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_TCP_Terminal_Client::sendText(TCP_Terminal_Client* theWrappedObject, const QString& text)
|
|
|
{
|
|
|
( theWrappedObject->sendText(text));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->startServer());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject, int port)
|
|
|
{
|
|
|
( theWrappedObject->startServer(port));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
XByteArray* PythonQtWrapper_XByteArray::new_XByteArray()
|
|
|
{
|
|
|
return new XByteArray(); }
|
|
|
|
|
|
int PythonQtWrapper_XByteArray::addressOffset(XByteArray* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->addressOffset());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_XByteArray::addressWidth(XByteArray* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->addressWidth());
|
|
|
}
|
|
|
|
|
|
QChar PythonQtWrapper_XByteArray::asciiChar(XByteArray* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->asciiChar(index));
|
|
|
}
|
|
|
|
|
|
QByteArray* PythonQtWrapper_XByteArray::data(XByteArray* theWrappedObject)
|
|
|
{
|
|
|
return &( theWrappedObject->data());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i)
|
|
|
{
|
|
|
return ( theWrappedObject->dataChanged(i));
|
|
|
}
|
|
|
|
|
|
QByteArray PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i, int len)
|
|
|
{
|
|
|
return ( theWrappedObject->dataChanged(i, len));
|
|
|
}
|
|
|
|
|
|
QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, char ch)
|
|
|
{
|
|
|
return &( theWrappedObject->insert(i, ch));
|
|
|
}
|
|
|
|
|
|
QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, const QByteArray& ba)
|
|
|
{
|
|
|
return &( theWrappedObject->insert(i, ba));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_XByteArray::realAddressNumbers(XByteArray* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->realAddressNumbers());
|
|
|
}
|
|
|
|
|
|
QByteArray* PythonQtWrapper_XByteArray::remove(XByteArray* theWrappedObject, int pos, int len)
|
|
|
{
|
|
|
return &( theWrappedObject->remove(pos, len));
|
|
|
}
|
|
|
|
|
|
QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, char ch)
|
|
|
{
|
|
|
return &( theWrappedObject->replace(index, ch));
|
|
|
}
|
|
|
|
|
|
QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, const QByteArray& ba)
|
|
|
{
|
|
|
return &( theWrappedObject->replace(index, ba));
|
|
|
}
|
|
|
|
|
|
QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba)
|
|
|
{
|
|
|
return &( theWrappedObject->replace(index, length, ba));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_XByteArray::setAddressOffset(XByteArray* theWrappedObject, int offset)
|
|
|
{
|
|
|
( theWrappedObject->setAddressOffset(offset));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_XByteArray::setAddressWidth(XByteArray* theWrappedObject, int width)
|
|
|
{
|
|
|
( theWrappedObject->setAddressWidth(width));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_XByteArray::setData(XByteArray* theWrappedObject, QByteArray data)
|
|
|
{
|
|
|
( theWrappedObject->setData(data));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, bool state)
|
|
|
{
|
|
|
( theWrappedObject->setDataChanged(i, state));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state)
|
|
|
{
|
|
|
( theWrappedObject->setDataChanged(i, state));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_XByteArray::size(XByteArray* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->size());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_XByteArray::toRedableString(XByteArray* theWrappedObject, int start, int end)
|
|
|
{
|
|
|
return ( theWrappedObject->toRedableString(start, end));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_abstractBinFile::~PythonQtShell_abstractBinFile() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFile::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("childEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFile::childEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_abstractBinFile::closeFile()
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("closeFile");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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("closeFile", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return int();
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFile::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("customEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFile::customEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_abstractBinFile::event(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("event");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return abstractBinFile::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_abstractBinFile::eventFilter(QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("eventFilter");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return abstractBinFile::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
QList<codeFragment* > PythonQtShell_abstractBinFile::getFragments()
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("getFragments");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"QList<codeFragment* >"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QList<codeFragment* > 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("getFragments", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QList<codeFragment* >*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return QList<codeFragment* >();
|
|
|
}
|
|
|
bool PythonQtShell_abstractBinFile::isopened()
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("isopened");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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("isopened", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return bool();
|
|
|
}
|
|
|
bool PythonQtShell_abstractBinFile::openFile(const QString& File0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("openFile");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "const QString&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&File0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return bool();
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFile::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("timerEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFile::timerEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_abstractBinFile::toBinary(const QString& File0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("toBinary");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "const QString&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&File0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return bool();
|
|
|
}
|
|
|
bool PythonQtShell_abstractBinFile::toSrec(const QString& File0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("toSrec");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "const QString&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&File0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return bool();
|
|
|
}
|
|
|
abstractBinFile* PythonQtWrapper_abstractBinFile::new_abstractBinFile()
|
|
|
{
|
|
|
return new PythonQtShell_abstractBinFile(); }
|
|
|
|
|
|
int PythonQtWrapper_abstractBinFile::closeFile(abstractBinFile* theWrappedObject)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_closeFile());
|
|
|
}
|
|
|
|
|
|
QList<codeFragment* > PythonQtWrapper_abstractBinFile::getFragments(abstractBinFile* theWrappedObject)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_getFragments());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_abstractBinFile::isopened(abstractBinFile* theWrappedObject)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_isopened());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_abstractBinFile::openFile(abstractBinFile* theWrappedObject, const QString& File)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_openFile(File));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_abstractBinFile::toBinary(abstractBinFile* theWrappedObject, const QString& File)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_toBinary(File));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_abstractBinFile::toSrec(abstractBinFile* theWrappedObject, const QString& File)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_toSrec(File));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_abstractBinFileWidget::~PythonQtShell_abstractBinFileWidget() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::actionEvent(QActionEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("actionEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::actionEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::changeEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("changeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::changeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("childEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::closeEvent(QCloseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("closeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::closeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("contextMenuEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::contextMenuEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("customEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::customEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_abstractBinFileWidget::devType() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("devType");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return abstractBinFileWidget::devType();
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dragEnterEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::dragEnterEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dragLeaveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::dragLeaveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dragMoveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::dragMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::dropEvent(QDropEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dropEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::dropEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::enterEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("enterEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::enterEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_abstractBinFileWidget::event(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("event");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return abstractBinFileWidget::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_abstractBinFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("eventFilter");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return abstractBinFileWidget::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::focusInEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("focusInEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::focusInEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_abstractBinFileWidget::focusNextPrevChild(bool next0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("focusNextPrevChild");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&next0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return abstractBinFileWidget::focusNextPrevChild(next0);
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::focusOutEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("focusOutEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::focusOutEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_abstractBinFileWidget::hasHeightForWidth() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("hasHeightForWidth");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return abstractBinFileWidget::hasHeightForWidth();
|
|
|
}
|
|
|
int PythonQtShell_abstractBinFileWidget::heightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("heightForWidth");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return abstractBinFileWidget::heightForWidth(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::hideEvent(QHideEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("hideEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::hideEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::initPainter(QPainter* painter0) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("initPainter");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&painter0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::initPainter(painter0);
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("inputMethodEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::inputMethodEvent(arg__1);
|
|
|
}
|
|
|
QVariant PythonQtShell_abstractBinFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("inputMethodQuery");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return abstractBinFileWidget::inputMethodQuery(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::keyPressEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("keyPressEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::keyPressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("keyReleaseEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::keyReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::leaveEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("leaveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::leaveEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_abstractBinFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("metric");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return abstractBinFileWidget::metric(arg__1);
|
|
|
}
|
|
|
QSize PythonQtShell_abstractBinFileWidget::minimumSizeHint() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("getMinimumSizeHint");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return abstractBinFileWidget::minimumSizeHint();
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::mouseDoubleClickEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mouseMoveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::mouseMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::mousePressEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mousePressEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::mousePressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mouseReleaseEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::mouseReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::moveEvent(QMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("moveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::moveEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_abstractBinFileWidget::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("nativeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return abstractBinFileWidget::nativeEvent(eventType0, message1, result2);
|
|
|
}
|
|
|
QPaintEngine* PythonQtShell_abstractBinFileWidget::paintEngine() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("paintEngine");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return abstractBinFileWidget::paintEngine();
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::paintEvent(QPaintEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("paintEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::paintEvent(arg__1);
|
|
|
}
|
|
|
QPaintDevice* PythonQtShell_abstractBinFileWidget::redirected(QPoint* offset0) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("redirected");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QPaintDevice* returnValue;
|
|
|
void* args[2] = {NULL, (void*)&offset0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintDevice**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return abstractBinFileWidget::redirected(offset0);
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::reloadFile()
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("reloadFile");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::resizeEvent(QResizeEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("resizeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::resizeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::setFile(abstractBinFile* file0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("setFile");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "abstractBinFile*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&file0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
QPainter* PythonQtShell_abstractBinFileWidget::sharedPainter() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("sharedPainter");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPainter* 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("sharedPainter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPainter**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return abstractBinFileWidget::sharedPainter();
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::showEvent(QShowEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("showEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::showEvent(arg__1);
|
|
|
}
|
|
|
QSize PythonQtShell_abstractBinFileWidget::sizeHint() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("getSizeHint");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return abstractBinFileWidget::sizeHint();
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::tabletEvent(QTabletEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("tabletEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::tabletEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("timerEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::timerEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_abstractBinFileWidget::wheelEvent(QWheelEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("wheelEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
abstractBinFileWidget::wheelEvent(arg__1);
|
|
|
}
|
|
|
abstractBinFileWidget* PythonQtWrapper_abstractBinFileWidget::new_abstractBinFileWidget(QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_abstractBinFileWidget(parent); }
|
|
|
|
|
|
void PythonQtWrapper_abstractBinFileWidget::reloadFile(abstractBinFileWidget* theWrappedObject)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_abstractBinFileWidget*)theWrappedObject)->promoted_reloadFile());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_abstractBinFileWidget::setFile(abstractBinFileWidget* theWrappedObject, abstractBinFile* file)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_abstractBinFileWidget*)theWrappedObject)->promoted_setFile(file));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_binaryFile::~PythonQtShell_binaryFile() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
int PythonQtShell_binaryFile::closeFile()
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("closeFile");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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("closeFile", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return binaryFile::closeFile();
|
|
|
}
|
|
|
QList<codeFragment* > PythonQtShell_binaryFile::getFragments()
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("getFragments");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"QList<codeFragment* >"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QList<codeFragment* > 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("getFragments", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QList<codeFragment* >*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return binaryFile::getFragments();
|
|
|
}
|
|
|
bool PythonQtShell_binaryFile::isopened()
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("isopened");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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("isopened", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return binaryFile::isopened();
|
|
|
}
|
|
|
bool PythonQtShell_binaryFile::openFile(const QString& File0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("openFile");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "const QString&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&File0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return binaryFile::openFile(File0);
|
|
|
}
|
|
|
bool PythonQtShell_binaryFile::toBinary(const QString& fileName0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("toBinary");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "const QString&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&fileName0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return binaryFile::toBinary(fileName0);
|
|
|
}
|
|
|
bool PythonQtShell_binaryFile::toSrec(const QString& fileName0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("toSrec");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "const QString&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&fileName0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return binaryFile::toSrec(fileName0);
|
|
|
}
|
|
|
binaryFile* PythonQtWrapper_binaryFile::new_binaryFile()
|
|
|
{
|
|
|
return new PythonQtShell_binaryFile(); }
|
|
|
|
|
|
binaryFile* PythonQtWrapper_binaryFile::new_binaryFile(const QString& File)
|
|
|
{
|
|
|
return new PythonQtShell_binaryFile(File); }
|
|
|
|
|
|
binaryFile* PythonQtWrapper_binaryFile::new_binaryFile(const QStringList& Files)
|
|
|
{
|
|
|
return new PythonQtShell_binaryFile(Files); }
|
|
|
|
|
|
int PythonQtWrapper_binaryFile::closeFile(binaryFile* theWrappedObject)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_closeFile());
|
|
|
}
|
|
|
|
|
|
codeFragment* PythonQtWrapper_binaryFile::getFragment(binaryFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getFragment(index));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_binaryFile::getFragmentAddress(binaryFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getFragmentAddress(index));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_binaryFile::getFragmentData(binaryFile* theWrappedObject, int index, char** buffer)
|
|
|
{
|
|
|
return ( theWrappedObject->getFragmentData(index, buffer));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_binaryFile::getFragmentHeader(binaryFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getFragmentHeader(index));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_binaryFile::getFragmentSize(binaryFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getFragmentSize(index));
|
|
|
}
|
|
|
|
|
|
QList<codeFragment* > PythonQtWrapper_binaryFile::getFragments(binaryFile* theWrappedObject)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_getFragments());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_binaryFile::getFragmentsCount(binaryFile* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->getFragmentsCount());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_binaryFile::isopened(binaryFile* theWrappedObject)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_isopened());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_binaryFile::openFile(binaryFile* theWrappedObject, const QString& File)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_openFile(File));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_binaryFile::openFiles(binaryFile* theWrappedObject, const QStringList& Files)
|
|
|
{
|
|
|
return ( theWrappedObject->openFiles(Files));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_binaryFile::static_binaryFile_toBinary(QList<codeFragment* > fragments, const QString& File)
|
|
|
{
|
|
|
return (binaryFile::toBinary(fragments, File));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_binaryFile::toBinary(binaryFile* theWrappedObject, const QString& fileName)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_toBinary(fileName));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_binaryFile::toSrec(binaryFile* theWrappedObject, const QString& fileName)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_toSrec(fileName));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_binaryFileWidget::~PythonQtShell_binaryFileWidget() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_binaryFileWidget::reloadFile()
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("reloadFile");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
binaryFileWidget::reloadFile();
|
|
|
}
|
|
|
void PythonQtShell_binaryFileWidget::setFile(abstractBinFile* file0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("setFile");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "abstractBinFile*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&file0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
binaryFileWidget::setFile(file0);
|
|
|
}
|
|
|
binaryFileWidget* PythonQtWrapper_binaryFileWidget::new_binaryFileWidget(QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_binaryFileWidget(parent); }
|
|
|
|
|
|
void PythonQtWrapper_binaryFileWidget::reloadFile(binaryFileWidget* theWrappedObject)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_binaryFileWidget*)theWrappedObject)->promoted_reloadFile());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_binaryFileWidget::setFile(binaryFileWidget* theWrappedObject, abstractBinFile* file)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_binaryFileWidget*)theWrappedObject)->promoted_setFile(file));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_codeFragment::~PythonQtShell_codeFragment() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
codeFragment* PythonQtWrapper_codeFragment::new_codeFragment()
|
|
|
{
|
|
|
return new PythonQtShell_codeFragment(); }
|
|
|
|
|
|
codeFragment* PythonQtWrapper_codeFragment::new_codeFragment(char* data, quint64 size, quint64 address)
|
|
|
{
|
|
|
return new PythonQtShell_codeFragment(data, size, address); }
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_elfFileWidget::~PythonQtShell_elfFileWidget() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_elfFileWidget::reloadFile()
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("reloadFile");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfFileWidget::reloadFile();
|
|
|
}
|
|
|
void PythonQtShell_elfFileWidget::setFile(abstractBinFile* file0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("setFile");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "abstractBinFile*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&file0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfFileWidget::setFile(file0);
|
|
|
}
|
|
|
elfFileWidget* PythonQtWrapper_elfFileWidget::new_elfFileWidget(QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_elfFileWidget(parent); }
|
|
|
|
|
|
void PythonQtWrapper_elfFileWidget::reloadFile(elfFileWidget* theWrappedObject)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_elfFileWidget*)theWrappedObject)->promoted_reloadFile());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_elfFileWidget::setFile(elfFileWidget* theWrappedObject, abstractBinFile* file)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_elfFileWidget*)theWrappedObject)->promoted_setFile(file));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_elfInfoWdgt::~PythonQtShell_elfInfoWdgt() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::actionEvent(QActionEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("actionEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::actionEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::changeEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("changeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::changeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("childEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::closeEvent(QCloseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("closeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::closeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("contextMenuEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::contextMenuEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("customEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::customEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_elfInfoWdgt::devType() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("devType");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return elfInfoWdgt::devType();
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dragEnterEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::dragEnterEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dragLeaveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::dragLeaveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dragMoveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::dragMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::dropEvent(QDropEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dropEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::dropEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::enterEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("enterEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::enterEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_elfInfoWdgt::event(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("event");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return elfInfoWdgt::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_elfInfoWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("eventFilter");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return elfInfoWdgt::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::focusInEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("focusInEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::focusInEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_elfInfoWdgt::focusNextPrevChild(bool next0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("focusNextPrevChild");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&next0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return elfInfoWdgt::focusNextPrevChild(next0);
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::focusOutEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("focusOutEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::focusOutEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_elfInfoWdgt::hasHeightForWidth() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("hasHeightForWidth");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return elfInfoWdgt::hasHeightForWidth();
|
|
|
}
|
|
|
int PythonQtShell_elfInfoWdgt::heightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("heightForWidth");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return elfInfoWdgt::heightForWidth(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::hideEvent(QHideEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("hideEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::hideEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::initPainter(QPainter* painter0) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("initPainter");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&painter0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::initPainter(painter0);
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("inputMethodEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::inputMethodEvent(arg__1);
|
|
|
}
|
|
|
QVariant PythonQtShell_elfInfoWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("inputMethodQuery");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return elfInfoWdgt::inputMethodQuery(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::keyPressEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("keyPressEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::keyPressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::keyReleaseEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("keyReleaseEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::keyReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::leaveEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("leaveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::leaveEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_elfInfoWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("metric");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return elfInfoWdgt::metric(arg__1);
|
|
|
}
|
|
|
QSize PythonQtShell_elfInfoWdgt::minimumSizeHint() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("getMinimumSizeHint");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return elfInfoWdgt::minimumSizeHint();
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::mouseDoubleClickEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::mouseMoveEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mouseMoveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::mouseMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::mousePressEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mousePressEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::mousePressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mouseReleaseEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::mouseReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::moveEvent(QMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("moveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::moveEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_elfInfoWdgt::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("nativeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return elfInfoWdgt::nativeEvent(eventType0, message1, result2);
|
|
|
}
|
|
|
QPaintEngine* PythonQtShell_elfInfoWdgt::paintEngine() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("paintEngine");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return elfInfoWdgt::paintEngine();
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::paintEvent(QPaintEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("paintEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::paintEvent(arg__1);
|
|
|
}
|
|
|
QPaintDevice* PythonQtShell_elfInfoWdgt::redirected(QPoint* offset0) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("redirected");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QPaintDevice* returnValue;
|
|
|
void* args[2] = {NULL, (void*)&offset0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintDevice**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return elfInfoWdgt::redirected(offset0);
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::resizeEvent(QResizeEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("resizeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::resizeEvent(arg__1);
|
|
|
}
|
|
|
QPainter* PythonQtShell_elfInfoWdgt::sharedPainter() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("sharedPainter");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPainter* 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("sharedPainter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPainter**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return elfInfoWdgt::sharedPainter();
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::showEvent(QShowEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("showEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::showEvent(arg__1);
|
|
|
}
|
|
|
QSize PythonQtShell_elfInfoWdgt::sizeHint() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("getSizeHint");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return elfInfoWdgt::sizeHint();
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::tabletEvent(QTabletEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("tabletEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::tabletEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("timerEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::timerEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_elfInfoWdgt::wheelEvent(QWheelEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("wheelEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
elfInfoWdgt::wheelEvent(arg__1);
|
|
|
}
|
|
|
elfInfoWdgt* PythonQtWrapper_elfInfoWdgt::new_elfInfoWdgt(QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_elfInfoWdgt(parent); }
|
|
|
|
|
|
|
|
|
|
|
|
elfparser* PythonQtWrapper_elfparser::new_elfparser()
|
|
|
{
|
|
|
return new elfparser(); }
|
|
|
|
|
|
int PythonQtWrapper_elfparser::closeFile(elfparser* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->closeFile());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_elfparser::getABI(elfparser* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->getABI());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_elfparser::getArchitecture(elfparser* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->getArchitecture());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_elfparser::getClass(elfparser* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->getClass());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_elfparser::getEndianness(elfparser* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->getEndianness());
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_elfparser::getEntryPointAddress(elfparser* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->getEntryPointAddress());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_elfparser::getSectionData(elfparser* theWrappedObject, int index, char** buffer)
|
|
|
{
|
|
|
return ( theWrappedObject->getSectionData(index, buffer));
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_elfparser::getSectionDatasz(elfparser* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSectionDatasz(index));
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_elfparser::getSectionMemsz(elfparser* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSectionMemsz(index));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_elfparser::getSectionName(elfparser* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSectionName(index));
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_elfparser::getSectionPaddr(elfparser* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSectionPaddr(index));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_elfparser::getSectionType(elfparser* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSectionType(index));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_elfparser::getSectioncount(elfparser* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->getSectioncount());
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_elfparser::getSegmentFilesz(elfparser* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSegmentFilesz(index));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_elfparser::getSegmentFlags(elfparser* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSegmentFlags(index));
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_elfparser::getSegmentMemsz(elfparser* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSegmentMemsz(index));
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_elfparser::getSegmentOffset(elfparser* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSegmentOffset(index));
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_elfparser::getSegmentPaddr(elfparser* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSegmentPaddr(index));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_elfparser::getSegmentType(elfparser* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSegmentType(index));
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_elfparser::getSegmentVaddr(elfparser* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getSegmentVaddr(index));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_elfparser::getSegmentcount(elfparser* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->getSegmentcount());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_elfparser::getType(elfparser* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->getType());
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_elfparser::getVersion(elfparser* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->getVersion());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_elfparser::static_elfparser_isElf(const QString& File)
|
|
|
{
|
|
|
return (elfparser::isElf(File));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_elfparser::iself(elfparser* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->iself());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_elfparser::isopened(elfparser* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->isopened());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_elfparser::setFilename(elfparser* theWrappedObject, const QString& name)
|
|
|
{
|
|
|
return ( theWrappedObject->setFilename(name));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_genericBinaryFileWidget::~PythonQtShell_genericBinaryFileWidget() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::actionEvent(QActionEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("actionEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::actionEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::changeEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("changeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::changeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("childEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::closeEvent(QCloseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("closeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::closeEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("contextMenuEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::contextMenuEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("customEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::customEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_genericBinaryFileWidget::devType() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("devType");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return genericBinaryFileWidget::devType();
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dragEnterEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::dragEnterEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dragLeaveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::dragLeaveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dragMoveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::dragMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::dropEvent(QDropEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("dropEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::dropEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::enterEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("enterEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::enterEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_genericBinaryFileWidget::event(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("event");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return genericBinaryFileWidget::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_genericBinaryFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("eventFilter");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return genericBinaryFileWidget::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::focusInEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("focusInEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::focusInEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_genericBinaryFileWidget::focusNextPrevChild(bool next0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("focusNextPrevChild");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "bool"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&next0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return genericBinaryFileWidget::focusNextPrevChild(next0);
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::focusOutEvent(QFocusEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("focusOutEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::focusOutEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_genericBinaryFileWidget::hasHeightForWidth() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("hasHeightForWidth");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return genericBinaryFileWidget::hasHeightForWidth();
|
|
|
}
|
|
|
int PythonQtShell_genericBinaryFileWidget::heightForWidth(int arg__1) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("heightForWidth");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return genericBinaryFileWidget::heightForWidth(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::hideEvent(QHideEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("hideEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::hideEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::initPainter(QPainter* painter0) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("initPainter");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&painter0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::initPainter(painter0);
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("inputMethodEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::inputMethodEvent(arg__1);
|
|
|
}
|
|
|
QVariant PythonQtShell_genericBinaryFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("inputMethodQuery");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return genericBinaryFileWidget::inputMethodQuery(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::keyPressEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("keyPressEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::keyPressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("keyReleaseEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::keyReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::leaveEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("leaveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::leaveEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_genericBinaryFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("metric");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return genericBinaryFileWidget::metric(arg__1);
|
|
|
}
|
|
|
QSize PythonQtShell_genericBinaryFileWidget::minimumSizeHint() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("getMinimumSizeHint");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return genericBinaryFileWidget::minimumSizeHint();
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::mouseDoubleClickEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mouseMoveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::mouseMoveEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::mousePressEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mousePressEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::mousePressEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("mouseReleaseEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::mouseReleaseEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::moveEvent(QMoveEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("moveEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::moveEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_genericBinaryFileWidget::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("nativeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return genericBinaryFileWidget::nativeEvent(eventType0, message1, result2);
|
|
|
}
|
|
|
QPaintEngine* PythonQtShell_genericBinaryFileWidget::paintEngine() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("paintEngine");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return genericBinaryFileWidget::paintEngine();
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::paintEvent(QPaintEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("paintEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::paintEvent(arg__1);
|
|
|
}
|
|
|
QPaintDevice* PythonQtShell_genericBinaryFileWidget::redirected(QPoint* offset0) const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("redirected");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
QPaintDevice* returnValue;
|
|
|
void* args[2] = {NULL, (void*)&offset0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPaintDevice**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return genericBinaryFileWidget::redirected(offset0);
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::resizeEvent(QResizeEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("resizeEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::resizeEvent(arg__1);
|
|
|
}
|
|
|
QPainter* PythonQtShell_genericBinaryFileWidget::sharedPainter() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("sharedPainter");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"QPainter*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QPainter* 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("sharedPainter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QPainter**)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return genericBinaryFileWidget::sharedPainter();
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::showEvent(QShowEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("showEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::showEvent(arg__1);
|
|
|
}
|
|
|
QSize PythonQtShell_genericBinaryFileWidget::sizeHint() const
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("getSizeHint");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return genericBinaryFileWidget::sizeHint();
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::tabletEvent(QTabletEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("tabletEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::tabletEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("timerEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::timerEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_genericBinaryFileWidget::wheelEvent(QWheelEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("wheelEvent");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
genericBinaryFileWidget::wheelEvent(arg__1);
|
|
|
}
|
|
|
genericBinaryFileWidget* PythonQtWrapper_genericBinaryFileWidget::new_genericBinaryFileWidget(QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_genericBinaryFileWidget(parent); }
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_srecFile::~PythonQtShell_srecFile() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
int PythonQtShell_srecFile::closeFile()
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("closeFile");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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("closeFile", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return srecFile::closeFile();
|
|
|
}
|
|
|
QList<codeFragment* > PythonQtShell_srecFile::getFragments()
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("getFragments");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"QList<codeFragment* >"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QList<codeFragment* > 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("getFragments", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QList<codeFragment* >*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return srecFile::getFragments();
|
|
|
}
|
|
|
bool PythonQtShell_srecFile::isopened()
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("isopened");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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("isopened", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return srecFile::isopened();
|
|
|
}
|
|
|
bool PythonQtShell_srecFile::openFile(const QString& File0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("openFile");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "const QString&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&File0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return srecFile::openFile(File0);
|
|
|
}
|
|
|
bool PythonQtShell_srecFile::toBinary(const QString& File0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("toBinary");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "const QString&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&File0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return srecFile::toBinary(File0);
|
|
|
}
|
|
|
bool PythonQtShell_srecFile::toSrec(const QString& File0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("toSrec");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"bool" , "const QString&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&File0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) {
|
|
|
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
|
|
if (args[0]!=&returnValue) {
|
|
|
if (args[0]==NULL) {
|
|
|
PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
return srecFile::toSrec(File0);
|
|
|
}
|
|
|
srecFile* PythonQtWrapper_srecFile::new_srecFile()
|
|
|
{
|
|
|
return new PythonQtShell_srecFile(); }
|
|
|
|
|
|
srecFile* PythonQtWrapper_srecFile::new_srecFile(const QString& File)
|
|
|
{
|
|
|
return new PythonQtShell_srecFile(File); }
|
|
|
|
|
|
srecFile* PythonQtWrapper_srecFile::new_srecFile(const QStringList& Files)
|
|
|
{
|
|
|
return new PythonQtShell_srecFile(Files); }
|
|
|
|
|
|
bool PythonQtWrapper_srecFile::static_srecFile_checkSum(const QString& line)
|
|
|
{
|
|
|
return (srecFile::checkSum(line));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_srecFile::closeFile(srecFile* theWrappedObject)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_closeFile());
|
|
|
}
|
|
|
|
|
|
codeFragment* PythonQtWrapper_srecFile::getFragment(srecFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getFragment(index));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_srecFile::getFragmentAddress(srecFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getFragmentAddress(index));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_srecFile::getFragmentData(srecFile* theWrappedObject, int index, char** buffer)
|
|
|
{
|
|
|
return ( theWrappedObject->getFragmentData(index, buffer));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_srecFile::getFragmentHeader(srecFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getFragmentHeader(index));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_srecFile::getFragmentSize(srecFile* theWrappedObject, int index)
|
|
|
{
|
|
|
return ( theWrappedObject->getFragmentSize(index));
|
|
|
}
|
|
|
|
|
|
QList<codeFragment* > PythonQtWrapper_srecFile::getFragments(srecFile* theWrappedObject)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_getFragments());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_srecFile::getFragmentsCount(srecFile* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->getFragmentsCount());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_srecFile::isSREC(srecFile* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->isSREC());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_srecFile::static_srecFile_isSREC(const QString& File)
|
|
|
{
|
|
|
return (srecFile::isSREC(File));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_srecFile::isopened(srecFile* theWrappedObject)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_isopened());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_srecFile::lineCount(srecFile* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->lineCount());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_srecFile::mergingRecords(srecFile* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->mergingRecords());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_srecFile::openFile(srecFile* theWrappedObject, const QString& File)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_openFile(File));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_srecFile::openFiles(srecFile* theWrappedObject, const QStringList& Files)
|
|
|
{
|
|
|
return ( theWrappedObject->openFiles(Files));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_srecFile::setMergingRecords(srecFile* theWrappedObject, bool enabled)
|
|
|
{
|
|
|
( theWrappedObject->setMergingRecords(enabled));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_srecFile::toBinary(srecFile* theWrappedObject, const QString& File)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_toBinary(File));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_srecFile::static_srecFile_toSrec(QList<codeFragment* > fragments, const QString& File)
|
|
|
{
|
|
|
return (srecFile::toSrec(fragments, File));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_srecFile::toSrec(srecFile* theWrappedObject, const QString& File)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_toSrec(File));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_srecFileWidget::~PythonQtShell_srecFileWidget() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_srecFileWidget::reloadFile()
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("reloadFile");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (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;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
srecFileWidget::reloadFile();
|
|
|
}
|
|
|
void PythonQtShell_srecFileWidget::setFile(abstractBinFile* file0)
|
|
|
{
|
|
|
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
|
|
|
static PyObject* name = PyString_FromString("setFile");
|
|
|
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
|
|
|
if (obj) {
|
|
|
static const char* argumentList[] ={"" , "abstractBinFile*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&file0};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
} else {
|
|
|
PyErr_Clear();
|
|
|
}
|
|
|
}
|
|
|
srecFileWidget::setFile(file0);
|
|
|
}
|
|
|
srecFileWidget* PythonQtWrapper_srecFileWidget::new_srecFileWidget(QWidget* parent)
|
|
|
{
|
|
|
return new PythonQtShell_srecFileWidget(parent); }
|
|
|
|
|
|
void PythonQtWrapper_srecFileWidget::reloadFile(srecFileWidget* theWrappedObject)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_srecFileWidget*)theWrappedObject)->promoted_reloadFile());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_srecFileWidget::setFile(srecFileWidget* theWrappedObject, abstractBinFile* file)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_srecFileWidget*)theWrappedObject)->promoted_setFile(file));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
