##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » SocExplorer
RSS
Added bool loadfile(abstractBinFile* file)...
jeandet -
r71:c4b98d42ee59 default
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,4 +1,4
1 1 2c82d72694590cbc2aebb946667f11f60ea89afe src/SocExplorerEngine/PeripheralWidget
2 e0f25227d6283e833fbb70c5fc1bdc6c3ca8060e src/common/genericBinaryFiles
2 cc958c79ba0939809a70e63b8bac798930160243 src/common/genericBinaryFiles
3 3 2dce25b198558be573f56c1cf337aa95ddd666d6 src/common/lppserial
4 4 923afde9cc96bb419cf898560d080ec96991aeca src/common/qhexedit
Show file before | Show file after | Hide comments
@@ -3,6 +3,7 QT += core gui xml svg network
3 3 contains(QT_MAJOR_VERSION, 5) {
4 4 QT += widgets
5 5 QT += printsupport
6 QT += multimedia multimediawidgets
6 7 }
7 8
8 9 SOCEXPLORER_SDK_BUILD="SOCEXPLORER_SDK_BUILD"
Show file before | Show file after | Hide comments
@@ -27,6 +27,7 SOCModel::SOCModel(socexplorerplugin *ro
27 27 QObject(parent)
28 28 {
29 29 p_rootDev = rootDev;
30 p_litleEndian = false;
30 31 }
31 32
32 33 qint32 SOCModel::getEnumDeviceBaseAddress(int VID, int PID, int count)
@@ -110,3 +111,8 qint32 SOCModel::readReg(qint32 address)
110 111 p_rootDev->Read(&valueInt,1,addressInt);
111 112 return (qint32)valueInt;
112 113 }
114
115 bool SOCModel::isLitleEndian()
116 {
117 return p_litleEndian;
118 }
Show file before | Show file after | Hide comments
@@ -94,10 +94,12 public slots:
94 94 int addEnumDevice(socExplorerEnumDevice* device);
95 95 void writeReg(qint32 address,qint32 value);
96 96 qint32 readReg(qint32 address);
97 bool isLitleEndian();
97 98 private:
98 99 socexplorerplugin* p_rootDev;
99 100 QList<socExplorerEnumDevice*> p_enumeratedDevices;
100 101 QList<SOCclk*> clktree;
102 bool p_litleEndian;
101 103 };
102 104
103 105
Show file before | Show file after | Hide comments
@@ -89,6 +89,7 INCLUDEPATH += engine \
89 89 plugins \
90 90 pluginManagerWdgt \
91 91 ../common \
92 ../common/genericBinaryFiles \
92 93 ../ \
93 94 RegisterMVS \
94 95 XmlEngine \
Show file before | Show file after | Hide comments
@@ -281,5 +281,10 void SocExplorerEngine::setLogLevel(int
281 281 loglvl = level;
282 282 }
283 283
284 bool SocExplorerEngine::isSocLitleEndian(socexplorerplugin *plugin)
285 {
286 return plugin2Soc(plugin)->isLitleEndian();
287 }
284 288
285 289
290
Show file before | Show file after | Hide comments
@@ -107,6 +107,7 public:
107 107 static void removeSOC(socexplorerplugin* rootPlugin);
108 108 static void message(socexplorerplugin* sender,const QString& message,int debugLevel=0);
109 109 static void setLogLevel(int level);
110 static bool isSocLitleEndian(socexplorerplugin* plugin);
110 111 signals:
111 112 void enumDeviceAdded(socExplorerEnumDevice* device);
112 113 public slots:
Show file before | Show file after | Hide comments
@@ -11,7 +11,7
11 11 #endif
12 12 #endif
13 13
14
14 #include <socexplorerengine.h>
15 15
16 16
17 17 genericPySysdriver::genericPySysdriver(socexplorerplugin* plugin,QObject* parent):
@@ -44,56 +44,28 void genericPySysdriver::Write(unsigned
44 44
45 45 bool genericPySysdriver::dumpMemory(unsigned int address,unsigned int count,QString file)
46 46 {
47 unsigned int* buffer = (unsigned int*)malloc(count*sizeof(unsigned int));
48 if(buffer!=NULL)
49 {
50 this->plugin->Read(buffer,count,address);
51 QFile outfile(file);
52 if (!outfile.open(QIODevice::ReadWrite | QIODevice::Text))
53 return false;
54 QTextStream out(&outfile);
55 for(int i=0;(unsigned int)i<count;i++)
56 out << "0x"+QString::number(address+(i*4),16) + ": 0x" + QString::number(buffer[i],16) + "\n";
57 free(buffer);
58 out.flush();
59 outfile.close();
60 return true;
61 }
62 return false;
47 return this->plugin->dumpMemory(address,count,file);
63 48 }
64 49
65 50 bool genericPySysdriver::memSet(unsigned int address,int value, unsigned int count)
66 51 {
67 unsigned int* buffer = (unsigned int*)malloc(count*sizeof(unsigned int));
68 if(buffer!=NULL)
69 {
70 memset((void*)buffer,value,count*sizeof(unsigned int));
71 this->plugin->Write(buffer,count,address);
72 free(buffer );
73 return true;
74 }
75 return false;
52 return this->plugin->memSet(address,value,count);
76 53 }
77 54
78 55 bool genericPySysdriver::loadbin(unsigned int address,QString file)
79 56 {
80 QFile infile(file);
81 if (!infile.open(QIODevice::ReadOnly))
82 return false;
83 uint32_t* buffer = (uint32_t*)malloc(infile.size());
84 if(buffer!=NULL)
85 {
86 infile.read((char*)buffer,infile.size());
87 for(int i=0;i<(infile.size()/4);i++)
88 {
89 buffer[i] = socexplorerBswap32(buffer[i]);
90 }
91 this->plugin->Write(buffer,infile.size()/4,address);
92 free(buffer);
93 return true;
94 }
95 return false;
57 return this->plugin->loadbin(address,file);
58
59 }
96 60
61 bool genericPySysdriver::loadfile(abstractBinFile *file)
62 {
63 return this->plugin->loadfile(file);
64 }
65
66 bool genericPySysdriver::dumpMemory(unsigned int address, unsigned int count, QString file, const QString &format)
67 {
68 return this->plugin->dumpMemory(address,count,file,format);
97 69 }
98 70
99 71 QString genericPySysdriver::instance()
Show file before | Show file after | Hide comments
@@ -28,6 +28,7
28 28 #include <QFile>
29 29 #include <stdint.h>
30 30 #include <QTextStream>
31 #include <abstractbinfile.h>
31 32 #if defined(SOCEXPLORER_SDK_BUILD)
32 33 # define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
33 34 #else
@@ -49,6 +50,8 public slots:
49 50 bool dumpMemory(unsigned int address,unsigned int count,QString file);
50 51 bool memSet(unsigned int address,int value, unsigned int count);
51 52 bool loadbin(unsigned int address,QString file);
53 bool loadfile(abstractBinFile* file);
54 bool dumpMemory(unsigned int address, unsigned int count, QString file, const QString &format);
52 55 QString instance();
53 56 private:
54 57 socexplorerplugin* plugin;
Show file before | Show file after | Hide comments
@@ -21,7 +21,9
21 21 ----------------------------------------------------------------------------*/
22 22
23 23 #include <socexplorerplugin.h>
24
24 #include <abstractbinfile.h>
25 #include <srec/srecfile.h>
26 #include <BinFile/binaryfile.h>
25 27
26 28 int socexplorerplugin::isConnected(){return this->Connected;}
27 29
@@ -33,44 +35,44 void socexplorerplugin::setBaseAddress(u
33 35
34 36 QString socexplorerplugin::instanceName()
35 37 {
36 return this->_instanceName;
38 return this->_instanceName;
37 39 }
38 40
39 41 int socexplorerplugin::registermenu(QMenu *menu)
40 42 {
41 this->menu = menu->addMenu(this->_instanceName);
42 this->closeAction = this->menu->addAction(tr("Close plugin"));
43 QObject::connect(this->closeAction,SIGNAL(triggered()),this,SLOT(closeMe()));
44 this->ChildsMenu = this->menu->addMenu(QString("Childs"));
45 for(int i=0;i<this->childs.count();i++)
43 this->menu = menu->addMenu(this->_instanceName);
44 this->closeAction = this->menu->addAction(tr("Close plugin"));
45 QObject::connect(this->closeAction,SIGNAL(triggered()),this,SLOT(closeMe()));
46 this->ChildsMenu = this->menu->addMenu(QString("Childs"));
47 for(int i=0;i<this->childs.count();i++)
46 48 {
47 this->childs.at(i)->registermenu(this->ChildsMenu);
49 this->childs.at(i)->registermenu(this->ChildsMenu);
48 50 }
49 if(this->pyObject!=NULL)emit this->registerObject((QObject*)this->pyObject,this->instanceName());
50 return 0;
51 if(this->pyObject!=NULL)emit this->registerObject((QObject*)this->pyObject,this->instanceName());
52 return 0;
51 53 }
52 54
53 55 void socexplorerplugin::postInstantiationTrigger()
54 56 {
55 return;
57 return;
56 58 }
57 59
58 60 unsigned int socexplorerplugin::Write(unsigned int *Value, unsigned int count, unsigned int address)
59 61 {
60 if(parent!=NULL)
62 if(parent!=NULL)
61 63 {
62 return parent->Write(Value,count,address);
64 return parent->Write(Value,count,address);
63 65 }
64 return 0;
66 return 0;
65 67 }
66 68
67 69 unsigned int socexplorerplugin::Read(unsigned int *Value, unsigned int count, unsigned int address)
68 70 {
69 if(parent!=NULL)
71 if(parent!=NULL)
70 72 {
71 return parent->Read(Value,count,address);
73 return parent->Read(Value,count,address);
72 74 }
73 return 0;
75 return 0;
74 76 }
75 77
76 78 void socexplorerplugin::closeMe(){emit this->closePlugin(this);}
@@ -79,13 +81,164 void socexplorerplugin::activate(bool fl
79 81
80 82 void socexplorerplugin::setInstanceName(const QString &newName)
81 83 {
82 this->_instanceName = newName;
83 if(this->menu)
84 this->menu->setTitle(this->_instanceName);
85 this->setWindowTitle(newName);
84 this->_instanceName = newName;
85 if(this->menu)
86 this->menu->setTitle(this->_instanceName);
87 this->setWindowTitle(newName);
88 }
89
90 bool socexplorerplugin::dumpMemory(unsigned int address, unsigned int count, QString file)
91 {
92 unsigned int* buffer = (unsigned int*)malloc(count*sizeof(unsigned int));
93 if(buffer!=NULL)
94 {
95 this->Read(buffer,count,address);
96 QFile outfile(file);
97 if (!outfile.open(QIODevice::ReadWrite | QIODevice::Text))
98 return false;
99 QTextStream out(&outfile);
100 for(int i=0;(unsigned int)i<count;i++)
101 out << "0x"+QString::number(address+(i*4),16) + ": 0x" + QString::number(buffer[i],16) + "\n";
102 free(buffer);
103 out.flush();
104 outfile.close();
105 return true;
106 }
107 return false;
108 }
109
110 bool socexplorerplugin::memSet(unsigned int address, int value, unsigned int count)
111 {
112 unsigned int* buffer = (unsigned int*)malloc(count*sizeof(unsigned int));
113 if(buffer!=NULL)
114 {
115 memset((void*)buffer,value,count*sizeof(unsigned int));
116 this->Write(buffer,count,address);
117 free(buffer );
118 return true;
119 }
120 return false;
121 }
122
123 bool socexplorerplugin::loadbin(unsigned int address, QString file)
124 {
125 QFile infile(file);
126 if (!infile.open(QIODevice::ReadOnly))
127 return false;
128 uint32_t* buffer = (uint32_t*)malloc(infile.size());
129 if(buffer!=NULL)
130 {
131 infile.read((char*)buffer,infile.size());
132 for(int i=0;i<(infile.size()/4);i++)
133 {
134 buffer[i] = socexplorerBswap32(buffer[i]);
135 }
136 this->Write(buffer,infile.size()/4,address);
137 free(buffer);
138 return true;
139 }
140 return false;
141
142 }
143
144 bool socexplorerplugin::loadfile(abstractBinFile *file)
145 {
146 if(file->isopened())
147 {
148 QList<codeFragment*> fragments= file->getFragments();
149 for(int i=0;i<fragments.count();i++)
150 {
151 int size = fragments.at(i)->size/4;
152 // TODO fixme, should be the oposite
153 #if __BYTE_ORDER == __LITTLE_ENDIAN
154 if(!file->litleendian)
155 {
156 uint32_t* buffer = (uint32_t*)malloc(fragments.at(i)->size);
157 memcpy(buffer,fragments.at(i)->data,fragments.at(i)->size);
158 if(buffer!=NULL)
159 {
160 for(int l=0;l<(size);l++)
161 {
162 buffer[l] = socexplorerBswap32(buffer[l]);
163 }
164 this->Write(buffer,size,fragments.at(i)->address);
165 free(buffer);
166 }
167 }
168 else
169 {
170 this->Write((uint32_t*) fragments.at(i)->data,size,fragments.at(i)->address);
171 }
172 #elif __BYTE_ORDER == __BIG_ENDIAN
173 if(file->litleendian)
174 {
175 uint32_t* buffer = (uint32_t*)malloc(fragments.at(i)->size);
176 memcpy(buffer,fragments.at(i)->data,fragments.at(i)->size);
177 if(buffer!=NULL)
178 {
179 for(int l=0;l<(size);l++)
180 {
181 buffer[l] = socexplorerBswap32(buffer[l]);
182 }
183 this->Write(buffer,size,fragments.at(i)->address);
184 free(buffer);
185 }
186 }
187 else
188 {
189 this->Write((uint32_t*) fragments.at(i)->data,size,fragments.at(i)->address);
190 }
191 #endif
192 }
193 }
194 return true;
195 }
196
197 bool socexplorerplugin::dumpMemory(unsigned int address, unsigned int count, QString file, const QString &format)
198 {
199 unsigned int* buffer = (unsigned int*)malloc(count*sizeof(unsigned int));
200 if(buffer!=NULL)
201 {
202 this->Read(buffer,count,address);
203 if(!format.compare("srec",Qt::CaseInsensitive))
204 {
205 //need to convert from in memory endianness to file endianness
206 //SREC is always big endian
207 #if __BYTE_ORDER == __LITTLE_ENDIAN
208 for(int l=0;l<(count);l++)
209 {
210 buffer[l] = socexplorerBswap32(buffer[l]);
211 }
212 #elif __BYTE_ORDER == __BIG_ENDIAN
213
214 #endif
215 codeFragment fragment((char*)buffer,count*4,address);
216 srecFile::toSrec(QList<codeFragment*>()<<&fragment,file);
217 }
218 if(!format.compare("bin",Qt::CaseInsensitive))
219 {
220 //beware this format is not portable from a big endian host to a litle endian one
221 codeFragment fragment((char*)buffer,count*4,address);
222 binaryFile::toBinary(QList<codeFragment*>()<<&fragment,file);
223 }
224 if(!format.compare("hexa",Qt::CaseInsensitive))
225 {
226 QFile outfile(file);
227 if (!outfile.open(QIODevice::ReadWrite | QIODevice::Text))
228 return false;
229 QTextStream out(&outfile);
230 for(int i=0;(unsigned int)i<count;i++)
231 out << "0x"+QString::number(address+(i*4),16) + ": 0x" + QString::number(buffer[i],16) + "\n";
232 free(buffer);
233 out.flush();
234 outfile.close();
235 }
236 return true;
237 }
238 return false;
86 239 }
87 240
88 241 void socexplorerplugin::makeGenericPyWrapper()
89 242 {
90 this->pyObject = new genericPySysdriver(this);
243 this->pyObject = new genericPySysdriver(this);
91 244 }
Show file before | Show file after | Hide comments
@@ -43,6 +43,7
43 43 #include <stdint.h>
44 44 #include <QTextStream>
45 45 #include <genericPySysdriver.h>
46 #include <abstractbinfile.h>
46 47 #ifndef driver_Name
47 48 #define driver_Name "Plugin"
48 49 #endif
@@ -161,6 +162,12 public slots:
161 162 virtual void closeMe();
162 163 virtual void activate(bool flag);
163 164 virtual void setInstanceName(const QString& newName);
165
166 virtual bool dumpMemory(unsigned int address,unsigned int count,QString file);
167 virtual bool memSet(unsigned int address,int value, unsigned int count);
168 virtual bool loadbin(unsigned int address,QString file);
169 virtual bool loadfile(abstractBinFile* file);
170 virtual bool dumpMemory(unsigned int address,unsigned int count,QString file,const QString& format);
164 171 protected:
165 172 void makeGenericPyWrapper();
166 173 int BaseAddress;
Show file before | Show file after | Hide comments
This diff has been collapsed as it changes many lines, (4709 lines changed) Show them Hide them
@@ -2,11 +2,11
2 2 #include <PythonQtConversion.h>
3 3 #include <PythonQtMethodInfo.h>
4 4 #include <PythonQtSignalReceiver.h>
5 #include <QIconEngine>
6 5 #include <QVariant>
7 6 #include <abstractbinfile.h>
8 7 #include <elfparser.h>
9 8 #include <qaction.h>
9 #include <qbackingstore.h>
10 10 #include <qbitmap.h>
11 11 #include <qbytearray.h>
12 12 #include <qcolor.h>
@@ -17,12 +17,14
17 17 #include <qfont.h>
18 18 #include <qgraphicseffect.h>
19 19 #include <qgraphicsproxywidget.h>
20 #include <qicon.h>
20 21 #include <qkeysequence.h>
21 22 #include <qlayout.h>
22 23 #include <qlineedit.h>
23 24 #include <qlist.h>
24 25 #include <qlocale.h>
25 26 #include <qmargins.h>
27 #include <qmetaobject.h>
26 28 #include <qobject.h>
27 29 #include <qpaintdevice.h>
28 30 #include <qpaintengine.h>
@@ -42,6 +44,7
42 44 #include <qstyle.h>
43 45 #include <qstyleoption.h>
44 46 #include <qwidget.h>
47 #include <qwindow.h>
45 48
46 49 PythonQtShell_ElfFile::~PythonQtShell_ElfFile() {
47 50 PythonQtPrivate* priv = PythonQt::priv();
@@ -49,10 +52,10 PythonQtShell_ElfFile::~PythonQtShell_El
49 52 }
50 53 int PythonQtShell_ElfFile::closeFile()
51 54 {
52 if (_wrapper) {
53 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
54 PyErr_Clear();
55 if (obj && !PythonQtSlotFunction_Check(obj)) {
55 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
56 static PyObject* name = PyString_FromString("closeFile");
57 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
58 if (obj) {
56 59 static const char* argumentList[] ={"int"};
57 60 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
58 61 int returnValue;
@@ -71,16 +74,18 if (_wrapper) {
71 74 if (result) { Py_DECREF(result); }
72 75 Py_DECREF(obj);
73 76 return returnValue;
77 } else {
78 PyErr_Clear();
74 79 }
75 80 }
76 81 return ElfFile::closeFile();
77 82 }
78 83 QList<codeFragment* > PythonQtShell_ElfFile::getFragments()
79 84 {
80 if (_wrapper) {
81 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
82 PyErr_Clear();
83 if (obj && !PythonQtSlotFunction_Check(obj)) {
85 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
86 static PyObject* name = PyString_FromString("getFragments");
87 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
88 if (obj) {
84 89 static const char* argumentList[] ={"QList<codeFragment* >"};
85 90 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
86 91 QList<codeFragment* > returnValue;
@@ -99,16 +104,18 if (_wrapper) {
99 104 if (result) { Py_DECREF(result); }
100 105 Py_DECREF(obj);
101 106 return returnValue;
107 } else {
108 PyErr_Clear();
102 109 }
103 110 }
104 111 return ElfFile::getFragments();
105 112 }
106 113 bool PythonQtShell_ElfFile::isopened()
107 114 {
108 if (_wrapper) {
109 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
110 PyErr_Clear();
111 if (obj && !PythonQtSlotFunction_Check(obj)) {
115 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
116 static PyObject* name = PyString_FromString("isopened");
117 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
118 if (obj) {
112 119 static const char* argumentList[] ={"bool"};
113 120 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
114 121 bool returnValue;
@@ -127,20 +134,22 if (_wrapper) {
127 134 if (result) { Py_DECREF(result); }
128 135 Py_DECREF(obj);
129 136 return returnValue;
137 } else {
138 PyErr_Clear();
130 139 }
131 140 }
132 141 return ElfFile::isopened();
133 142 }
134 bool PythonQtShell_ElfFile::openFile(const QString& File)
135 {
136 if (_wrapper) {
137 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
138 PyErr_Clear();
139 if (obj && !PythonQtSlotFunction_Check(obj)) {
143 bool PythonQtShell_ElfFile::openFile(const QString& File0)
144 {
145 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
146 static PyObject* name = PyString_FromString("openFile");
147 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
148 if (obj) {
140 149 static const char* argumentList[] ={"bool" , "const QString&"};
141 150 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
142 151 bool returnValue;
143 void* args[2] = {NULL, (void*)&File};
152 void* args[2] = {NULL, (void*)&File0};
144 153 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
145 154 if (result) {
146 155 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -155,20 +164,22 if (_wrapper) {
155 164 if (result) { Py_DECREF(result); }
156 165 Py_DECREF(obj);
157 166 return returnValue;
158 }
159 }
160 return ElfFile::openFile(File);
161 }
162 bool PythonQtShell_ElfFile::toBinary(const QString& File)
163 {
164 if (_wrapper) {
165 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
166 PyErr_Clear();
167 if (obj && !PythonQtSlotFunction_Check(obj)) {
167 } else {
168 PyErr_Clear();
169 }
170 }
171 return ElfFile::openFile(File0);
172 }
173 bool PythonQtShell_ElfFile::toBinary(const QString& File0)
174 {
175 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
176 static PyObject* name = PyString_FromString("toBinary");
177 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
178 if (obj) {
168 179 static const char* argumentList[] ={"bool" , "const QString&"};
169 180 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
170 181 bool returnValue;
171 void* args[2] = {NULL, (void*)&File};
182 void* args[2] = {NULL, (void*)&File0};
172 183 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
173 184 if (result) {
174 185 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -183,20 +194,22 if (_wrapper) {
183 194 if (result) { Py_DECREF(result); }
184 195 Py_DECREF(obj);
185 196 return returnValue;
186 }
187 }
188 return ElfFile::toBinary(File);
189 }
190 bool PythonQtShell_ElfFile::toSrec(const QString& File)
191 {
192 if (_wrapper) {
193 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
194 PyErr_Clear();
195 if (obj && !PythonQtSlotFunction_Check(obj)) {
197 } else {
198 PyErr_Clear();
199 }
200 }
201 return ElfFile::toBinary(File0);
202 }
203 bool PythonQtShell_ElfFile::toSrec(const QString& File0)
204 {
205 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
206 static PyObject* name = PyString_FromString("toSrec");
207 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
208 if (obj) {
196 209 static const char* argumentList[] ={"bool" , "const QString&"};
197 210 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
198 211 bool returnValue;
199 void* args[2] = {NULL, (void*)&File};
212 void* args[2] = {NULL, (void*)&File0};
200 213 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
201 214 if (result) {
202 215 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -211,9 +224,11 if (_wrapper) {
211 224 if (result) { Py_DECREF(result); }
212 225 Py_DECREF(obj);
213 226 return returnValue;
214 }
215 }
216 return ElfFile::toSrec(File);
227 } else {
228 PyErr_Clear();
229 }
230 }
231 return ElfFile::toSrec(File0);
217 232 }
218 233 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile()
219 234 {
@@ -393,11 +408,21 qint64 PythonQtWrapper_ElfFile::getVers
393 408 return ( theWrappedObject->getVersion());
394 409 }
395 410
411 bool PythonQtWrapper_ElfFile::isBigEndian(ElfFile* theWrappedObject)
412 {
413 return ( theWrappedObject->isBigEndian());
414 }
415
396 416 bool PythonQtWrapper_ElfFile::static_ElfFile_isElf(const QString& File)
397 417 {
398 418 return (ElfFile::isElf(File));
399 419 }
400 420
421 bool PythonQtWrapper_ElfFile::isLitleEndian(ElfFile* theWrappedObject)
422 {
423 return ( theWrappedObject->isLitleEndian());
424 }
425
401 426 bool PythonQtWrapper_ElfFile::iself(ElfFile* theWrappedObject)
402 427 {
403 428 return ( theWrappedObject->iself());
@@ -436,10 +461,10 PythonQtShell_MemSizeWdgt::~PythonQtShel
436 461 }
437 462 void PythonQtShell_MemSizeWdgt::actionEvent(QActionEvent* arg__1)
438 463 {
439 if (_wrapper) {
440 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
441 PyErr_Clear();
442 if (obj && !PythonQtSlotFunction_Check(obj)) {
464 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
465 static PyObject* name = PyString_FromString("actionEvent");
466 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
467 if (obj) {
443 468 static const char* argumentList[] ={"" , "QActionEvent*"};
444 469 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
445 470 void* args[2] = {NULL, (void*)&arg__1};
@@ -447,16 +472,18 if (_wrapper) {
447 472 if (result) { Py_DECREF(result); }
448 473 Py_DECREF(obj);
449 474 return;
475 } else {
476 PyErr_Clear();
450 477 }
451 478 }
452 479 MemSizeWdgt::actionEvent(arg__1);
453 480 }
454 481 void PythonQtShell_MemSizeWdgt::changeEvent(QEvent* arg__1)
455 482 {
456 if (_wrapper) {
457 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
458 PyErr_Clear();
459 if (obj && !PythonQtSlotFunction_Check(obj)) {
483 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
484 static PyObject* name = PyString_FromString("changeEvent");
485 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
486 if (obj) {
460 487 static const char* argumentList[] ={"" , "QEvent*"};
461 488 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
462 489 void* args[2] = {NULL, (void*)&arg__1};
@@ -464,16 +491,18 if (_wrapper) {
464 491 if (result) { Py_DECREF(result); }
465 492 Py_DECREF(obj);
466 493 return;
494 } else {
495 PyErr_Clear();
467 496 }
468 497 }
469 498 MemSizeWdgt::changeEvent(arg__1);
470 499 }
471 500 void PythonQtShell_MemSizeWdgt::childEvent(QChildEvent* arg__1)
472 501 {
473 if (_wrapper) {
474 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
475 PyErr_Clear();
476 if (obj && !PythonQtSlotFunction_Check(obj)) {
502 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
503 static PyObject* name = PyString_FromString("childEvent");
504 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
505 if (obj) {
477 506 static const char* argumentList[] ={"" , "QChildEvent*"};
478 507 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
479 508 void* args[2] = {NULL, (void*)&arg__1};
@@ -481,16 +510,18 if (_wrapper) {
481 510 if (result) { Py_DECREF(result); }
482 511 Py_DECREF(obj);
483 512 return;
513 } else {
514 PyErr_Clear();
484 515 }
485 516 }
486 517 MemSizeWdgt::childEvent(arg__1);
487 518 }
488 519 void PythonQtShell_MemSizeWdgt::closeEvent(QCloseEvent* arg__1)
489 520 {
490 if (_wrapper) {
491 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
492 PyErr_Clear();
493 if (obj && !PythonQtSlotFunction_Check(obj)) {
521 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
522 static PyObject* name = PyString_FromString("closeEvent");
523 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
524 if (obj) {
494 525 static const char* argumentList[] ={"" , "QCloseEvent*"};
495 526 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
496 527 void* args[2] = {NULL, (void*)&arg__1};
@@ -498,16 +529,18 if (_wrapper) {
498 529 if (result) { Py_DECREF(result); }
499 530 Py_DECREF(obj);
500 531 return;
532 } else {
533 PyErr_Clear();
501 534 }
502 535 }
503 536 MemSizeWdgt::closeEvent(arg__1);
504 537 }
505 538 void PythonQtShell_MemSizeWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
506 539 {
507 if (_wrapper) {
508 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
509 PyErr_Clear();
510 if (obj && !PythonQtSlotFunction_Check(obj)) {
540 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
541 static PyObject* name = PyString_FromString("contextMenuEvent");
542 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
543 if (obj) {
511 544 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
512 545 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
513 546 void* args[2] = {NULL, (void*)&arg__1};
@@ -515,16 +548,18 if (_wrapper) {
515 548 if (result) { Py_DECREF(result); }
516 549 Py_DECREF(obj);
517 550 return;
551 } else {
552 PyErr_Clear();
518 553 }
519 554 }
520 555 MemSizeWdgt::contextMenuEvent(arg__1);
521 556 }
522 557 void PythonQtShell_MemSizeWdgt::customEvent(QEvent* arg__1)
523 558 {
524 if (_wrapper) {
525 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
526 PyErr_Clear();
527 if (obj && !PythonQtSlotFunction_Check(obj)) {
559 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
560 static PyObject* name = PyString_FromString("customEvent");
561 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
562 if (obj) {
528 563 static const char* argumentList[] ={"" , "QEvent*"};
529 564 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
530 565 void* args[2] = {NULL, (void*)&arg__1};
@@ -532,16 +567,18 if (_wrapper) {
532 567 if (result) { Py_DECREF(result); }
533 568 Py_DECREF(obj);
534 569 return;
570 } else {
571 PyErr_Clear();
535 572 }
536 573 }
537 574 MemSizeWdgt::customEvent(arg__1);
538 575 }
539 576 int PythonQtShell_MemSizeWdgt::devType() const
540 577 {
541 if (_wrapper) {
542 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
543 PyErr_Clear();
544 if (obj && !PythonQtSlotFunction_Check(obj)) {
578 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
579 static PyObject* name = PyString_FromString("devType");
580 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
581 if (obj) {
545 582 static const char* argumentList[] ={"int"};
546 583 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
547 584 int returnValue;
@@ -560,16 +597,18 if (_wrapper) {
560 597 if (result) { Py_DECREF(result); }
561 598 Py_DECREF(obj);
562 599 return returnValue;
600 } else {
601 PyErr_Clear();
563 602 }
564 603 }
565 604 return MemSizeWdgt::devType();
566 605 }
567 606 void PythonQtShell_MemSizeWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
568 607 {
569 if (_wrapper) {
570 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
571 PyErr_Clear();
572 if (obj && !PythonQtSlotFunction_Check(obj)) {
608 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
609 static PyObject* name = PyString_FromString("dragEnterEvent");
610 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
611 if (obj) {
573 612 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
574 613 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
575 614 void* args[2] = {NULL, (void*)&arg__1};
@@ -577,16 +616,18 if (_wrapper) {
577 616 if (result) { Py_DECREF(result); }
578 617 Py_DECREF(obj);
579 618 return;
619 } else {
620 PyErr_Clear();
580 621 }
581 622 }
582 623 MemSizeWdgt::dragEnterEvent(arg__1);
583 624 }
584 625 void PythonQtShell_MemSizeWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
585 626 {
586 if (_wrapper) {
587 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
588 PyErr_Clear();
589 if (obj && !PythonQtSlotFunction_Check(obj)) {
627 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
628 static PyObject* name = PyString_FromString("dragLeaveEvent");
629 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
630 if (obj) {
590 631 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
591 632 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
592 633 void* args[2] = {NULL, (void*)&arg__1};
@@ -594,16 +635,18 if (_wrapper) {
594 635 if (result) { Py_DECREF(result); }
595 636 Py_DECREF(obj);
596 637 return;
638 } else {
639 PyErr_Clear();
597 640 }
598 641 }
599 642 MemSizeWdgt::dragLeaveEvent(arg__1);
600 643 }
601 644 void PythonQtShell_MemSizeWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
602 645 {
603 if (_wrapper) {
604 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
605 PyErr_Clear();
606 if (obj && !PythonQtSlotFunction_Check(obj)) {
646 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
647 static PyObject* name = PyString_FromString("dragMoveEvent");
648 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
649 if (obj) {
607 650 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
608 651 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
609 652 void* args[2] = {NULL, (void*)&arg__1};
@@ -611,16 +654,18 if (_wrapper) {
611 654 if (result) { Py_DECREF(result); }
612 655 Py_DECREF(obj);
613 656 return;
657 } else {
658 PyErr_Clear();
614 659 }
615 660 }
616 661 MemSizeWdgt::dragMoveEvent(arg__1);
617 662 }
618 663 void PythonQtShell_MemSizeWdgt::dropEvent(QDropEvent* arg__1)
619 664 {
620 if (_wrapper) {
621 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
622 PyErr_Clear();
623 if (obj && !PythonQtSlotFunction_Check(obj)) {
665 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
666 static PyObject* name = PyString_FromString("dropEvent");
667 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
668 if (obj) {
624 669 static const char* argumentList[] ={"" , "QDropEvent*"};
625 670 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
626 671 void* args[2] = {NULL, (void*)&arg__1};
@@ -628,16 +673,18 if (_wrapper) {
628 673 if (result) { Py_DECREF(result); }
629 674 Py_DECREF(obj);
630 675 return;
676 } else {
677 PyErr_Clear();
631 678 }
632 679 }
633 680 MemSizeWdgt::dropEvent(arg__1);
634 681 }
635 682 void PythonQtShell_MemSizeWdgt::enterEvent(QEvent* arg__1)
636 683 {
637 if (_wrapper) {
638 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
639 PyErr_Clear();
640 if (obj && !PythonQtSlotFunction_Check(obj)) {
684 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
685 static PyObject* name = PyString_FromString("enterEvent");
686 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
687 if (obj) {
641 688 static const char* argumentList[] ={"" , "QEvent*"};
642 689 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
643 690 void* args[2] = {NULL, (void*)&arg__1};
@@ -645,16 +692,18 if (_wrapper) {
645 692 if (result) { Py_DECREF(result); }
646 693 Py_DECREF(obj);
647 694 return;
695 } else {
696 PyErr_Clear();
648 697 }
649 698 }
650 699 MemSizeWdgt::enterEvent(arg__1);
651 700 }
652 701 bool PythonQtShell_MemSizeWdgt::event(QEvent* arg__1)
653 702 {
654 if (_wrapper) {
655 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
656 PyErr_Clear();
657 if (obj && !PythonQtSlotFunction_Check(obj)) {
703 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
704 static PyObject* name = PyString_FromString("event");
705 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
706 if (obj) {
658 707 static const char* argumentList[] ={"bool" , "QEvent*"};
659 708 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
660 709 bool returnValue;
@@ -673,16 +722,18 if (_wrapper) {
673 722 if (result) { Py_DECREF(result); }
674 723 Py_DECREF(obj);
675 724 return returnValue;
725 } else {
726 PyErr_Clear();
676 727 }
677 728 }
678 729 return MemSizeWdgt::event(arg__1);
679 730 }
680 731 bool PythonQtShell_MemSizeWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
681 732 {
682 if (_wrapper) {
683 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
684 PyErr_Clear();
685 if (obj && !PythonQtSlotFunction_Check(obj)) {
733 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
734 static PyObject* name = PyString_FromString("eventFilter");
735 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
736 if (obj) {
686 737 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
687 738 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
688 739 bool returnValue;
@@ -701,16 +752,18 if (_wrapper) {
701 752 if (result) { Py_DECREF(result); }
702 753 Py_DECREF(obj);
703 754 return returnValue;
755 } else {
756 PyErr_Clear();
704 757 }
705 758 }
706 759 return MemSizeWdgt::eventFilter(arg__1, arg__2);
707 760 }
708 761 void PythonQtShell_MemSizeWdgt::focusInEvent(QFocusEvent* arg__1)
709 762 {
710 if (_wrapper) {
711 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
712 PyErr_Clear();
713 if (obj && !PythonQtSlotFunction_Check(obj)) {
763 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
764 static PyObject* name = PyString_FromString("focusInEvent");
765 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
766 if (obj) {
714 767 static const char* argumentList[] ={"" , "QFocusEvent*"};
715 768 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
716 769 void* args[2] = {NULL, (void*)&arg__1};
@@ -718,20 +771,22 if (_wrapper) {
718 771 if (result) { Py_DECREF(result); }
719 772 Py_DECREF(obj);
720 773 return;
774 } else {
775 PyErr_Clear();
721 776 }
722 777 }
723 778 MemSizeWdgt::focusInEvent(arg__1);
724 779 }
725 bool PythonQtShell_MemSizeWdgt::focusNextPrevChild(bool next)
726 {
727 if (_wrapper) {
728 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
729 PyErr_Clear();
730 if (obj && !PythonQtSlotFunction_Check(obj)) {
780 bool PythonQtShell_MemSizeWdgt::focusNextPrevChild(bool next0)
781 {
782 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
783 static PyObject* name = PyString_FromString("focusNextPrevChild");
784 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
785 if (obj) {
731 786 static const char* argumentList[] ={"bool" , "bool"};
732 787 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
733 788 bool returnValue;
734 void* args[2] = {NULL, (void*)&next};
789 void* args[2] = {NULL, (void*)&next0};
735 790 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
736 791 if (result) {
737 792 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -746,16 +801,18 if (_wrapper) {
746 801 if (result) { Py_DECREF(result); }
747 802 Py_DECREF(obj);
748 803 return returnValue;
749 }
750 }
751 return MemSizeWdgt::focusNextPrevChild(next);
804 } else {
805 PyErr_Clear();
806 }
807 }
808 return MemSizeWdgt::focusNextPrevChild(next0);
752 809 }
753 810 void PythonQtShell_MemSizeWdgt::focusOutEvent(QFocusEvent* arg__1)
754 811 {
755 if (_wrapper) {
756 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
757 PyErr_Clear();
758 if (obj && !PythonQtSlotFunction_Check(obj)) {
812 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
813 static PyObject* name = PyString_FromString("focusOutEvent");
814 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
815 if (obj) {
759 816 static const char* argumentList[] ={"" , "QFocusEvent*"};
760 817 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
761 818 void* args[2] = {NULL, (void*)&arg__1};
@@ -763,16 +820,18 if (_wrapper) {
763 820 if (result) { Py_DECREF(result); }
764 821 Py_DECREF(obj);
765 822 return;
823 } else {
824 PyErr_Clear();
766 825 }
767 826 }
768 827 MemSizeWdgt::focusOutEvent(arg__1);
769 828 }
770 829 bool PythonQtShell_MemSizeWdgt::hasHeightForWidth() const
771 830 {
772 if (_wrapper) {
773 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
774 PyErr_Clear();
775 if (obj && !PythonQtSlotFunction_Check(obj)) {
831 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
832 static PyObject* name = PyString_FromString("hasHeightForWidth");
833 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
834 if (obj) {
776 835 static const char* argumentList[] ={"bool"};
777 836 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
778 837 bool returnValue;
@@ -791,16 +850,18 if (_wrapper) {
791 850 if (result) { Py_DECREF(result); }
792 851 Py_DECREF(obj);
793 852 return returnValue;
853 } else {
854 PyErr_Clear();
794 855 }
795 856 }
796 857 return MemSizeWdgt::hasHeightForWidth();
797 858 }
798 859 int PythonQtShell_MemSizeWdgt::heightForWidth(int arg__1) const
799 860 {
800 if (_wrapper) {
801 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
802 PyErr_Clear();
803 if (obj && !PythonQtSlotFunction_Check(obj)) {
861 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
862 static PyObject* name = PyString_FromString("heightForWidth");
863 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
864 if (obj) {
804 865 static const char* argumentList[] ={"int" , "int"};
805 866 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
806 867 int returnValue;
@@ -819,16 +880,18 if (_wrapper) {
819 880 if (result) { Py_DECREF(result); }
820 881 Py_DECREF(obj);
821 882 return returnValue;
883 } else {
884 PyErr_Clear();
822 885 }
823 886 }
824 887 return MemSizeWdgt::heightForWidth(arg__1);
825 888 }
826 889 void PythonQtShell_MemSizeWdgt::hideEvent(QHideEvent* arg__1)
827 890 {
828 if (_wrapper) {
829 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
830 PyErr_Clear();
831 if (obj && !PythonQtSlotFunction_Check(obj)) {
891 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
892 static PyObject* name = PyString_FromString("hideEvent");
893 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
894 if (obj) {
832 895 static const char* argumentList[] ={"" , "QHideEvent*"};
833 896 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
834 897 void* args[2] = {NULL, (void*)&arg__1};
@@ -836,33 +899,37 if (_wrapper) {
836 899 if (result) { Py_DECREF(result); }
837 900 Py_DECREF(obj);
838 901 return;
902 } else {
903 PyErr_Clear();
839 904 }
840 905 }
841 906 MemSizeWdgt::hideEvent(arg__1);
842 907 }
843 void PythonQtShell_MemSizeWdgt::initPainter(QPainter* painter) const
844 {
845 if (_wrapper) {
846 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
847 PyErr_Clear();
848 if (obj && !PythonQtSlotFunction_Check(obj)) {
908 void PythonQtShell_MemSizeWdgt::initPainter(QPainter* painter0) const
909 {
910 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
911 static PyObject* name = PyString_FromString("initPainter");
912 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
913 if (obj) {
849 914 static const char* argumentList[] ={"" , "QPainter*"};
850 915 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
851 void* args[2] = {NULL, (void*)&painter};
852 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
853 if (result) { Py_DECREF(result); }
854 Py_DECREF(obj);
855 return;
856 }
857 }
858 MemSizeWdgt::initPainter(painter);
916 void* args[2] = {NULL, (void*)&painter0};
917 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
918 if (result) { Py_DECREF(result); }
919 Py_DECREF(obj);
920 return;
921 } else {
922 PyErr_Clear();
923 }
924 }
925 MemSizeWdgt::initPainter(painter0);
859 926 }
860 927 void PythonQtShell_MemSizeWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
861 928 {
862 if (_wrapper) {
863 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
864 PyErr_Clear();
865 if (obj && !PythonQtSlotFunction_Check(obj)) {
929 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
930 static PyObject* name = PyString_FromString("inputMethodEvent");
931 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
932 if (obj) {
866 933 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
867 934 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
868 935 void* args[2] = {NULL, (void*)&arg__1};
@@ -870,16 +937,18 if (_wrapper) {
870 937 if (result) { Py_DECREF(result); }
871 938 Py_DECREF(obj);
872 939 return;
940 } else {
941 PyErr_Clear();
873 942 }
874 943 }
875 944 MemSizeWdgt::inputMethodEvent(arg__1);
876 945 }
877 946 QVariant PythonQtShell_MemSizeWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
878 947 {
879 if (_wrapper) {
880 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
881 PyErr_Clear();
882 if (obj && !PythonQtSlotFunction_Check(obj)) {
948 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
949 static PyObject* name = PyString_FromString("inputMethodQuery");
950 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
951 if (obj) {
883 952 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
884 953 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
885 954 QVariant returnValue;
@@ -898,16 +967,18 if (_wrapper) {
898 967 if (result) { Py_DECREF(result); }
899 968 Py_DECREF(obj);
900 969 return returnValue;
970 } else {
971 PyErr_Clear();
901 972 }
902 973 }
903 974 return MemSizeWdgt::inputMethodQuery(arg__1);
904 975 }
905 976 void PythonQtShell_MemSizeWdgt::keyPressEvent(QKeyEvent* arg__1)
906 977 {
907 if (_wrapper) {
908 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
909 PyErr_Clear();
910 if (obj && !PythonQtSlotFunction_Check(obj)) {
978 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
979 static PyObject* name = PyString_FromString("keyPressEvent");
980 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
981 if (obj) {
911 982 static const char* argumentList[] ={"" , "QKeyEvent*"};
912 983 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
913 984 void* args[2] = {NULL, (void*)&arg__1};
@@ -915,16 +986,18 if (_wrapper) {
915 986 if (result) { Py_DECREF(result); }
916 987 Py_DECREF(obj);
917 988 return;
989 } else {
990 PyErr_Clear();
918 991 }
919 992 }
920 993 MemSizeWdgt::keyPressEvent(arg__1);
921 994 }
922 995 void PythonQtShell_MemSizeWdgt::keyReleaseEvent(QKeyEvent* arg__1)
923 996 {
924 if (_wrapper) {
925 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
926 PyErr_Clear();
927 if (obj && !PythonQtSlotFunction_Check(obj)) {
997 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
998 static PyObject* name = PyString_FromString("keyReleaseEvent");
999 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1000 if (obj) {
928 1001 static const char* argumentList[] ={"" , "QKeyEvent*"};
929 1002 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
930 1003 void* args[2] = {NULL, (void*)&arg__1};
@@ -932,16 +1005,18 if (_wrapper) {
932 1005 if (result) { Py_DECREF(result); }
933 1006 Py_DECREF(obj);
934 1007 return;
1008 } else {
1009 PyErr_Clear();
935 1010 }
936 1011 }
937 1012 MemSizeWdgt::keyReleaseEvent(arg__1);
938 1013 }
939 1014 void PythonQtShell_MemSizeWdgt::leaveEvent(QEvent* arg__1)
940 1015 {
941 if (_wrapper) {
942 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
943 PyErr_Clear();
944 if (obj && !PythonQtSlotFunction_Check(obj)) {
1016 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1017 static PyObject* name = PyString_FromString("leaveEvent");
1018 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1019 if (obj) {
945 1020 static const char* argumentList[] ={"" , "QEvent*"};
946 1021 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
947 1022 void* args[2] = {NULL, (void*)&arg__1};
@@ -949,16 +1024,18 if (_wrapper) {
949 1024 if (result) { Py_DECREF(result); }
950 1025 Py_DECREF(obj);
951 1026 return;
1027 } else {
1028 PyErr_Clear();
952 1029 }
953 1030 }
954 1031 MemSizeWdgt::leaveEvent(arg__1);
955 1032 }
956 1033 int PythonQtShell_MemSizeWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
957 1034 {
958 if (_wrapper) {
959 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
960 PyErr_Clear();
961 if (obj && !PythonQtSlotFunction_Check(obj)) {
1035 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1036 static PyObject* name = PyString_FromString("metric");
1037 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1038 if (obj) {
962 1039 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
963 1040 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
964 1041 int returnValue;
@@ -977,16 +1054,18 if (_wrapper) {
977 1054 if (result) { Py_DECREF(result); }
978 1055 Py_DECREF(obj);
979 1056 return returnValue;
1057 } else {
1058 PyErr_Clear();
980 1059 }
981 1060 }
982 1061 return MemSizeWdgt::metric(arg__1);
983 1062 }
984 1063 QSize PythonQtShell_MemSizeWdgt::minimumSizeHint() const
985 1064 {
986 if (_wrapper) {
987 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
988 PyErr_Clear();
989 if (obj && !PythonQtSlotFunction_Check(obj)) {
1065 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1066 static PyObject* name = PyString_FromString("getMinimumSizeHint");
1067 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1068 if (obj) {
990 1069 static const char* argumentList[] ={"QSize"};
991 1070 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
992 1071 QSize returnValue;
@@ -1005,16 +1084,18 if (_wrapper) {
1005 1084 if (result) { Py_DECREF(result); }
1006 1085 Py_DECREF(obj);
1007 1086 return returnValue;
1087 } else {
1088 PyErr_Clear();
1008 1089 }
1009 1090 }
1010 1091 return MemSizeWdgt::minimumSizeHint();
1011 1092 }
1012 1093 void PythonQtShell_MemSizeWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
1013 1094 {
1014 if (_wrapper) {
1015 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
1016 PyErr_Clear();
1017 if (obj && !PythonQtSlotFunction_Check(obj)) {
1095 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1096 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
1097 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1098 if (obj) {
1018 1099 static const char* argumentList[] ={"" , "QMouseEvent*"};
1019 1100 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1020 1101 void* args[2] = {NULL, (void*)&arg__1};
@@ -1022,16 +1103,18 if (_wrapper) {
1022 1103 if (result) { Py_DECREF(result); }
1023 1104 Py_DECREF(obj);
1024 1105 return;
1106 } else {
1107 PyErr_Clear();
1025 1108 }
1026 1109 }
1027 1110 MemSizeWdgt::mouseDoubleClickEvent(arg__1);
1028 1111 }
1029 1112 void PythonQtShell_MemSizeWdgt::mouseMoveEvent(QMouseEvent* arg__1)
1030 1113 {
1031 if (_wrapper) {
1032 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
1033 PyErr_Clear();
1034 if (obj && !PythonQtSlotFunction_Check(obj)) {
1114 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1115 static PyObject* name = PyString_FromString("mouseMoveEvent");
1116 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1117 if (obj) {
1035 1118 static const char* argumentList[] ={"" , "QMouseEvent*"};
1036 1119 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1037 1120 void* args[2] = {NULL, (void*)&arg__1};
@@ -1039,16 +1122,18 if (_wrapper) {
1039 1122 if (result) { Py_DECREF(result); }
1040 1123 Py_DECREF(obj);
1041 1124 return;
1125 } else {
1126 PyErr_Clear();
1042 1127 }
1043 1128 }
1044 1129 MemSizeWdgt::mouseMoveEvent(arg__1);
1045 1130 }
1046 1131 void PythonQtShell_MemSizeWdgt::mousePressEvent(QMouseEvent* arg__1)
1047 1132 {
1048 if (_wrapper) {
1049 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
1050 PyErr_Clear();
1051 if (obj && !PythonQtSlotFunction_Check(obj)) {
1133 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1134 static PyObject* name = PyString_FromString("mousePressEvent");
1135 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1136 if (obj) {
1052 1137 static const char* argumentList[] ={"" , "QMouseEvent*"};
1053 1138 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1054 1139 void* args[2] = {NULL, (void*)&arg__1};
@@ -1056,16 +1141,18 if (_wrapper) {
1056 1141 if (result) { Py_DECREF(result); }
1057 1142 Py_DECREF(obj);
1058 1143 return;
1144 } else {
1145 PyErr_Clear();
1059 1146 }
1060 1147 }
1061 1148 MemSizeWdgt::mousePressEvent(arg__1);
1062 1149 }
1063 1150 void PythonQtShell_MemSizeWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
1064 1151 {
1065 if (_wrapper) {
1066 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
1067 PyErr_Clear();
1068 if (obj && !PythonQtSlotFunction_Check(obj)) {
1152 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1153 static PyObject* name = PyString_FromString("mouseReleaseEvent");
1154 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1155 if (obj) {
1069 1156 static const char* argumentList[] ={"" , "QMouseEvent*"};
1070 1157 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1071 1158 void* args[2] = {NULL, (void*)&arg__1};
@@ -1073,16 +1160,18 if (_wrapper) {
1073 1160 if (result) { Py_DECREF(result); }
1074 1161 Py_DECREF(obj);
1075 1162 return;
1163 } else {
1164 PyErr_Clear();
1076 1165 }
1077 1166 }
1078 1167 MemSizeWdgt::mouseReleaseEvent(arg__1);
1079 1168 }
1080 1169 void PythonQtShell_MemSizeWdgt::moveEvent(QMoveEvent* arg__1)
1081 1170 {
1082 if (_wrapper) {
1083 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
1084 PyErr_Clear();
1085 if (obj && !PythonQtSlotFunction_Check(obj)) {
1171 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1172 static PyObject* name = PyString_FromString("moveEvent");
1173 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1174 if (obj) {
1086 1175 static const char* argumentList[] ={"" , "QMoveEvent*"};
1087 1176 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1088 1177 void* args[2] = {NULL, (void*)&arg__1};
@@ -1090,20 +1179,22 if (_wrapper) {
1090 1179 if (result) { Py_DECREF(result); }
1091 1180 Py_DECREF(obj);
1092 1181 return;
1182 } else {
1183 PyErr_Clear();
1093 1184 }
1094 1185 }
1095 1186 MemSizeWdgt::moveEvent(arg__1);
1096 1187 }
1097 bool PythonQtShell_MemSizeWdgt::nativeEvent(const QByteArray& eventType, void* message, long* result)
1098 {
1099 if (_wrapper) {
1100 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
1101 PyErr_Clear();
1102 if (obj && !PythonQtSlotFunction_Check(obj)) {
1188 bool PythonQtShell_MemSizeWdgt::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
1189 {
1190 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1191 static PyObject* name = PyString_FromString("nativeEvent");
1192 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1193 if (obj) {
1103 1194 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
1104 1195 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
1105 1196 bool returnValue;
1106 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
1197 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
1107 1198 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1108 1199 if (result) {
1109 1200 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -1118,16 +1209,18 if (_wrapper) {
1118 1209 if (result) { Py_DECREF(result); }
1119 1210 Py_DECREF(obj);
1120 1211 return returnValue;
1121 }
1122 }
1123 return MemSizeWdgt::nativeEvent(eventType, message, result);
1212 } else {
1213 PyErr_Clear();
1214 }
1215 }
1216 return MemSizeWdgt::nativeEvent(eventType0, message1, result2);
1124 1217 }
1125 1218 QPaintEngine* PythonQtShell_MemSizeWdgt::paintEngine() const
1126 1219 {
1127 if (_wrapper) {
1128 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
1129 PyErr_Clear();
1130 if (obj && !PythonQtSlotFunction_Check(obj)) {
1220 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1221 static PyObject* name = PyString_FromString("paintEngine");
1222 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1223 if (obj) {
1131 1224 static const char* argumentList[] ={"QPaintEngine*"};
1132 1225 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1133 1226 QPaintEngine* returnValue;
@@ -1146,16 +1239,18 if (_wrapper) {
1146 1239 if (result) { Py_DECREF(result); }
1147 1240 Py_DECREF(obj);
1148 1241 return returnValue;
1242 } else {
1243 PyErr_Clear();
1149 1244 }
1150 1245 }
1151 1246 return MemSizeWdgt::paintEngine();
1152 1247 }
1153 1248 void PythonQtShell_MemSizeWdgt::paintEvent(QPaintEvent* arg__1)
1154 1249 {
1155 if (_wrapper) {
1156 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
1157 PyErr_Clear();
1158 if (obj && !PythonQtSlotFunction_Check(obj)) {
1250 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1251 static PyObject* name = PyString_FromString("paintEvent");
1252 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1253 if (obj) {
1159 1254 static const char* argumentList[] ={"" , "QPaintEvent*"};
1160 1255 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1161 1256 void* args[2] = {NULL, (void*)&arg__1};
@@ -1163,20 +1258,22 if (_wrapper) {
1163 1258 if (result) { Py_DECREF(result); }
1164 1259 Py_DECREF(obj);
1165 1260 return;
1261 } else {
1262 PyErr_Clear();
1166 1263 }
1167 1264 }
1168 1265 MemSizeWdgt::paintEvent(arg__1);
1169 1266 }
1170 QPaintDevice* PythonQtShell_MemSizeWdgt::redirected(QPoint* offset) const
1171 {
1172 if (_wrapper) {
1173 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
1174 PyErr_Clear();
1175 if (obj && !PythonQtSlotFunction_Check(obj)) {
1267 QPaintDevice* PythonQtShell_MemSizeWdgt::redirected(QPoint* offset0) const
1268 {
1269 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1270 static PyObject* name = PyString_FromString("redirected");
1271 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1272 if (obj) {
1176 1273 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
1177 1274 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1178 1275 QPaintDevice* returnValue;
1179 void* args[2] = {NULL, (void*)&offset};
1276 void* args[2] = {NULL, (void*)&offset0};
1180 1277 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1181 1278 if (result) {
1182 1279 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -1191,16 +1288,18 if (_wrapper) {
1191 1288 if (result) { Py_DECREF(result); }
1192 1289 Py_DECREF(obj);
1193 1290 return returnValue;
1194 }
1195 }
1196 return MemSizeWdgt::redirected(offset);
1291 } else {
1292 PyErr_Clear();
1293 }
1294 }
1295 return MemSizeWdgt::redirected(offset0);
1197 1296 }
1198 1297 void PythonQtShell_MemSizeWdgt::resizeEvent(QResizeEvent* arg__1)
1199 1298 {
1200 if (_wrapper) {
1201 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
1202 PyErr_Clear();
1203 if (obj && !PythonQtSlotFunction_Check(obj)) {
1299 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1300 static PyObject* name = PyString_FromString("resizeEvent");
1301 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1302 if (obj) {
1204 1303 static const char* argumentList[] ={"" , "QResizeEvent*"};
1205 1304 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1206 1305 void* args[2] = {NULL, (void*)&arg__1};
@@ -1208,16 +1307,18 if (_wrapper) {
1208 1307 if (result) { Py_DECREF(result); }
1209 1308 Py_DECREF(obj);
1210 1309 return;
1310 } else {
1311 PyErr_Clear();
1211 1312 }
1212 1313 }
1213 1314 MemSizeWdgt::resizeEvent(arg__1);
1214 1315 }
1215 1316 QPainter* PythonQtShell_MemSizeWdgt::sharedPainter() const
1216 1317 {
1217 if (_wrapper) {
1218 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
1219 PyErr_Clear();
1220 if (obj && !PythonQtSlotFunction_Check(obj)) {
1318 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1319 static PyObject* name = PyString_FromString("sharedPainter");
1320 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1321 if (obj) {
1221 1322 static const char* argumentList[] ={"QPainter*"};
1222 1323 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1223 1324 QPainter* returnValue;
@@ -1236,16 +1337,18 if (_wrapper) {
1236 1337 if (result) { Py_DECREF(result); }
1237 1338 Py_DECREF(obj);
1238 1339 return returnValue;
1340 } else {
1341 PyErr_Clear();
1239 1342 }
1240 1343 }
1241 1344 return MemSizeWdgt::sharedPainter();
1242 1345 }
1243 1346 void PythonQtShell_MemSizeWdgt::showEvent(QShowEvent* arg__1)
1244 1347 {
1245 if (_wrapper) {
1246 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
1247 PyErr_Clear();
1248 if (obj && !PythonQtSlotFunction_Check(obj)) {
1348 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1349 static PyObject* name = PyString_FromString("showEvent");
1350 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1351 if (obj) {
1249 1352 static const char* argumentList[] ={"" , "QShowEvent*"};
1250 1353 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1251 1354 void* args[2] = {NULL, (void*)&arg__1};
@@ -1253,16 +1356,18 if (_wrapper) {
1253 1356 if (result) { Py_DECREF(result); }
1254 1357 Py_DECREF(obj);
1255 1358 return;
1359 } else {
1360 PyErr_Clear();
1256 1361 }
1257 1362 }
1258 1363 MemSizeWdgt::showEvent(arg__1);
1259 1364 }
1260 1365 QSize PythonQtShell_MemSizeWdgt::sizeHint() const
1261 1366 {
1262 if (_wrapper) {
1263 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
1264 PyErr_Clear();
1265 if (obj && !PythonQtSlotFunction_Check(obj)) {
1367 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1368 static PyObject* name = PyString_FromString("getSizeHint");
1369 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1370 if (obj) {
1266 1371 static const char* argumentList[] ={"QSize"};
1267 1372 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1268 1373 QSize returnValue;
@@ -1281,16 +1386,18 if (_wrapper) {
1281 1386 if (result) { Py_DECREF(result); }
1282 1387 Py_DECREF(obj);
1283 1388 return returnValue;
1389 } else {
1390 PyErr_Clear();
1284 1391 }
1285 1392 }
1286 1393 return MemSizeWdgt::sizeHint();
1287 1394 }
1288 1395 void PythonQtShell_MemSizeWdgt::tabletEvent(QTabletEvent* arg__1)
1289 1396 {
1290 if (_wrapper) {
1291 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
1292 PyErr_Clear();
1293 if (obj && !PythonQtSlotFunction_Check(obj)) {
1397 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1398 static PyObject* name = PyString_FromString("tabletEvent");
1399 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1400 if (obj) {
1294 1401 static const char* argumentList[] ={"" , "QTabletEvent*"};
1295 1402 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1296 1403 void* args[2] = {NULL, (void*)&arg__1};
@@ -1298,16 +1405,18 if (_wrapper) {
1298 1405 if (result) { Py_DECREF(result); }
1299 1406 Py_DECREF(obj);
1300 1407 return;
1408 } else {
1409 PyErr_Clear();
1301 1410 }
1302 1411 }
1303 1412 MemSizeWdgt::tabletEvent(arg__1);
1304 1413 }
1305 1414 void PythonQtShell_MemSizeWdgt::timerEvent(QTimerEvent* arg__1)
1306 1415 {
1307 if (_wrapper) {
1308 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
1309 PyErr_Clear();
1310 if (obj && !PythonQtSlotFunction_Check(obj)) {
1416 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1417 static PyObject* name = PyString_FromString("timerEvent");
1418 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1419 if (obj) {
1311 1420 static const char* argumentList[] ={"" , "QTimerEvent*"};
1312 1421 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1313 1422 void* args[2] = {NULL, (void*)&arg__1};
@@ -1315,16 +1424,18 if (_wrapper) {
1315 1424 if (result) { Py_DECREF(result); }
1316 1425 Py_DECREF(obj);
1317 1426 return;
1427 } else {
1428 PyErr_Clear();
1318 1429 }
1319 1430 }
1320 1431 MemSizeWdgt::timerEvent(arg__1);
1321 1432 }
1322 1433 void PythonQtShell_MemSizeWdgt::wheelEvent(QWheelEvent* arg__1)
1323 1434 {
1324 if (_wrapper) {
1325 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
1326 PyErr_Clear();
1327 if (obj && !PythonQtSlotFunction_Check(obj)) {
1435 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1436 static PyObject* name = PyString_FromString("wheelEvent");
1437 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1438 if (obj) {
1328 1439 static const char* argumentList[] ={"" , "QWheelEvent*"};
1329 1440 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1330 1441 void* args[2] = {NULL, (void*)&arg__1};
@@ -1332,6 +1443,8 if (_wrapper) {
1332 1443 if (result) { Py_DECREF(result); }
1333 1444 Py_DECREF(obj);
1334 1445 return;
1446 } else {
1447 PyErr_Clear();
1335 1448 }
1336 1449 }
1337 1450 MemSizeWdgt::wheelEvent(arg__1);
@@ -1372,10 +1485,10 PythonQtShell_QHexEdit::~PythonQtShell_Q
1372 1485 }
1373 1486 void PythonQtShell_QHexEdit::actionEvent(QActionEvent* arg__1)
1374 1487 {
1375 if (_wrapper) {
1376 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
1377 PyErr_Clear();
1378 if (obj && !PythonQtSlotFunction_Check(obj)) {
1488 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1489 static PyObject* name = PyString_FromString("actionEvent");
1490 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1491 if (obj) {
1379 1492 static const char* argumentList[] ={"" , "QActionEvent*"};
1380 1493 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1381 1494 void* args[2] = {NULL, (void*)&arg__1};
@@ -1383,16 +1496,18 if (_wrapper) {
1383 1496 if (result) { Py_DECREF(result); }
1384 1497 Py_DECREF(obj);
1385 1498 return;
1499 } else {
1500 PyErr_Clear();
1386 1501 }
1387 1502 }
1388 1503 QHexEdit::actionEvent(arg__1);
1389 1504 }
1390 1505 void PythonQtShell_QHexEdit::changeEvent(QEvent* arg__1)
1391 1506 {
1392 if (_wrapper) {
1393 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
1394 PyErr_Clear();
1395 if (obj && !PythonQtSlotFunction_Check(obj)) {
1507 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1508 static PyObject* name = PyString_FromString("changeEvent");
1509 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1510 if (obj) {
1396 1511 static const char* argumentList[] ={"" , "QEvent*"};
1397 1512 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1398 1513 void* args[2] = {NULL, (void*)&arg__1};
@@ -1400,16 +1515,18 if (_wrapper) {
1400 1515 if (result) { Py_DECREF(result); }
1401 1516 Py_DECREF(obj);
1402 1517 return;
1518 } else {
1519 PyErr_Clear();
1403 1520 }
1404 1521 }
1405 1522 QHexEdit::changeEvent(arg__1);
1406 1523 }
1407 1524 void PythonQtShell_QHexEdit::childEvent(QChildEvent* arg__1)
1408 1525 {
1409 if (_wrapper) {
1410 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
1411 PyErr_Clear();
1412 if (obj && !PythonQtSlotFunction_Check(obj)) {
1526 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1527 static PyObject* name = PyString_FromString("childEvent");
1528 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1529 if (obj) {
1413 1530 static const char* argumentList[] ={"" , "QChildEvent*"};
1414 1531 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1415 1532 void* args[2] = {NULL, (void*)&arg__1};
@@ -1417,16 +1534,18 if (_wrapper) {
1417 1534 if (result) { Py_DECREF(result); }
1418 1535 Py_DECREF(obj);
1419 1536 return;
1537 } else {
1538 PyErr_Clear();
1420 1539 }
1421 1540 }
1422 1541 QHexEdit::childEvent(arg__1);
1423 1542 }
1424 1543 void PythonQtShell_QHexEdit::closeEvent(QCloseEvent* arg__1)
1425 1544 {
1426 if (_wrapper) {
1427 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
1428 PyErr_Clear();
1429 if (obj && !PythonQtSlotFunction_Check(obj)) {
1545 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1546 static PyObject* name = PyString_FromString("closeEvent");
1547 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1548 if (obj) {
1430 1549 static const char* argumentList[] ={"" , "QCloseEvent*"};
1431 1550 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1432 1551 void* args[2] = {NULL, (void*)&arg__1};
@@ -1434,16 +1553,18 if (_wrapper) {
1434 1553 if (result) { Py_DECREF(result); }
1435 1554 Py_DECREF(obj);
1436 1555 return;
1556 } else {
1557 PyErr_Clear();
1437 1558 }
1438 1559 }
1439 1560 QHexEdit::closeEvent(arg__1);
1440 1561 }
1441 1562 void PythonQtShell_QHexEdit::contextMenuEvent(QContextMenuEvent* arg__1)
1442 1563 {
1443 if (_wrapper) {
1444 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
1445 PyErr_Clear();
1446 if (obj && !PythonQtSlotFunction_Check(obj)) {
1564 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1565 static PyObject* name = PyString_FromString("contextMenuEvent");
1566 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1567 if (obj) {
1447 1568 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
1448 1569 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1449 1570 void* args[2] = {NULL, (void*)&arg__1};
@@ -1451,16 +1572,18 if (_wrapper) {
1451 1572 if (result) { Py_DECREF(result); }
1452 1573 Py_DECREF(obj);
1453 1574 return;
1575 } else {
1576 PyErr_Clear();
1454 1577 }
1455 1578 }
1456 1579 QHexEdit::contextMenuEvent(arg__1);
1457 1580 }
1458 1581 void PythonQtShell_QHexEdit::customEvent(QEvent* arg__1)
1459 1582 {
1460 if (_wrapper) {
1461 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
1462 PyErr_Clear();
1463 if (obj && !PythonQtSlotFunction_Check(obj)) {
1583 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1584 static PyObject* name = PyString_FromString("customEvent");
1585 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1586 if (obj) {
1464 1587 static const char* argumentList[] ={"" , "QEvent*"};
1465 1588 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1466 1589 void* args[2] = {NULL, (void*)&arg__1};
@@ -1468,16 +1591,18 if (_wrapper) {
1468 1591 if (result) { Py_DECREF(result); }
1469 1592 Py_DECREF(obj);
1470 1593 return;
1594 } else {
1595 PyErr_Clear();
1471 1596 }
1472 1597 }
1473 1598 QHexEdit::customEvent(arg__1);
1474 1599 }
1475 1600 int PythonQtShell_QHexEdit::devType() const
1476 1601 {
1477 if (_wrapper) {
1478 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
1479 PyErr_Clear();
1480 if (obj && !PythonQtSlotFunction_Check(obj)) {
1602 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1603 static PyObject* name = PyString_FromString("devType");
1604 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1605 if (obj) {
1481 1606 static const char* argumentList[] ={"int"};
1482 1607 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1483 1608 int returnValue;
@@ -1496,16 +1621,18 if (_wrapper) {
1496 1621 if (result) { Py_DECREF(result); }
1497 1622 Py_DECREF(obj);
1498 1623 return returnValue;
1624 } else {
1625 PyErr_Clear();
1499 1626 }
1500 1627 }
1501 1628 return QHexEdit::devType();
1502 1629 }
1503 1630 void PythonQtShell_QHexEdit::dragEnterEvent(QDragEnterEvent* arg__1)
1504 1631 {
1505 if (_wrapper) {
1506 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
1507 PyErr_Clear();
1508 if (obj && !PythonQtSlotFunction_Check(obj)) {
1632 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1633 static PyObject* name = PyString_FromString("dragEnterEvent");
1634 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1635 if (obj) {
1509 1636 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
1510 1637 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1511 1638 void* args[2] = {NULL, (void*)&arg__1};
@@ -1513,16 +1640,18 if (_wrapper) {
1513 1640 if (result) { Py_DECREF(result); }
1514 1641 Py_DECREF(obj);
1515 1642 return;
1643 } else {
1644 PyErr_Clear();
1516 1645 }
1517 1646 }
1518 1647 QHexEdit::dragEnterEvent(arg__1);
1519 1648 }
1520 1649 void PythonQtShell_QHexEdit::dragLeaveEvent(QDragLeaveEvent* arg__1)
1521 1650 {
1522 if (_wrapper) {
1523 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
1524 PyErr_Clear();
1525 if (obj && !PythonQtSlotFunction_Check(obj)) {
1651 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1652 static PyObject* name = PyString_FromString("dragLeaveEvent");
1653 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1654 if (obj) {
1526 1655 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
1527 1656 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1528 1657 void* args[2] = {NULL, (void*)&arg__1};
@@ -1530,16 +1659,18 if (_wrapper) {
1530 1659 if (result) { Py_DECREF(result); }
1531 1660 Py_DECREF(obj);
1532 1661 return;
1662 } else {
1663 PyErr_Clear();
1533 1664 }
1534 1665 }
1535 1666 QHexEdit::dragLeaveEvent(arg__1);
1536 1667 }
1537 1668 void PythonQtShell_QHexEdit::dragMoveEvent(QDragMoveEvent* arg__1)
1538 1669 {
1539 if (_wrapper) {
1540 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
1541 PyErr_Clear();
1542 if (obj && !PythonQtSlotFunction_Check(obj)) {
1670 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1671 static PyObject* name = PyString_FromString("dragMoveEvent");
1672 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1673 if (obj) {
1543 1674 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
1544 1675 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1545 1676 void* args[2] = {NULL, (void*)&arg__1};
@@ -1547,16 +1678,18 if (_wrapper) {
1547 1678 if (result) { Py_DECREF(result); }
1548 1679 Py_DECREF(obj);
1549 1680 return;
1681 } else {
1682 PyErr_Clear();
1550 1683 }
1551 1684 }
1552 1685 QHexEdit::dragMoveEvent(arg__1);
1553 1686 }
1554 1687 void PythonQtShell_QHexEdit::dropEvent(QDropEvent* arg__1)
1555 1688 {
1556 if (_wrapper) {
1557 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
1558 PyErr_Clear();
1559 if (obj && !PythonQtSlotFunction_Check(obj)) {
1689 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1690 static PyObject* name = PyString_FromString("dropEvent");
1691 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1692 if (obj) {
1560 1693 static const char* argumentList[] ={"" , "QDropEvent*"};
1561 1694 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1562 1695 void* args[2] = {NULL, (void*)&arg__1};
@@ -1564,16 +1697,18 if (_wrapper) {
1564 1697 if (result) { Py_DECREF(result); }
1565 1698 Py_DECREF(obj);
1566 1699 return;
1700 } else {
1701 PyErr_Clear();
1567 1702 }
1568 1703 }
1569 1704 QHexEdit::dropEvent(arg__1);
1570 1705 }
1571 1706 void PythonQtShell_QHexEdit::enterEvent(QEvent* arg__1)
1572 1707 {
1573 if (_wrapper) {
1574 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
1575 PyErr_Clear();
1576 if (obj && !PythonQtSlotFunction_Check(obj)) {
1708 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1709 static PyObject* name = PyString_FromString("enterEvent");
1710 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1711 if (obj) {
1577 1712 static const char* argumentList[] ={"" , "QEvent*"};
1578 1713 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1579 1714 void* args[2] = {NULL, (void*)&arg__1};
@@ -1581,16 +1716,18 if (_wrapper) {
1581 1716 if (result) { Py_DECREF(result); }
1582 1717 Py_DECREF(obj);
1583 1718 return;
1719 } else {
1720 PyErr_Clear();
1584 1721 }
1585 1722 }
1586 1723 QHexEdit::enterEvent(arg__1);
1587 1724 }
1588 1725 bool PythonQtShell_QHexEdit::event(QEvent* arg__1)
1589 1726 {
1590 if (_wrapper) {
1591 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
1592 PyErr_Clear();
1593 if (obj && !PythonQtSlotFunction_Check(obj)) {
1727 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1728 static PyObject* name = PyString_FromString("event");
1729 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1730 if (obj) {
1594 1731 static const char* argumentList[] ={"bool" , "QEvent*"};
1595 1732 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1596 1733 bool returnValue;
@@ -1609,16 +1746,18 if (_wrapper) {
1609 1746 if (result) { Py_DECREF(result); }
1610 1747 Py_DECREF(obj);
1611 1748 return returnValue;
1749 } else {
1750 PyErr_Clear();
1612 1751 }
1613 1752 }
1614 1753 return QHexEdit::event(arg__1);
1615 1754 }
1616 1755 bool PythonQtShell_QHexEdit::eventFilter(QObject* arg__1, QEvent* arg__2)
1617 1756 {
1618 if (_wrapper) {
1619 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
1620 PyErr_Clear();
1621 if (obj && !PythonQtSlotFunction_Check(obj)) {
1757 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1758 static PyObject* name = PyString_FromString("eventFilter");
1759 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1760 if (obj) {
1622 1761 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
1623 1762 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
1624 1763 bool returnValue;
@@ -1637,16 +1776,18 if (_wrapper) {
1637 1776 if (result) { Py_DECREF(result); }
1638 1777 Py_DECREF(obj);
1639 1778 return returnValue;
1779 } else {
1780 PyErr_Clear();
1640 1781 }
1641 1782 }
1642 1783 return QHexEdit::eventFilter(arg__1, arg__2);
1643 1784 }
1644 1785 void PythonQtShell_QHexEdit::focusInEvent(QFocusEvent* arg__1)
1645 1786 {
1646 if (_wrapper) {
1647 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
1648 PyErr_Clear();
1649 if (obj && !PythonQtSlotFunction_Check(obj)) {
1787 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1788 static PyObject* name = PyString_FromString("focusInEvent");
1789 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1790 if (obj) {
1650 1791 static const char* argumentList[] ={"" , "QFocusEvent*"};
1651 1792 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1652 1793 void* args[2] = {NULL, (void*)&arg__1};
@@ -1654,20 +1795,22 if (_wrapper) {
1654 1795 if (result) { Py_DECREF(result); }
1655 1796 Py_DECREF(obj);
1656 1797 return;
1798 } else {
1799 PyErr_Clear();
1657 1800 }
1658 1801 }
1659 1802 QHexEdit::focusInEvent(arg__1);
1660 1803 }
1661 bool PythonQtShell_QHexEdit::focusNextPrevChild(bool next)
1662 {
1663 if (_wrapper) {
1664 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
1665 PyErr_Clear();
1666 if (obj && !PythonQtSlotFunction_Check(obj)) {
1804 bool PythonQtShell_QHexEdit::focusNextPrevChild(bool next0)
1805 {
1806 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1807 static PyObject* name = PyString_FromString("focusNextPrevChild");
1808 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1809 if (obj) {
1667 1810 static const char* argumentList[] ={"bool" , "bool"};
1668 1811 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1669 1812 bool returnValue;
1670 void* args[2] = {NULL, (void*)&next};
1813 void* args[2] = {NULL, (void*)&next0};
1671 1814 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1672 1815 if (result) {
1673 1816 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -1682,16 +1825,18 if (_wrapper) {
1682 1825 if (result) { Py_DECREF(result); }
1683 1826 Py_DECREF(obj);
1684 1827 return returnValue;
1685 }
1686 }
1687 return QHexEdit::focusNextPrevChild(next);
1828 } else {
1829 PyErr_Clear();
1830 }
1831 }
1832 return QHexEdit::focusNextPrevChild(next0);
1688 1833 }
1689 1834 void PythonQtShell_QHexEdit::focusOutEvent(QFocusEvent* arg__1)
1690 1835 {
1691 if (_wrapper) {
1692 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
1693 PyErr_Clear();
1694 if (obj && !PythonQtSlotFunction_Check(obj)) {
1836 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1837 static PyObject* name = PyString_FromString("focusOutEvent");
1838 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1839 if (obj) {
1695 1840 static const char* argumentList[] ={"" , "QFocusEvent*"};
1696 1841 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1697 1842 void* args[2] = {NULL, (void*)&arg__1};
@@ -1699,16 +1844,18 if (_wrapper) {
1699 1844 if (result) { Py_DECREF(result); }
1700 1845 Py_DECREF(obj);
1701 1846 return;
1847 } else {
1848 PyErr_Clear();
1702 1849 }
1703 1850 }
1704 1851 QHexEdit::focusOutEvent(arg__1);
1705 1852 }
1706 1853 bool PythonQtShell_QHexEdit::hasHeightForWidth() const
1707 1854 {
1708 if (_wrapper) {
1709 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
1710 PyErr_Clear();
1711 if (obj && !PythonQtSlotFunction_Check(obj)) {
1855 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1856 static PyObject* name = PyString_FromString("hasHeightForWidth");
1857 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1858 if (obj) {
1712 1859 static const char* argumentList[] ={"bool"};
1713 1860 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1714 1861 bool returnValue;
@@ -1727,16 +1874,18 if (_wrapper) {
1727 1874 if (result) { Py_DECREF(result); }
1728 1875 Py_DECREF(obj);
1729 1876 return returnValue;
1877 } else {
1878 PyErr_Clear();
1730 1879 }
1731 1880 }
1732 1881 return QHexEdit::hasHeightForWidth();
1733 1882 }
1734 1883 int PythonQtShell_QHexEdit::heightForWidth(int arg__1) const
1735 1884 {
1736 if (_wrapper) {
1737 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
1738 PyErr_Clear();
1739 if (obj && !PythonQtSlotFunction_Check(obj)) {
1885 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1886 static PyObject* name = PyString_FromString("heightForWidth");
1887 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1888 if (obj) {
1740 1889 static const char* argumentList[] ={"int" , "int"};
1741 1890 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1742 1891 int returnValue;
@@ -1755,16 +1904,18 if (_wrapper) {
1755 1904 if (result) { Py_DECREF(result); }
1756 1905 Py_DECREF(obj);
1757 1906 return returnValue;
1907 } else {
1908 PyErr_Clear();
1758 1909 }
1759 1910 }
1760 1911 return QHexEdit::heightForWidth(arg__1);
1761 1912 }
1762 1913 void PythonQtShell_QHexEdit::hideEvent(QHideEvent* arg__1)
1763 1914 {
1764 if (_wrapper) {
1765 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
1766 PyErr_Clear();
1767 if (obj && !PythonQtSlotFunction_Check(obj)) {
1915 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1916 static PyObject* name = PyString_FromString("hideEvent");
1917 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1918 if (obj) {
1768 1919 static const char* argumentList[] ={"" , "QHideEvent*"};
1769 1920 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1770 1921 void* args[2] = {NULL, (void*)&arg__1};
@@ -1772,33 +1923,37 if (_wrapper) {
1772 1923 if (result) { Py_DECREF(result); }
1773 1924 Py_DECREF(obj);
1774 1925 return;
1926 } else {
1927 PyErr_Clear();
1775 1928 }
1776 1929 }
1777 1930 QHexEdit::hideEvent(arg__1);
1778 1931 }
1779 void PythonQtShell_QHexEdit::initPainter(QPainter* painter) const
1780 {
1781 if (_wrapper) {
1782 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
1783 PyErr_Clear();
1784 if (obj && !PythonQtSlotFunction_Check(obj)) {
1932 void PythonQtShell_QHexEdit::initPainter(QPainter* painter0) const
1933 {
1934 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1935 static PyObject* name = PyString_FromString("initPainter");
1936 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1937 if (obj) {
1785 1938 static const char* argumentList[] ={"" , "QPainter*"};
1786 1939 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1787 void* args[2] = {NULL, (void*)&painter};
1788 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1789 if (result) { Py_DECREF(result); }
1790 Py_DECREF(obj);
1791 return;
1792 }
1793 }
1794 QHexEdit::initPainter(painter);
1940 void* args[2] = {NULL, (void*)&painter0};
1941 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1942 if (result) { Py_DECREF(result); }
1943 Py_DECREF(obj);
1944 return;
1945 } else {
1946 PyErr_Clear();
1947 }
1948 }
1949 QHexEdit::initPainter(painter0);
1795 1950 }
1796 1951 void PythonQtShell_QHexEdit::inputMethodEvent(QInputMethodEvent* arg__1)
1797 1952 {
1798 if (_wrapper) {
1799 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
1800 PyErr_Clear();
1801 if (obj && !PythonQtSlotFunction_Check(obj)) {
1953 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1954 static PyObject* name = PyString_FromString("inputMethodEvent");
1955 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1956 if (obj) {
1802 1957 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
1803 1958 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1804 1959 void* args[2] = {NULL, (void*)&arg__1};
@@ -1806,16 +1961,18 if (_wrapper) {
1806 1961 if (result) { Py_DECREF(result); }
1807 1962 Py_DECREF(obj);
1808 1963 return;
1964 } else {
1965 PyErr_Clear();
1809 1966 }
1810 1967 }
1811 1968 QHexEdit::inputMethodEvent(arg__1);
1812 1969 }
1813 1970 QVariant PythonQtShell_QHexEdit::inputMethodQuery(Qt::InputMethodQuery arg__1) const
1814 1971 {
1815 if (_wrapper) {
1816 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
1817 PyErr_Clear();
1818 if (obj && !PythonQtSlotFunction_Check(obj)) {
1972 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1973 static PyObject* name = PyString_FromString("inputMethodQuery");
1974 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1975 if (obj) {
1819 1976 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
1820 1977 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1821 1978 QVariant returnValue;
@@ -1834,16 +1991,18 if (_wrapper) {
1834 1991 if (result) { Py_DECREF(result); }
1835 1992 Py_DECREF(obj);
1836 1993 return returnValue;
1994 } else {
1995 PyErr_Clear();
1837 1996 }
1838 1997 }
1839 1998 return QHexEdit::inputMethodQuery(arg__1);
1840 1999 }
1841 2000 void PythonQtShell_QHexEdit::keyPressEvent(QKeyEvent* arg__1)
1842 2001 {
1843 if (_wrapper) {
1844 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
1845 PyErr_Clear();
1846 if (obj && !PythonQtSlotFunction_Check(obj)) {
2002 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2003 static PyObject* name = PyString_FromString("keyPressEvent");
2004 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2005 if (obj) {
1847 2006 static const char* argumentList[] ={"" , "QKeyEvent*"};
1848 2007 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1849 2008 void* args[2] = {NULL, (void*)&arg__1};
@@ -1851,16 +2010,18 if (_wrapper) {
1851 2010 if (result) { Py_DECREF(result); }
1852 2011 Py_DECREF(obj);
1853 2012 return;
2013 } else {
2014 PyErr_Clear();
1854 2015 }
1855 2016 }
1856 2017 QHexEdit::keyPressEvent(arg__1);
1857 2018 }
1858 2019 void PythonQtShell_QHexEdit::keyReleaseEvent(QKeyEvent* arg__1)
1859 2020 {
1860 if (_wrapper) {
1861 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
1862 PyErr_Clear();
1863 if (obj && !PythonQtSlotFunction_Check(obj)) {
2021 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2022 static PyObject* name = PyString_FromString("keyReleaseEvent");
2023 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2024 if (obj) {
1864 2025 static const char* argumentList[] ={"" , "QKeyEvent*"};
1865 2026 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1866 2027 void* args[2] = {NULL, (void*)&arg__1};
@@ -1868,16 +2029,18 if (_wrapper) {
1868 2029 if (result) { Py_DECREF(result); }
1869 2030 Py_DECREF(obj);
1870 2031 return;
2032 } else {
2033 PyErr_Clear();
1871 2034 }
1872 2035 }
1873 2036 QHexEdit::keyReleaseEvent(arg__1);
1874 2037 }
1875 2038 void PythonQtShell_QHexEdit::leaveEvent(QEvent* arg__1)
1876 2039 {
1877 if (_wrapper) {
1878 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
1879 PyErr_Clear();
1880 if (obj && !PythonQtSlotFunction_Check(obj)) {
2040 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2041 static PyObject* name = PyString_FromString("leaveEvent");
2042 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2043 if (obj) {
1881 2044 static const char* argumentList[] ={"" , "QEvent*"};
1882 2045 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1883 2046 void* args[2] = {NULL, (void*)&arg__1};
@@ -1885,16 +2048,18 if (_wrapper) {
1885 2048 if (result) { Py_DECREF(result); }
1886 2049 Py_DECREF(obj);
1887 2050 return;
2051 } else {
2052 PyErr_Clear();
1888 2053 }
1889 2054 }
1890 2055 QHexEdit::leaveEvent(arg__1);
1891 2056 }
1892 2057 int PythonQtShell_QHexEdit::metric(QPaintDevice::PaintDeviceMetric arg__1) const
1893 2058 {
1894 if (_wrapper) {
1895 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
1896 PyErr_Clear();
1897 if (obj && !PythonQtSlotFunction_Check(obj)) {
2059 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2060 static PyObject* name = PyString_FromString("metric");
2061 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2062 if (obj) {
1898 2063 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
1899 2064 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1900 2065 int returnValue;
@@ -1913,16 +2078,18 if (_wrapper) {
1913 2078 if (result) { Py_DECREF(result); }
1914 2079 Py_DECREF(obj);
1915 2080 return returnValue;
2081 } else {
2082 PyErr_Clear();
1916 2083 }
1917 2084 }
1918 2085 return QHexEdit::metric(arg__1);
1919 2086 }
1920 2087 void PythonQtShell_QHexEdit::mouseDoubleClickEvent(QMouseEvent* arg__1)
1921 2088 {
1922 if (_wrapper) {
1923 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
1924 PyErr_Clear();
1925 if (obj && !PythonQtSlotFunction_Check(obj)) {
2089 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2090 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
2091 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2092 if (obj) {
1926 2093 static const char* argumentList[] ={"" , "QMouseEvent*"};
1927 2094 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1928 2095 void* args[2] = {NULL, (void*)&arg__1};
@@ -1930,16 +2097,18 if (_wrapper) {
1930 2097 if (result) { Py_DECREF(result); }
1931 2098 Py_DECREF(obj);
1932 2099 return;
2100 } else {
2101 PyErr_Clear();
1933 2102 }
1934 2103 }
1935 2104 QHexEdit::mouseDoubleClickEvent(arg__1);
1936 2105 }
1937 2106 void PythonQtShell_QHexEdit::mouseMoveEvent(QMouseEvent* arg__1)
1938 2107 {
1939 if (_wrapper) {
1940 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
1941 PyErr_Clear();
1942 if (obj && !PythonQtSlotFunction_Check(obj)) {
2108 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2109 static PyObject* name = PyString_FromString("mouseMoveEvent");
2110 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2111 if (obj) {
1943 2112 static const char* argumentList[] ={"" , "QMouseEvent*"};
1944 2113 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1945 2114 void* args[2] = {NULL, (void*)&arg__1};
@@ -1947,16 +2116,18 if (_wrapper) {
1947 2116 if (result) { Py_DECREF(result); }
1948 2117 Py_DECREF(obj);
1949 2118 return;
2119 } else {
2120 PyErr_Clear();
1950 2121 }
1951 2122 }
1952 2123 QHexEdit::mouseMoveEvent(arg__1);
1953 2124 }
1954 2125 void PythonQtShell_QHexEdit::mousePressEvent(QMouseEvent* arg__1)
1955 2126 {
1956 if (_wrapper) {
1957 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
1958 PyErr_Clear();
1959 if (obj && !PythonQtSlotFunction_Check(obj)) {
2127 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2128 static PyObject* name = PyString_FromString("mousePressEvent");
2129 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2130 if (obj) {
1960 2131 static const char* argumentList[] ={"" , "QMouseEvent*"};
1961 2132 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1962 2133 void* args[2] = {NULL, (void*)&arg__1};
@@ -1964,16 +2135,18 if (_wrapper) {
1964 2135 if (result) { Py_DECREF(result); }
1965 2136 Py_DECREF(obj);
1966 2137 return;
2138 } else {
2139 PyErr_Clear();
1967 2140 }
1968 2141 }
1969 2142 QHexEdit::mousePressEvent(arg__1);
1970 2143 }
1971 2144 void PythonQtShell_QHexEdit::mouseReleaseEvent(QMouseEvent* arg__1)
1972 2145 {
1973 if (_wrapper) {
1974 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
1975 PyErr_Clear();
1976 if (obj && !PythonQtSlotFunction_Check(obj)) {
2146 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2147 static PyObject* name = PyString_FromString("mouseReleaseEvent");
2148 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2149 if (obj) {
1977 2150 static const char* argumentList[] ={"" , "QMouseEvent*"};
1978 2151 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1979 2152 void* args[2] = {NULL, (void*)&arg__1};
@@ -1981,16 +2154,18 if (_wrapper) {
1981 2154 if (result) { Py_DECREF(result); }
1982 2155 Py_DECREF(obj);
1983 2156 return;
2157 } else {
2158 PyErr_Clear();
1984 2159 }
1985 2160 }
1986 2161 QHexEdit::mouseReleaseEvent(arg__1);
1987 2162 }
1988 2163 void PythonQtShell_QHexEdit::moveEvent(QMoveEvent* arg__1)
1989 2164 {
1990 if (_wrapper) {
1991 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
1992 PyErr_Clear();
1993 if (obj && !PythonQtSlotFunction_Check(obj)) {
2165 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2166 static PyObject* name = PyString_FromString("moveEvent");
2167 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2168 if (obj) {
1994 2169 static const char* argumentList[] ={"" , "QMoveEvent*"};
1995 2170 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1996 2171 void* args[2] = {NULL, (void*)&arg__1};
@@ -1998,20 +2173,22 if (_wrapper) {
1998 2173 if (result) { Py_DECREF(result); }
1999 2174 Py_DECREF(obj);
2000 2175 return;
2176 } else {
2177 PyErr_Clear();
2001 2178 }
2002 2179 }
2003 2180 QHexEdit::moveEvent(arg__1);
2004 2181 }
2005 bool PythonQtShell_QHexEdit::nativeEvent(const QByteArray& eventType, void* message, long* result)
2006 {
2007 if (_wrapper) {
2008 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
2009 PyErr_Clear();
2010 if (obj && !PythonQtSlotFunction_Check(obj)) {
2182 bool PythonQtShell_QHexEdit::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
2183 {
2184 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2185 static PyObject* name = PyString_FromString("nativeEvent");
2186 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2187 if (obj) {
2011 2188 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
2012 2189 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
2013 2190 bool returnValue;
2014 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
2191 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
2015 2192 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2016 2193 if (result) {
2017 2194 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -2026,16 +2203,18 if (_wrapper) {
2026 2203 if (result) { Py_DECREF(result); }
2027 2204 Py_DECREF(obj);
2028 2205 return returnValue;
2029 }
2030 }
2031 return QHexEdit::nativeEvent(eventType, message, result);
2206 } else {
2207 PyErr_Clear();
2208 }
2209 }
2210 return QHexEdit::nativeEvent(eventType0, message1, result2);
2032 2211 }
2033 2212 QPaintEngine* PythonQtShell_QHexEdit::paintEngine() const
2034 2213 {
2035 if (_wrapper) {
2036 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
2037 PyErr_Clear();
2038 if (obj && !PythonQtSlotFunction_Check(obj)) {
2214 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2215 static PyObject* name = PyString_FromString("paintEngine");
2216 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2217 if (obj) {
2039 2218 static const char* argumentList[] ={"QPaintEngine*"};
2040 2219 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2041 2220 QPaintEngine* returnValue;
@@ -2054,16 +2233,18 if (_wrapper) {
2054 2233 if (result) { Py_DECREF(result); }
2055 2234 Py_DECREF(obj);
2056 2235 return returnValue;
2236 } else {
2237 PyErr_Clear();
2057 2238 }
2058 2239 }
2059 2240 return QHexEdit::paintEngine();
2060 2241 }
2061 2242 void PythonQtShell_QHexEdit::paintEvent(QPaintEvent* arg__1)
2062 2243 {
2063 if (_wrapper) {
2064 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
2065 PyErr_Clear();
2066 if (obj && !PythonQtSlotFunction_Check(obj)) {
2244 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2245 static PyObject* name = PyString_FromString("paintEvent");
2246 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2247 if (obj) {
2067 2248 static const char* argumentList[] ={"" , "QPaintEvent*"};
2068 2249 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2069 2250 void* args[2] = {NULL, (void*)&arg__1};
@@ -2071,20 +2252,22 if (_wrapper) {
2071 2252 if (result) { Py_DECREF(result); }
2072 2253 Py_DECREF(obj);
2073 2254 return;
2255 } else {
2256 PyErr_Clear();
2074 2257 }
2075 2258 }
2076 2259 QHexEdit::paintEvent(arg__1);
2077 2260 }
2078 QPaintDevice* PythonQtShell_QHexEdit::redirected(QPoint* offset) const
2079 {
2080 if (_wrapper) {
2081 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
2082 PyErr_Clear();
2083 if (obj && !PythonQtSlotFunction_Check(obj)) {
2261 QPaintDevice* PythonQtShell_QHexEdit::redirected(QPoint* offset0) const
2262 {
2263 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2264 static PyObject* name = PyString_FromString("redirected");
2265 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2266 if (obj) {
2084 2267 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
2085 2268 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2086 2269 QPaintDevice* returnValue;
2087 void* args[2] = {NULL, (void*)&offset};
2270 void* args[2] = {NULL, (void*)&offset0};
2088 2271 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2089 2272 if (result) {
2090 2273 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -2099,16 +2282,18 if (_wrapper) {
2099 2282 if (result) { Py_DECREF(result); }
2100 2283 Py_DECREF(obj);
2101 2284 return returnValue;
2102 }
2103 }
2104 return QHexEdit::redirected(offset);
2285 } else {
2286 PyErr_Clear();
2287 }
2288 }
2289 return QHexEdit::redirected(offset0);
2105 2290 }
2106 2291 void PythonQtShell_QHexEdit::resizeEvent(QResizeEvent* arg__1)
2107 2292 {
2108 if (_wrapper) {
2109 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
2110 PyErr_Clear();
2111 if (obj && !PythonQtSlotFunction_Check(obj)) {
2293 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2294 static PyObject* name = PyString_FromString("resizeEvent");
2295 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2296 if (obj) {
2112 2297 static const char* argumentList[] ={"" , "QResizeEvent*"};
2113 2298 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2114 2299 void* args[2] = {NULL, (void*)&arg__1};
@@ -2116,50 +2301,56 if (_wrapper) {
2116 2301 if (result) { Py_DECREF(result); }
2117 2302 Py_DECREF(obj);
2118 2303 return;
2304 } else {
2305 PyErr_Clear();
2119 2306 }
2120 2307 }
2121 2308 QHexEdit::resizeEvent(arg__1);
2122 2309 }
2123 void PythonQtShell_QHexEdit::scrollContentsBy(int dx, int dy)
2124 {
2125 if (_wrapper) {
2126 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "scrollContentsBy");
2127 PyErr_Clear();
2128 if (obj && !PythonQtSlotFunction_Check(obj)) {
2310 void PythonQtShell_QHexEdit::scrollContentsBy(int dx0, int dy1)
2311 {
2312 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2313 static PyObject* name = PyString_FromString("scrollContentsBy");
2314 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2315 if (obj) {
2129 2316 static const char* argumentList[] ={"" , "int" , "int"};
2130 2317 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2131 void* args[3] = {NULL, (void*)&dx, (void*)&dy};
2132 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2133 if (result) { Py_DECREF(result); }
2134 Py_DECREF(obj);
2135 return;
2136 }
2137 }
2138 QHexEdit::scrollContentsBy(dx, dy);
2139 }
2140 void PythonQtShell_QHexEdit::setupViewport(QWidget* viewport)
2141 {
2142 if (_wrapper) {
2143 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setupViewport");
2144 PyErr_Clear();
2145 if (obj && !PythonQtSlotFunction_Check(obj)) {
2318 void* args[3] = {NULL, (void*)&dx0, (void*)&dy1};
2319 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2320 if (result) { Py_DECREF(result); }
2321 Py_DECREF(obj);
2322 return;
2323 } else {
2324 PyErr_Clear();
2325 }
2326 }
2327 QHexEdit::scrollContentsBy(dx0, dy1);
2328 }
2329 void PythonQtShell_QHexEdit::setupViewport(QWidget* viewport0)
2330 {
2331 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2332 static PyObject* name = PyString_FromString("setupViewport");
2333 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2334 if (obj) {
2146 2335 static const char* argumentList[] ={"" , "QWidget*"};
2147 2336 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2148 void* args[2] = {NULL, (void*)&viewport};
2149 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2150 if (result) { Py_DECREF(result); }
2151 Py_DECREF(obj);
2152 return;
2153 }
2154 }
2155 QHexEdit::setupViewport(viewport);
2337 void* args[2] = {NULL, (void*)&viewport0};
2338 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2339 if (result) { Py_DECREF(result); }
2340 Py_DECREF(obj);
2341 return;
2342 } else {
2343 PyErr_Clear();
2344 }
2345 }
2346 QHexEdit::setupViewport(viewport0);
2156 2347 }
2157 2348 QPainter* PythonQtShell_QHexEdit::sharedPainter() const
2158 2349 {
2159 if (_wrapper) {
2160 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
2161 PyErr_Clear();
2162 if (obj && !PythonQtSlotFunction_Check(obj)) {
2350 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2351 static PyObject* name = PyString_FromString("sharedPainter");
2352 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2353 if (obj) {
2163 2354 static const char* argumentList[] ={"QPainter*"};
2164 2355 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2165 2356 QPainter* returnValue;
@@ -2178,16 +2369,18 if (_wrapper) {
2178 2369 if (result) { Py_DECREF(result); }
2179 2370 Py_DECREF(obj);
2180 2371 return returnValue;
2372 } else {
2373 PyErr_Clear();
2181 2374 }
2182 2375 }
2183 2376 return QHexEdit::sharedPainter();
2184 2377 }
2185 2378 void PythonQtShell_QHexEdit::showEvent(QShowEvent* arg__1)
2186 2379 {
2187 if (_wrapper) {
2188 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
2189 PyErr_Clear();
2190 if (obj && !PythonQtSlotFunction_Check(obj)) {
2380 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2381 static PyObject* name = PyString_FromString("showEvent");
2382 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2383 if (obj) {
2191 2384 static const char* argumentList[] ={"" , "QShowEvent*"};
2192 2385 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2193 2386 void* args[2] = {NULL, (void*)&arg__1};
@@ -2195,16 +2388,18 if (_wrapper) {
2195 2388 if (result) { Py_DECREF(result); }
2196 2389 Py_DECREF(obj);
2197 2390 return;
2391 } else {
2392 PyErr_Clear();
2198 2393 }
2199 2394 }
2200 2395 QHexEdit::showEvent(arg__1);
2201 2396 }
2202 2397 void PythonQtShell_QHexEdit::tabletEvent(QTabletEvent* arg__1)
2203 2398 {
2204 if (_wrapper) {
2205 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
2206 PyErr_Clear();
2207 if (obj && !PythonQtSlotFunction_Check(obj)) {
2399 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2400 static PyObject* name = PyString_FromString("tabletEvent");
2401 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2402 if (obj) {
2208 2403 static const char* argumentList[] ={"" , "QTabletEvent*"};
2209 2404 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2210 2405 void* args[2] = {NULL, (void*)&arg__1};
@@ -2212,16 +2407,18 if (_wrapper) {
2212 2407 if (result) { Py_DECREF(result); }
2213 2408 Py_DECREF(obj);
2214 2409 return;
2410 } else {
2411 PyErr_Clear();
2215 2412 }
2216 2413 }
2217 2414 QHexEdit::tabletEvent(arg__1);
2218 2415 }
2219 2416 void PythonQtShell_QHexEdit::timerEvent(QTimerEvent* arg__1)
2220 2417 {
2221 if (_wrapper) {
2222 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
2223 PyErr_Clear();
2224 if (obj && !PythonQtSlotFunction_Check(obj)) {
2418 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2419 static PyObject* name = PyString_FromString("timerEvent");
2420 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2421 if (obj) {
2225 2422 static const char* argumentList[] ={"" , "QTimerEvent*"};
2226 2423 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2227 2424 void* args[2] = {NULL, (void*)&arg__1};
@@ -2229,16 +2426,18 if (_wrapper) {
2229 2426 if (result) { Py_DECREF(result); }
2230 2427 Py_DECREF(obj);
2231 2428 return;
2429 } else {
2430 PyErr_Clear();
2232 2431 }
2233 2432 }
2234 2433 QHexEdit::timerEvent(arg__1);
2235 2434 }
2236 2435 bool PythonQtShell_QHexEdit::viewportEvent(QEvent* arg__1)
2237 2436 {
2238 if (_wrapper) {
2239 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportEvent");
2240 PyErr_Clear();
2241 if (obj && !PythonQtSlotFunction_Check(obj)) {
2437 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2438 static PyObject* name = PyString_FromString("viewportEvent");
2439 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2440 if (obj) {
2242 2441 static const char* argumentList[] ={"bool" , "QEvent*"};
2243 2442 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2244 2443 bool returnValue;
@@ -2257,16 +2456,18 if (_wrapper) {
2257 2456 if (result) { Py_DECREF(result); }
2258 2457 Py_DECREF(obj);
2259 2458 return returnValue;
2459 } else {
2460 PyErr_Clear();
2260 2461 }
2261 2462 }
2262 2463 return QHexEdit::viewportEvent(arg__1);
2263 2464 }
2264 2465 QSize PythonQtShell_QHexEdit::viewportSizeHint() const
2265 2466 {
2266 if (_wrapper) {
2267 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportSizeHint");
2268 PyErr_Clear();
2269 if (obj && !PythonQtSlotFunction_Check(obj)) {
2467 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2468 static PyObject* name = PyString_FromString("viewportSizeHint");
2469 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2470 if (obj) {
2270 2471 static const char* argumentList[] ={"QSize"};
2271 2472 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2272 2473 QSize returnValue;
@@ -2285,16 +2486,18 if (_wrapper) {
2285 2486 if (result) { Py_DECREF(result); }
2286 2487 Py_DECREF(obj);
2287 2488 return returnValue;
2489 } else {
2490 PyErr_Clear();
2288 2491 }
2289 2492 }
2290 2493 return QHexEdit::viewportSizeHint();
2291 2494 }
2292 2495 void PythonQtShell_QHexEdit::wheelEvent(QWheelEvent* arg__1)
2293 2496 {
2294 if (_wrapper) {
2295 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
2296 PyErr_Clear();
2297 if (obj && !PythonQtSlotFunction_Check(obj)) {
2497 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2498 static PyObject* name = PyString_FromString("wheelEvent");
2499 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2500 if (obj) {
2298 2501 static const char* argumentList[] ={"" , "QWheelEvent*"};
2299 2502 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2300 2503 void* args[2] = {NULL, (void*)&arg__1};
@@ -2302,6 +2505,8 if (_wrapper) {
2302 2505 if (result) { Py_DECREF(result); }
2303 2506 Py_DECREF(obj);
2304 2507 return;
2508 } else {
2509 PyErr_Clear();
2305 2510 }
2306 2511 }
2307 2512 QHexEdit::wheelEvent(arg__1);
@@ -2473,10 +2678,10 PythonQtShell_QHexSpinBox::~PythonQtShel
2473 2678 }
2474 2679 void PythonQtShell_QHexSpinBox::actionEvent(QActionEvent* arg__1)
2475 2680 {
2476 if (_wrapper) {
2477 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
2478 PyErr_Clear();
2479 if (obj && !PythonQtSlotFunction_Check(obj)) {
2681 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2682 static PyObject* name = PyString_FromString("actionEvent");
2683 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2684 if (obj) {
2480 2685 static const char* argumentList[] ={"" , "QActionEvent*"};
2481 2686 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2482 2687 void* args[2] = {NULL, (void*)&arg__1};
@@ -2484,33 +2689,37 if (_wrapper) {
2484 2689 if (result) { Py_DECREF(result); }
2485 2690 Py_DECREF(obj);
2486 2691 return;
2692 } else {
2693 PyErr_Clear();
2487 2694 }
2488 2695 }
2489 2696 QHexSpinBox::actionEvent(arg__1);
2490 2697 }
2491 void PythonQtShell_QHexSpinBox::changeEvent(QEvent* event)
2492 {
2493 if (_wrapper) {
2494 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
2495 PyErr_Clear();
2496 if (obj && !PythonQtSlotFunction_Check(obj)) {
2698 void PythonQtShell_QHexSpinBox::changeEvent(QEvent* event0)
2699 {
2700 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2701 static PyObject* name = PyString_FromString("changeEvent");
2702 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2703 if (obj) {
2497 2704 static const char* argumentList[] ={"" , "QEvent*"};
2498 2705 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2499 void* args[2] = {NULL, (void*)&event};
2500 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2501 if (result) { Py_DECREF(result); }
2502 Py_DECREF(obj);
2503 return;
2504 }
2505 }
2506 QHexSpinBox::changeEvent(event);
2706 void* args[2] = {NULL, (void*)&event0};
2707 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2708 if (result) { Py_DECREF(result); }
2709 Py_DECREF(obj);
2710 return;
2711 } else {
2712 PyErr_Clear();
2713 }
2714 }
2715 QHexSpinBox::changeEvent(event0);
2507 2716 }
2508 2717 void PythonQtShell_QHexSpinBox::childEvent(QChildEvent* arg__1)
2509 2718 {
2510 if (_wrapper) {
2511 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
2512 PyErr_Clear();
2513 if (obj && !PythonQtSlotFunction_Check(obj)) {
2719 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2720 static PyObject* name = PyString_FromString("childEvent");
2721 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2722 if (obj) {
2514 2723 static const char* argumentList[] ={"" , "QChildEvent*"};
2515 2724 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2516 2725 void* args[2] = {NULL, (void*)&arg__1};
@@ -2518,16 +2727,18 if (_wrapper) {
2518 2727 if (result) { Py_DECREF(result); }
2519 2728 Py_DECREF(obj);
2520 2729 return;
2730 } else {
2731 PyErr_Clear();
2521 2732 }
2522 2733 }
2523 2734 QHexSpinBox::childEvent(arg__1);
2524 2735 }
2525 2736 void PythonQtShell_QHexSpinBox::clear()
2526 2737 {
2527 if (_wrapper) {
2528 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "clear");
2529 PyErr_Clear();
2530 if (obj && !PythonQtSlotFunction_Check(obj)) {
2738 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2739 static PyObject* name = PyString_FromString("clear");
2740 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2741 if (obj) {
2531 2742 static const char* argumentList[] ={""};
2532 2743 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2533 2744 void* args[1] = {NULL};
@@ -2535,50 +2746,56 if (_wrapper) {
2535 2746 if (result) { Py_DECREF(result); }
2536 2747 Py_DECREF(obj);
2537 2748 return;
2749 } else {
2750 PyErr_Clear();
2538 2751 }
2539 2752 }
2540 2753 QHexSpinBox::clear();
2541 2754 }
2542 void PythonQtShell_QHexSpinBox::closeEvent(QCloseEvent* event)
2543 {
2544 if (_wrapper) {
2545 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
2546 PyErr_Clear();
2547 if (obj && !PythonQtSlotFunction_Check(obj)) {
2755 void PythonQtShell_QHexSpinBox::closeEvent(QCloseEvent* event0)
2756 {
2757 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2758 static PyObject* name = PyString_FromString("closeEvent");
2759 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2760 if (obj) {
2548 2761 static const char* argumentList[] ={"" , "QCloseEvent*"};
2549 2762 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2550 void* args[2] = {NULL, (void*)&event};
2551 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2552 if (result) { Py_DECREF(result); }
2553 Py_DECREF(obj);
2554 return;
2555 }
2556 }
2557 QHexSpinBox::closeEvent(event);
2558 }
2559 void PythonQtShell_QHexSpinBox::contextMenuEvent(QContextMenuEvent* event)
2560 {
2561 if (_wrapper) {
2562 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
2563 PyErr_Clear();
2564 if (obj && !PythonQtSlotFunction_Check(obj)) {
2763 void* args[2] = {NULL, (void*)&event0};
2764 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2765 if (result) { Py_DECREF(result); }
2766 Py_DECREF(obj);
2767 return;
2768 } else {
2769 PyErr_Clear();
2770 }
2771 }
2772 QHexSpinBox::closeEvent(event0);
2773 }
2774 void PythonQtShell_QHexSpinBox::contextMenuEvent(QContextMenuEvent* event0)
2775 {
2776 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2777 static PyObject* name = PyString_FromString("contextMenuEvent");
2778 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2779 if (obj) {
2565 2780 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
2566 2781 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2567 void* args[2] = {NULL, (void*)&event};
2568 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2569 if (result) { Py_DECREF(result); }
2570 Py_DECREF(obj);
2571 return;
2572 }
2573 }
2574 QHexSpinBox::contextMenuEvent(event);
2782 void* args[2] = {NULL, (void*)&event0};
2783 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2784 if (result) { Py_DECREF(result); }
2785 Py_DECREF(obj);
2786 return;
2787 } else {
2788 PyErr_Clear();
2789 }
2790 }
2791 QHexSpinBox::contextMenuEvent(event0);
2575 2792 }
2576 2793 void PythonQtShell_QHexSpinBox::customEvent(QEvent* arg__1)
2577 2794 {
2578 if (_wrapper) {
2579 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
2580 PyErr_Clear();
2581 if (obj && !PythonQtSlotFunction_Check(obj)) {
2795 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2796 static PyObject* name = PyString_FromString("customEvent");
2797 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2798 if (obj) {
2582 2799 static const char* argumentList[] ={"" , "QEvent*"};
2583 2800 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2584 2801 void* args[2] = {NULL, (void*)&arg__1};
@@ -2586,16 +2803,18 if (_wrapper) {
2586 2803 if (result) { Py_DECREF(result); }
2587 2804 Py_DECREF(obj);
2588 2805 return;
2806 } else {
2807 PyErr_Clear();
2589 2808 }
2590 2809 }
2591 2810 QHexSpinBox::customEvent(arg__1);
2592 2811 }
2593 2812 int PythonQtShell_QHexSpinBox::devType() const
2594 2813 {
2595 if (_wrapper) {
2596 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
2597 PyErr_Clear();
2598 if (obj && !PythonQtSlotFunction_Check(obj)) {
2814 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2815 static PyObject* name = PyString_FromString("devType");
2816 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2817 if (obj) {
2599 2818 static const char* argumentList[] ={"int"};
2600 2819 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2601 2820 int returnValue;
@@ -2614,16 +2833,18 if (_wrapper) {
2614 2833 if (result) { Py_DECREF(result); }
2615 2834 Py_DECREF(obj);
2616 2835 return returnValue;
2836 } else {
2837 PyErr_Clear();
2617 2838 }
2618 2839 }
2619 2840 return QHexSpinBox::devType();
2620 2841 }
2621 2842 void PythonQtShell_QHexSpinBox::dragEnterEvent(QDragEnterEvent* arg__1)
2622 2843 {
2623 if (_wrapper) {
2624 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
2625 PyErr_Clear();
2626 if (obj && !PythonQtSlotFunction_Check(obj)) {
2844 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2845 static PyObject* name = PyString_FromString("dragEnterEvent");
2846 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2847 if (obj) {
2627 2848 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
2628 2849 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2629 2850 void* args[2] = {NULL, (void*)&arg__1};
@@ -2631,16 +2852,18 if (_wrapper) {
2631 2852 if (result) { Py_DECREF(result); }
2632 2853 Py_DECREF(obj);
2633 2854 return;
2855 } else {
2856 PyErr_Clear();
2634 2857 }
2635 2858 }
2636 2859 QHexSpinBox::dragEnterEvent(arg__1);
2637 2860 }
2638 2861 void PythonQtShell_QHexSpinBox::dragLeaveEvent(QDragLeaveEvent* arg__1)
2639 2862 {
2640 if (_wrapper) {
2641 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
2642 PyErr_Clear();
2643 if (obj && !PythonQtSlotFunction_Check(obj)) {
2863 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2864 static PyObject* name = PyString_FromString("dragLeaveEvent");
2865 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2866 if (obj) {
2644 2867 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
2645 2868 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2646 2869 void* args[2] = {NULL, (void*)&arg__1};
@@ -2648,16 +2871,18 if (_wrapper) {
2648 2871 if (result) { Py_DECREF(result); }
2649 2872 Py_DECREF(obj);
2650 2873 return;
2874 } else {
2875 PyErr_Clear();
2651 2876 }
2652 2877 }
2653 2878 QHexSpinBox::dragLeaveEvent(arg__1);
2654 2879 }
2655 2880 void PythonQtShell_QHexSpinBox::dragMoveEvent(QDragMoveEvent* arg__1)
2656 2881 {
2657 if (_wrapper) {
2658 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
2659 PyErr_Clear();
2660 if (obj && !PythonQtSlotFunction_Check(obj)) {
2882 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2883 static PyObject* name = PyString_FromString("dragMoveEvent");
2884 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2885 if (obj) {
2661 2886 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
2662 2887 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2663 2888 void* args[2] = {NULL, (void*)&arg__1};
@@ -2665,16 +2890,18 if (_wrapper) {
2665 2890 if (result) { Py_DECREF(result); }
2666 2891 Py_DECREF(obj);
2667 2892 return;
2893 } else {
2894 PyErr_Clear();
2668 2895 }
2669 2896 }
2670 2897 QHexSpinBox::dragMoveEvent(arg__1);
2671 2898 }
2672 2899 void PythonQtShell_QHexSpinBox::dropEvent(QDropEvent* arg__1)
2673 2900 {
2674 if (_wrapper) {
2675 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
2676 PyErr_Clear();
2677 if (obj && !PythonQtSlotFunction_Check(obj)) {
2901 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2902 static PyObject* name = PyString_FromString("dropEvent");
2903 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2904 if (obj) {
2678 2905 static const char* argumentList[] ={"" , "QDropEvent*"};
2679 2906 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2680 2907 void* args[2] = {NULL, (void*)&arg__1};
@@ -2682,16 +2909,18 if (_wrapper) {
2682 2909 if (result) { Py_DECREF(result); }
2683 2910 Py_DECREF(obj);
2684 2911 return;
2912 } else {
2913 PyErr_Clear();
2685 2914 }
2686 2915 }
2687 2916 QHexSpinBox::dropEvent(arg__1);
2688 2917 }
2689 2918 void PythonQtShell_QHexSpinBox::enterEvent(QEvent* arg__1)
2690 2919 {
2691 if (_wrapper) {
2692 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
2693 PyErr_Clear();
2694 if (obj && !PythonQtSlotFunction_Check(obj)) {
2920 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2921 static PyObject* name = PyString_FromString("enterEvent");
2922 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2923 if (obj) {
2695 2924 static const char* argumentList[] ={"" , "QEvent*"};
2696 2925 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2697 2926 void* args[2] = {NULL, (void*)&arg__1};
@@ -2699,20 +2928,22 if (_wrapper) {
2699 2928 if (result) { Py_DECREF(result); }
2700 2929 Py_DECREF(obj);
2701 2930 return;
2931 } else {
2932 PyErr_Clear();
2702 2933 }
2703 2934 }
2704 2935 QHexSpinBox::enterEvent(arg__1);
2705 2936 }
2706 bool PythonQtShell_QHexSpinBox::event(QEvent* event)
2707 {
2708 if (_wrapper) {
2709 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
2710 PyErr_Clear();
2711 if (obj && !PythonQtSlotFunction_Check(obj)) {
2937 bool PythonQtShell_QHexSpinBox::event(QEvent* event0)
2938 {
2939 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2940 static PyObject* name = PyString_FromString("event");
2941 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2942 if (obj) {
2712 2943 static const char* argumentList[] ={"bool" , "QEvent*"};
2713 2944 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2714 2945 bool returnValue;
2715 void* args[2] = {NULL, (void*)&event};
2946 void* args[2] = {NULL, (void*)&event0};
2716 2947 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2717 2948 if (result) {
2718 2949 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -2727,16 +2958,18 if (_wrapper) {
2727 2958 if (result) { Py_DECREF(result); }
2728 2959 Py_DECREF(obj);
2729 2960 return returnValue;
2730 }
2731 }
2732 return QHexSpinBox::event(event);
2961 } else {
2962 PyErr_Clear();
2963 }
2964 }
2965 return QHexSpinBox::event(event0);
2733 2966 }
2734 2967 bool PythonQtShell_QHexSpinBox::eventFilter(QObject* arg__1, QEvent* arg__2)
2735 2968 {
2736 if (_wrapper) {
2737 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
2738 PyErr_Clear();
2739 if (obj && !PythonQtSlotFunction_Check(obj)) {
2969 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2970 static PyObject* name = PyString_FromString("eventFilter");
2971 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2972 if (obj) {
2740 2973 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
2741 2974 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2742 2975 bool returnValue;
@@ -2755,54 +2988,60 if (_wrapper) {
2755 2988 if (result) { Py_DECREF(result); }
2756 2989 Py_DECREF(obj);
2757 2990 return returnValue;
2991 } else {
2992 PyErr_Clear();
2758 2993 }
2759 2994 }
2760 2995 return QHexSpinBox::eventFilter(arg__1, arg__2);
2761 2996 }
2762 void PythonQtShell_QHexSpinBox::fixup(QString& str) const
2763 {
2764 if (_wrapper) {
2765 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "fixup");
2766 PyErr_Clear();
2767 if (obj && !PythonQtSlotFunction_Check(obj)) {
2997 void PythonQtShell_QHexSpinBox::fixup(QString& str0) const
2998 {
2999 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3000 static PyObject* name = PyString_FromString("fixup");
3001 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3002 if (obj) {
2768 3003 static const char* argumentList[] ={"" , "QString&"};
2769 3004 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2770 void* args[2] = {NULL, (void*)&str};
2771 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2772 if (result) { Py_DECREF(result); }
2773 Py_DECREF(obj);
2774 return;
2775 }
2776 }
2777 QHexSpinBox::fixup(str);
2778 }
2779 void PythonQtShell_QHexSpinBox::focusInEvent(QFocusEvent* event)
2780 {
2781 if (_wrapper) {
2782 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
2783 PyErr_Clear();
2784 if (obj && !PythonQtSlotFunction_Check(obj)) {
3005 void* args[2] = {NULL, (void*)&str0};
3006 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3007 if (result) { Py_DECREF(result); }
3008 Py_DECREF(obj);
3009 return;
3010 } else {
3011 PyErr_Clear();
3012 }
3013 }
3014 QHexSpinBox::fixup(str0);
3015 }
3016 void PythonQtShell_QHexSpinBox::focusInEvent(QFocusEvent* event0)
3017 {
3018 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3019 static PyObject* name = PyString_FromString("focusInEvent");
3020 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3021 if (obj) {
2785 3022 static const char* argumentList[] ={"" , "QFocusEvent*"};
2786 3023 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2787 void* args[2] = {NULL, (void*)&event};
2788 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2789 if (result) { Py_DECREF(result); }
2790 Py_DECREF(obj);
2791 return;
2792 }
2793 }
2794 QHexSpinBox::focusInEvent(event);
2795 }
2796 bool PythonQtShell_QHexSpinBox::focusNextPrevChild(bool next)
2797 {
2798 if (_wrapper) {
2799 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
2800 PyErr_Clear();
2801 if (obj && !PythonQtSlotFunction_Check(obj)) {
3024 void* args[2] = {NULL, (void*)&event0};
3025 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3026 if (result) { Py_DECREF(result); }
3027 Py_DECREF(obj);
3028 return;
3029 } else {
3030 PyErr_Clear();
3031 }
3032 }
3033 QHexSpinBox::focusInEvent(event0);
3034 }
3035 bool PythonQtShell_QHexSpinBox::focusNextPrevChild(bool next0)
3036 {
3037 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3038 static PyObject* name = PyString_FromString("focusNextPrevChild");
3039 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3040 if (obj) {
2802 3041 static const char* argumentList[] ={"bool" , "bool"};
2803 3042 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2804 3043 bool returnValue;
2805 void* args[2] = {NULL, (void*)&next};
3044 void* args[2] = {NULL, (void*)&next0};
2806 3045 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2807 3046 if (result) {
2808 3047 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -2817,33 +3056,37 if (_wrapper) {
2817 3056 if (result) { Py_DECREF(result); }
2818 3057 Py_DECREF(obj);
2819 3058 return returnValue;
2820 }
2821 }
2822 return QHexSpinBox::focusNextPrevChild(next);
2823 }
2824 void PythonQtShell_QHexSpinBox::focusOutEvent(QFocusEvent* event)
2825 {
2826 if (_wrapper) {
2827 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
2828 PyErr_Clear();
2829 if (obj && !PythonQtSlotFunction_Check(obj)) {
3059 } else {
3060 PyErr_Clear();
3061 }
3062 }
3063 return QHexSpinBox::focusNextPrevChild(next0);
3064 }
3065 void PythonQtShell_QHexSpinBox::focusOutEvent(QFocusEvent* event0)
3066 {
3067 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3068 static PyObject* name = PyString_FromString("focusOutEvent");
3069 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3070 if (obj) {
2830 3071 static const char* argumentList[] ={"" , "QFocusEvent*"};
2831 3072 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2832 void* args[2] = {NULL, (void*)&event};
2833 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2834 if (result) { Py_DECREF(result); }
2835 Py_DECREF(obj);
2836 return;
2837 }
2838 }
2839 QHexSpinBox::focusOutEvent(event);
3073 void* args[2] = {NULL, (void*)&event0};
3074 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3075 if (result) { Py_DECREF(result); }
3076 Py_DECREF(obj);
3077 return;
3078 } else {
3079 PyErr_Clear();
3080 }
3081 }
3082 QHexSpinBox::focusOutEvent(event0);
2840 3083 }
2841 3084 bool PythonQtShell_QHexSpinBox::hasHeightForWidth() const
2842 3085 {
2843 if (_wrapper) {
2844 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
2845 PyErr_Clear();
2846 if (obj && !PythonQtSlotFunction_Check(obj)) {
3086 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3087 static PyObject* name = PyString_FromString("hasHeightForWidth");
3088 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3089 if (obj) {
2847 3090 static const char* argumentList[] ={"bool"};
2848 3091 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2849 3092 bool returnValue;
@@ -2862,16 +3105,18 if (_wrapper) {
2862 3105 if (result) { Py_DECREF(result); }
2863 3106 Py_DECREF(obj);
2864 3107 return returnValue;
3108 } else {
3109 PyErr_Clear();
2865 3110 }
2866 3111 }
2867 3112 return QHexSpinBox::hasHeightForWidth();
2868 3113 }
2869 3114 int PythonQtShell_QHexSpinBox::heightForWidth(int arg__1) const
2870 3115 {
2871 if (_wrapper) {
2872 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
2873 PyErr_Clear();
2874 if (obj && !PythonQtSlotFunction_Check(obj)) {
3116 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3117 static PyObject* name = PyString_FromString("heightForWidth");
3118 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3119 if (obj) {
2875 3120 static const char* argumentList[] ={"int" , "int"};
2876 3121 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2877 3122 int returnValue;
@@ -2890,50 +3135,56 if (_wrapper) {
2890 3135 if (result) { Py_DECREF(result); }
2891 3136 Py_DECREF(obj);
2892 3137 return returnValue;
3138 } else {
3139 PyErr_Clear();
2893 3140 }
2894 3141 }
2895 3142 return QHexSpinBox::heightForWidth(arg__1);
2896 3143 }
2897 void PythonQtShell_QHexSpinBox::hideEvent(QHideEvent* event)
2898 {
2899 if (_wrapper) {
2900 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
2901 PyErr_Clear();
2902 if (obj && !PythonQtSlotFunction_Check(obj)) {
3144 void PythonQtShell_QHexSpinBox::hideEvent(QHideEvent* event0)
3145 {
3146 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3147 static PyObject* name = PyString_FromString("hideEvent");
3148 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3149 if (obj) {
2903 3150 static const char* argumentList[] ={"" , "QHideEvent*"};
2904 3151 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2905 void* args[2] = {NULL, (void*)&event};
2906 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2907 if (result) { Py_DECREF(result); }
2908 Py_DECREF(obj);
2909 return;
2910 }
2911 }
2912 QHexSpinBox::hideEvent(event);
2913 }
2914 void PythonQtShell_QHexSpinBox::initPainter(QPainter* painter) const
2915 {
2916 if (_wrapper) {
2917 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
2918 PyErr_Clear();
2919 if (obj && !PythonQtSlotFunction_Check(obj)) {
3152 void* args[2] = {NULL, (void*)&event0};
3153 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3154 if (result) { Py_DECREF(result); }
3155 Py_DECREF(obj);
3156 return;
3157 } else {
3158 PyErr_Clear();
3159 }
3160 }
3161 QHexSpinBox::hideEvent(event0);
3162 }
3163 void PythonQtShell_QHexSpinBox::initPainter(QPainter* painter0) const
3164 {
3165 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3166 static PyObject* name = PyString_FromString("initPainter");
3167 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3168 if (obj) {
2920 3169 static const char* argumentList[] ={"" , "QPainter*"};
2921 3170 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2922 void* args[2] = {NULL, (void*)&painter};
2923 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2924 if (result) { Py_DECREF(result); }
2925 Py_DECREF(obj);
2926 return;
2927 }
2928 }
2929 QHexSpinBox::initPainter(painter);
3171 void* args[2] = {NULL, (void*)&painter0};
3172 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3173 if (result) { Py_DECREF(result); }
3174 Py_DECREF(obj);
3175 return;
3176 } else {
3177 PyErr_Clear();
3178 }
3179 }
3180 QHexSpinBox::initPainter(painter0);
2930 3181 }
2931 3182 void PythonQtShell_QHexSpinBox::inputMethodEvent(QInputMethodEvent* arg__1)
2932 3183 {
2933 if (_wrapper) {
2934 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
2935 PyErr_Clear();
2936 if (obj && !PythonQtSlotFunction_Check(obj)) {
3184 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3185 static PyObject* name = PyString_FromString("inputMethodEvent");
3186 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3187 if (obj) {
2937 3188 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
2938 3189 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2939 3190 void* args[2] = {NULL, (void*)&arg__1};
@@ -2941,16 +3192,18 if (_wrapper) {
2941 3192 if (result) { Py_DECREF(result); }
2942 3193 Py_DECREF(obj);
2943 3194 return;
3195 } else {
3196 PyErr_Clear();
2944 3197 }
2945 3198 }
2946 3199 QHexSpinBox::inputMethodEvent(arg__1);
2947 3200 }
2948 3201 QVariant PythonQtShell_QHexSpinBox::inputMethodQuery(Qt::InputMethodQuery arg__1) const
2949 3202 {
2950 if (_wrapper) {
2951 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
2952 PyErr_Clear();
2953 if (obj && !PythonQtSlotFunction_Check(obj)) {
3203 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3204 static PyObject* name = PyString_FromString("inputMethodQuery");
3205 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3206 if (obj) {
2954 3207 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
2955 3208 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2956 3209 QVariant returnValue;
@@ -2969,50 +3222,56 if (_wrapper) {
2969 3222 if (result) { Py_DECREF(result); }
2970 3223 Py_DECREF(obj);
2971 3224 return returnValue;
3225 } else {
3226 PyErr_Clear();
2972 3227 }
2973 3228 }
2974 3229 return QHexSpinBox::inputMethodQuery(arg__1);
2975 3230 }
2976 void PythonQtShell_QHexSpinBox::keyPressEvent(QKeyEvent* event)
2977 {
2978 if (_wrapper) {
2979 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
2980 PyErr_Clear();
2981 if (obj && !PythonQtSlotFunction_Check(obj)) {
3231 void PythonQtShell_QHexSpinBox::keyPressEvent(QKeyEvent* event0)
3232 {
3233 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3234 static PyObject* name = PyString_FromString("keyPressEvent");
3235 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3236 if (obj) {
2982 3237 static const char* argumentList[] ={"" , "QKeyEvent*"};
2983 3238 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2984 void* args[2] = {NULL, (void*)&event};
2985 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2986 if (result) { Py_DECREF(result); }
2987 Py_DECREF(obj);
2988 return;
2989 }
2990 }
2991 QHexSpinBox::keyPressEvent(event);
2992 }
2993 void PythonQtShell_QHexSpinBox::keyReleaseEvent(QKeyEvent* event)
2994 {
2995 if (_wrapper) {
2996 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
2997 PyErr_Clear();
2998 if (obj && !PythonQtSlotFunction_Check(obj)) {
3239 void* args[2] = {NULL, (void*)&event0};
3240 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3241 if (result) { Py_DECREF(result); }
3242 Py_DECREF(obj);
3243 return;
3244 } else {
3245 PyErr_Clear();
3246 }
3247 }
3248 QHexSpinBox::keyPressEvent(event0);
3249 }
3250 void PythonQtShell_QHexSpinBox::keyReleaseEvent(QKeyEvent* event0)
3251 {
3252 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3253 static PyObject* name = PyString_FromString("keyReleaseEvent");
3254 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3255 if (obj) {
2999 3256 static const char* argumentList[] ={"" , "QKeyEvent*"};
3000 3257 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3001 void* args[2] = {NULL, (void*)&event};
3002 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3003 if (result) { Py_DECREF(result); }
3004 Py_DECREF(obj);
3005 return;
3006 }
3007 }
3008 QHexSpinBox::keyReleaseEvent(event);
3258 void* args[2] = {NULL, (void*)&event0};
3259 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3260 if (result) { Py_DECREF(result); }
3261 Py_DECREF(obj);
3262 return;
3263 } else {
3264 PyErr_Clear();
3265 }
3266 }
3267 QHexSpinBox::keyReleaseEvent(event0);
3009 3268 }
3010 3269 void PythonQtShell_QHexSpinBox::leaveEvent(QEvent* arg__1)
3011 3270 {
3012 if (_wrapper) {
3013 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
3014 PyErr_Clear();
3015 if (obj && !PythonQtSlotFunction_Check(obj)) {
3271 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3272 static PyObject* name = PyString_FromString("leaveEvent");
3273 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3274 if (obj) {
3016 3275 static const char* argumentList[] ={"" , "QEvent*"};
3017 3276 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3018 3277 void* args[2] = {NULL, (void*)&arg__1};
@@ -3020,16 +3279,18 if (_wrapper) {
3020 3279 if (result) { Py_DECREF(result); }
3021 3280 Py_DECREF(obj);
3022 3281 return;
3282 } else {
3283 PyErr_Clear();
3023 3284 }
3024 3285 }
3025 3286 QHexSpinBox::leaveEvent(arg__1);
3026 3287 }
3027 3288 int PythonQtShell_QHexSpinBox::metric(QPaintDevice::PaintDeviceMetric arg__1) const
3028 3289 {
3029 if (_wrapper) {
3030 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
3031 PyErr_Clear();
3032 if (obj && !PythonQtSlotFunction_Check(obj)) {
3290 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3291 static PyObject* name = PyString_FromString("metric");
3292 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3293 if (obj) {
3033 3294 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
3034 3295 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3035 3296 int returnValue;
@@ -3048,16 +3309,18 if (_wrapper) {
3048 3309 if (result) { Py_DECREF(result); }
3049 3310 Py_DECREF(obj);
3050 3311 return returnValue;
3312 } else {
3313 PyErr_Clear();
3051 3314 }
3052 3315 }
3053 3316 return QHexSpinBox::metric(arg__1);
3054 3317 }
3055 3318 void PythonQtShell_QHexSpinBox::mouseDoubleClickEvent(QMouseEvent* arg__1)
3056 3319 {
3057 if (_wrapper) {
3058 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
3059 PyErr_Clear();
3060 if (obj && !PythonQtSlotFunction_Check(obj)) {
3320 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3321 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
3322 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3323 if (obj) {
3061 3324 static const char* argumentList[] ={"" , "QMouseEvent*"};
3062 3325 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3063 3326 void* args[2] = {NULL, (void*)&arg__1};
@@ -3065,67 +3328,75 if (_wrapper) {
3065 3328 if (result) { Py_DECREF(result); }
3066 3329 Py_DECREF(obj);
3067 3330 return;
3331 } else {
3332 PyErr_Clear();
3068 3333 }
3069 3334 }
3070 3335 QHexSpinBox::mouseDoubleClickEvent(arg__1);
3071 3336 }
3072 void PythonQtShell_QHexSpinBox::mouseMoveEvent(QMouseEvent* event)
3073 {
3074 if (_wrapper) {
3075 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
3076 PyErr_Clear();
3077 if (obj && !PythonQtSlotFunction_Check(obj)) {
3337 void PythonQtShell_QHexSpinBox::mouseMoveEvent(QMouseEvent* event0)
3338 {
3339 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3340 static PyObject* name = PyString_FromString("mouseMoveEvent");
3341 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3342 if (obj) {
3078 3343 static const char* argumentList[] ={"" , "QMouseEvent*"};
3079 3344 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3080 void* args[2] = {NULL, (void*)&event};
3081 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3082 if (result) { Py_DECREF(result); }
3083 Py_DECREF(obj);
3084 return;
3085 }
3086 }
3087 QHexSpinBox::mouseMoveEvent(event);
3088 }
3089 void PythonQtShell_QHexSpinBox::mousePressEvent(QMouseEvent* event)
3090 {
3091 if (_wrapper) {
3092 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
3093 PyErr_Clear();
3094 if (obj && !PythonQtSlotFunction_Check(obj)) {
3345 void* args[2] = {NULL, (void*)&event0};
3346 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3347 if (result) { Py_DECREF(result); }
3348 Py_DECREF(obj);
3349 return;
3350 } else {
3351 PyErr_Clear();
3352 }
3353 }
3354 QHexSpinBox::mouseMoveEvent(event0);
3355 }
3356 void PythonQtShell_QHexSpinBox::mousePressEvent(QMouseEvent* event0)
3357 {
3358 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3359 static PyObject* name = PyString_FromString("mousePressEvent");
3360 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3361 if (obj) {
3095 3362 static const char* argumentList[] ={"" , "QMouseEvent*"};
3096 3363 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3097 void* args[2] = {NULL, (void*)&event};
3098 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3099 if (result) { Py_DECREF(result); }
3100 Py_DECREF(obj);
3101 return;
3102 }
3103 }
3104 QHexSpinBox::mousePressEvent(event);
3105 }
3106 void PythonQtShell_QHexSpinBox::mouseReleaseEvent(QMouseEvent* event)
3107 {
3108 if (_wrapper) {
3109 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
3110 PyErr_Clear();
3111 if (obj && !PythonQtSlotFunction_Check(obj)) {
3364 void* args[2] = {NULL, (void*)&event0};
3365 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3366 if (result) { Py_DECREF(result); }
3367 Py_DECREF(obj);
3368 return;
3369 } else {
3370 PyErr_Clear();
3371 }
3372 }
3373 QHexSpinBox::mousePressEvent(event0);
3374 }
3375 void PythonQtShell_QHexSpinBox::mouseReleaseEvent(QMouseEvent* event0)
3376 {
3377 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3378 static PyObject* name = PyString_FromString("mouseReleaseEvent");
3379 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3380 if (obj) {
3112 3381 static const char* argumentList[] ={"" , "QMouseEvent*"};
3113 3382 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3114 void* args[2] = {NULL, (void*)&event};
3115 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3116 if (result) { Py_DECREF(result); }
3117 Py_DECREF(obj);
3118 return;
3119 }
3120 }
3121 QHexSpinBox::mouseReleaseEvent(event);
3383 void* args[2] = {NULL, (void*)&event0};
3384 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3385 if (result) { Py_DECREF(result); }
3386 Py_DECREF(obj);
3387 return;
3388 } else {
3389 PyErr_Clear();
3390 }
3391 }
3392 QHexSpinBox::mouseReleaseEvent(event0);
3122 3393 }
3123 3394 void PythonQtShell_QHexSpinBox::moveEvent(QMoveEvent* arg__1)
3124 3395 {
3125 if (_wrapper) {
3126 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
3127 PyErr_Clear();
3128 if (obj && !PythonQtSlotFunction_Check(obj)) {
3396 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3397 static PyObject* name = PyString_FromString("moveEvent");
3398 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3399 if (obj) {
3129 3400 static const char* argumentList[] ={"" , "QMoveEvent*"};
3130 3401 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3131 3402 void* args[2] = {NULL, (void*)&arg__1};
@@ -3133,20 +3404,22 if (_wrapper) {
3133 3404 if (result) { Py_DECREF(result); }
3134 3405 Py_DECREF(obj);
3135 3406 return;
3407 } else {
3408 PyErr_Clear();
3136 3409 }
3137 3410 }
3138 3411 QHexSpinBox::moveEvent(arg__1);
3139 3412 }
3140 bool PythonQtShell_QHexSpinBox::nativeEvent(const QByteArray& eventType, void* message, long* result)
3141 {
3142 if (_wrapper) {
3143 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
3144 PyErr_Clear();
3145 if (obj && !PythonQtSlotFunction_Check(obj)) {
3413 bool PythonQtShell_QHexSpinBox::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
3414 {
3415 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3416 static PyObject* name = PyString_FromString("nativeEvent");
3417 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3418 if (obj) {
3146 3419 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
3147 3420 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
3148 3421 bool returnValue;
3149 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
3422 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
3150 3423 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3151 3424 if (result) {
3152 3425 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -3161,16 +3434,18 if (_wrapper) {
3161 3434 if (result) { Py_DECREF(result); }
3162 3435 Py_DECREF(obj);
3163 3436 return returnValue;
3164 }
3165 }
3166 return QHexSpinBox::nativeEvent(eventType, message, result);
3437 } else {
3438 PyErr_Clear();
3439 }
3440 }
3441 return QHexSpinBox::nativeEvent(eventType0, message1, result2);
3167 3442 }
3168 3443 QPaintEngine* PythonQtShell_QHexSpinBox::paintEngine() const
3169 3444 {
3170 if (_wrapper) {
3171 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
3172 PyErr_Clear();
3173 if (obj && !PythonQtSlotFunction_Check(obj)) {
3445 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3446 static PyObject* name = PyString_FromString("paintEngine");
3447 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3448 if (obj) {
3174 3449 static const char* argumentList[] ={"QPaintEngine*"};
3175 3450 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3176 3451 QPaintEngine* returnValue;
@@ -3189,37 +3464,41 if (_wrapper) {
3189 3464 if (result) { Py_DECREF(result); }
3190 3465 Py_DECREF(obj);
3191 3466 return returnValue;
3467 } else {
3468 PyErr_Clear();
3192 3469 }
3193 3470 }
3194 3471 return QHexSpinBox::paintEngine();
3195 3472 }
3196 void PythonQtShell_QHexSpinBox::paintEvent(QPaintEvent* event)
3197 {
3198 if (_wrapper) {
3199 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
3200 PyErr_Clear();
3201 if (obj && !PythonQtSlotFunction_Check(obj)) {
3473 void PythonQtShell_QHexSpinBox::paintEvent(QPaintEvent* event0)
3474 {
3475 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3476 static PyObject* name = PyString_FromString("paintEvent");
3477 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3478 if (obj) {
3202 3479 static const char* argumentList[] ={"" , "QPaintEvent*"};
3203 3480 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3204 void* args[2] = {NULL, (void*)&event};
3205 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3206 if (result) { Py_DECREF(result); }
3207 Py_DECREF(obj);
3208 return;
3209 }
3210 }
3211 QHexSpinBox::paintEvent(event);
3212 }
3213 QPaintDevice* PythonQtShell_QHexSpinBox::redirected(QPoint* offset) const
3214 {
3215 if (_wrapper) {
3216 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
3217 PyErr_Clear();
3218 if (obj && !PythonQtSlotFunction_Check(obj)) {
3481 void* args[2] = {NULL, (void*)&event0};
3482 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3483 if (result) { Py_DECREF(result); }
3484 Py_DECREF(obj);
3485 return;
3486 } else {
3487 PyErr_Clear();
3488 }
3489 }
3490 QHexSpinBox::paintEvent(event0);
3491 }
3492 QPaintDevice* PythonQtShell_QHexSpinBox::redirected(QPoint* offset0) const
3493 {
3494 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3495 static PyObject* name = PyString_FromString("redirected");
3496 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3497 if (obj) {
3219 3498 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
3220 3499 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3221 3500 QPaintDevice* returnValue;
3222 void* args[2] = {NULL, (void*)&offset};
3501 void* args[2] = {NULL, (void*)&offset0};
3223 3502 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3224 3503 if (result) {
3225 3504 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -3234,33 +3513,37 if (_wrapper) {
3234 3513 if (result) { Py_DECREF(result); }
3235 3514 Py_DECREF(obj);
3236 3515 return returnValue;
3237 }
3238 }
3239 return QHexSpinBox::redirected(offset);
3240 }
3241 void PythonQtShell_QHexSpinBox::resizeEvent(QResizeEvent* event)
3242 {
3243 if (_wrapper) {
3244 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
3245 PyErr_Clear();
3246 if (obj && !PythonQtSlotFunction_Check(obj)) {
3516 } else {
3517 PyErr_Clear();
3518 }
3519 }
3520 return QHexSpinBox::redirected(offset0);
3521 }
3522 void PythonQtShell_QHexSpinBox::resizeEvent(QResizeEvent* event0)
3523 {
3524 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3525 static PyObject* name = PyString_FromString("resizeEvent");
3526 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3527 if (obj) {
3247 3528 static const char* argumentList[] ={"" , "QResizeEvent*"};
3248 3529 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3249 void* args[2] = {NULL, (void*)&event};
3250 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3251 if (result) { Py_DECREF(result); }
3252 Py_DECREF(obj);
3253 return;
3254 }
3255 }
3256 QHexSpinBox::resizeEvent(event);
3530 void* args[2] = {NULL, (void*)&event0};
3531 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3532 if (result) { Py_DECREF(result); }
3533 Py_DECREF(obj);
3534 return;
3535 } else {
3536 PyErr_Clear();
3537 }
3538 }
3539 QHexSpinBox::resizeEvent(event0);
3257 3540 }
3258 3541 QPainter* PythonQtShell_QHexSpinBox::sharedPainter() const
3259 3542 {
3260 if (_wrapper) {
3261 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
3262 PyErr_Clear();
3263 if (obj && !PythonQtSlotFunction_Check(obj)) {
3543 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3544 static PyObject* name = PyString_FromString("sharedPainter");
3545 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3546 if (obj) {
3264 3547 static const char* argumentList[] ={"QPainter*"};
3265 3548 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3266 3549 QPainter* returnValue;
@@ -3279,50 +3562,56 if (_wrapper) {
3279 3562 if (result) { Py_DECREF(result); }
3280 3563 Py_DECREF(obj);
3281 3564 return returnValue;
3565 } else {
3566 PyErr_Clear();
3282 3567 }
3283 3568 }
3284 3569 return QHexSpinBox::sharedPainter();
3285 3570 }
3286 void PythonQtShell_QHexSpinBox::showEvent(QShowEvent* event)
3287 {
3288 if (_wrapper) {
3289 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
3290 PyErr_Clear();
3291 if (obj && !PythonQtSlotFunction_Check(obj)) {
3571 void PythonQtShell_QHexSpinBox::showEvent(QShowEvent* event0)
3572 {
3573 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3574 static PyObject* name = PyString_FromString("showEvent");
3575 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3576 if (obj) {
3292 3577 static const char* argumentList[] ={"" , "QShowEvent*"};
3293 3578 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3294 void* args[2] = {NULL, (void*)&event};
3295 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3296 if (result) { Py_DECREF(result); }
3297 Py_DECREF(obj);
3298 return;
3299 }
3300 }
3301 QHexSpinBox::showEvent(event);
3302 }
3303 void PythonQtShell_QHexSpinBox::stepBy(int steps)
3304 {
3305 if (_wrapper) {
3306 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepBy");
3307 PyErr_Clear();
3308 if (obj && !PythonQtSlotFunction_Check(obj)) {
3579 void* args[2] = {NULL, (void*)&event0};
3580 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3581 if (result) { Py_DECREF(result); }
3582 Py_DECREF(obj);
3583 return;
3584 } else {
3585 PyErr_Clear();
3586 }
3587 }
3588 QHexSpinBox::showEvent(event0);
3589 }
3590 void PythonQtShell_QHexSpinBox::stepBy(int steps0)
3591 {
3592 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3593 static PyObject* name = PyString_FromString("stepBy");
3594 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3595 if (obj) {
3309 3596 static const char* argumentList[] ={"" , "int"};
3310 3597 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3311 void* args[2] = {NULL, (void*)&steps};
3312 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3313 if (result) { Py_DECREF(result); }
3314 Py_DECREF(obj);
3315 return;
3316 }
3317 }
3318 QHexSpinBox::stepBy(steps);
3598 void* args[2] = {NULL, (void*)&steps0};
3599 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3600 if (result) { Py_DECREF(result); }
3601 Py_DECREF(obj);
3602 return;
3603 } else {
3604 PyErr_Clear();
3605 }
3606 }
3607 QHexSpinBox::stepBy(steps0);
3319 3608 }
3320 3609 QAbstractSpinBox::StepEnabled PythonQtShell_QHexSpinBox::stepEnabled() const
3321 3610 {
3322 if (_wrapper) {
3323 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepEnabled");
3324 PyErr_Clear();
3325 if (obj && !PythonQtSlotFunction_Check(obj)) {
3611 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3612 static PyObject* name = PyString_FromString("stepEnabled");
3613 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3614 if (obj) {
3326 3615 static const char* argumentList[] ={"QAbstractSpinBox::StepEnabled"};
3327 3616 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3328 3617 QAbstractSpinBox::StepEnabled returnValue;
@@ -3341,16 +3630,18 if (_wrapper) {
3341 3630 if (result) { Py_DECREF(result); }
3342 3631 Py_DECREF(obj);
3343 3632 return returnValue;
3633 } else {
3634 PyErr_Clear();
3344 3635 }
3345 3636 }
3346 3637 return QHexSpinBox::stepEnabled();
3347 3638 }
3348 3639 void PythonQtShell_QHexSpinBox::tabletEvent(QTabletEvent* arg__1)
3349 3640 {
3350 if (_wrapper) {
3351 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
3352 PyErr_Clear();
3353 if (obj && !PythonQtSlotFunction_Check(obj)) {
3641 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3642 static PyObject* name = PyString_FromString("tabletEvent");
3643 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3644 if (obj) {
3354 3645 static const char* argumentList[] ={"" , "QTabletEvent*"};
3355 3646 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3356 3647 void* args[2] = {NULL, (void*)&arg__1};
@@ -3358,20 +3649,22 if (_wrapper) {
3358 3649 if (result) { Py_DECREF(result); }
3359 3650 Py_DECREF(obj);
3360 3651 return;
3652 } else {
3653 PyErr_Clear();
3361 3654 }
3362 3655 }
3363 3656 QHexSpinBox::tabletEvent(arg__1);
3364 3657 }
3365 QString PythonQtShell_QHexSpinBox::textFromValue(int value) const
3366 {
3367 if (_wrapper) {
3368 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "textFromValue");
3369 PyErr_Clear();
3370 if (obj && !PythonQtSlotFunction_Check(obj)) {
3658 QString PythonQtShell_QHexSpinBox::textFromValue(int value0) const
3659 {
3660 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3661 static PyObject* name = PyString_FromString("textFromValue");
3662 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3663 if (obj) {
3371 3664 static const char* argumentList[] ={"QString" , "int"};
3372 3665 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3373 3666 QString returnValue;
3374 void* args[2] = {NULL, (void*)&value};
3667 void* args[2] = {NULL, (void*)&value0};
3375 3668 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3376 3669 if (result) {
3377 3670 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -3386,37 +3679,41 if (_wrapper) {
3386 3679 if (result) { Py_DECREF(result); }
3387 3680 Py_DECREF(obj);
3388 3681 return returnValue;
3389 }
3390 }
3391 return QHexSpinBox::textFromValue(value);
3392 }
3393 void PythonQtShell_QHexSpinBox::timerEvent(QTimerEvent* event)
3394 {
3395 if (_wrapper) {
3396 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
3397 PyErr_Clear();
3398 if (obj && !PythonQtSlotFunction_Check(obj)) {
3682 } else {
3683 PyErr_Clear();
3684 }
3685 }
3686 return QHexSpinBox::textFromValue(value0);
3687 }
3688 void PythonQtShell_QHexSpinBox::timerEvent(QTimerEvent* event0)
3689 {
3690 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3691 static PyObject* name = PyString_FromString("timerEvent");
3692 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3693 if (obj) {
3399 3694 static const char* argumentList[] ={"" , "QTimerEvent*"};
3400 3695 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3401 void* args[2] = {NULL, (void*)&event};
3402 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3403 if (result) { Py_DECREF(result); }
3404 Py_DECREF(obj);
3405 return;
3406 }
3407 }
3408 QHexSpinBox::timerEvent(event);
3409 }
3410 QValidator::State PythonQtShell_QHexSpinBox::validate(QString& input, int& pos) const
3411 {
3412 if (_wrapper) {
3413 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "validate");
3414 PyErr_Clear();
3415 if (obj && !PythonQtSlotFunction_Check(obj)) {
3696 void* args[2] = {NULL, (void*)&event0};
3697 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3698 if (result) { Py_DECREF(result); }
3699 Py_DECREF(obj);
3700 return;
3701 } else {
3702 PyErr_Clear();
3703 }
3704 }
3705 QHexSpinBox::timerEvent(event0);
3706 }
3707 QValidator::State PythonQtShell_QHexSpinBox::validate(QString& input0, int& pos1) const
3708 {
3709 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3710 static PyObject* name = PyString_FromString("validate");
3711 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3712 if (obj) {
3416 3713 static const char* argumentList[] ={"QValidator::State" , "QString&" , "int&"};
3417 3714 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3418 3715 QValidator::State returnValue;
3419 void* args[3] = {NULL, (void*)&input, (void*)&pos};
3716 void* args[3] = {NULL, (void*)&input0, (void*)&pos1};
3420 3717 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3421 3718 if (result) {
3422 3719 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -3431,20 +3728,22 if (_wrapper) {
3431 3728 if (result) { Py_DECREF(result); }
3432 3729 Py_DECREF(obj);
3433 3730 return returnValue;
3434 }
3435 }
3436 return QHexSpinBox::validate(input, pos);
3437 }
3438 int PythonQtShell_QHexSpinBox::valueFromText(const QString& text) const
3439 {
3440 if (_wrapper) {
3441 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "valueFromText");
3442 PyErr_Clear();
3443 if (obj && !PythonQtSlotFunction_Check(obj)) {
3731 } else {
3732 PyErr_Clear();
3733 }
3734 }
3735 return QHexSpinBox::validate(input0, pos1);
3736 }
3737 int PythonQtShell_QHexSpinBox::valueFromText(const QString& text0) const
3738 {
3739 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3740 static PyObject* name = PyString_FromString("valueFromText");
3741 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3742 if (obj) {
3444 3743 static const char* argumentList[] ={"int" , "const QString&"};
3445 3744 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3446 3745 int returnValue;
3447 void* args[2] = {NULL, (void*)&text};
3746 void* args[2] = {NULL, (void*)&text0};
3448 3747 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3449 3748 if (result) {
3450 3749 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -3459,26 +3758,30 if (_wrapper) {
3459 3758 if (result) { Py_DECREF(result); }
3460 3759 Py_DECREF(obj);
3461 3760 return returnValue;
3462 }
3463 }
3464 return QHexSpinBox::valueFromText(text);
3465 }
3466 void PythonQtShell_QHexSpinBox::wheelEvent(QWheelEvent* event)
3467 {
3468 if (_wrapper) {
3469 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
3470 PyErr_Clear();
3471 if (obj && !PythonQtSlotFunction_Check(obj)) {
3761 } else {
3762 PyErr_Clear();
3763 }
3764 }
3765 return QHexSpinBox::valueFromText(text0);
3766 }
3767 void PythonQtShell_QHexSpinBox::wheelEvent(QWheelEvent* event0)
3768 {
3769 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3770 static PyObject* name = PyString_FromString("wheelEvent");
3771 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3772 if (obj) {
3472 3773 static const char* argumentList[] ={"" , "QWheelEvent*"};
3473 3774 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3474 void* args[2] = {NULL, (void*)&event};
3475 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3476 if (result) { Py_DECREF(result); }
3477 Py_DECREF(obj);
3478 return;
3479 }
3480 }
3481 QHexSpinBox::wheelEvent(event);
3775 void* args[2] = {NULL, (void*)&event0};
3776 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3777 if (result) { Py_DECREF(result); }
3778 Py_DECREF(obj);
3779 return;
3780 } else {
3781 PyErr_Clear();
3782 }
3783 }
3784 QHexSpinBox::wheelEvent(event0);
3482 3785 }
3483 3786 QHexSpinBox* PythonQtWrapper_QHexSpinBox::new_QHexSpinBox(QWidget* parent)
3484 3787 {
@@ -3512,10 +3815,10 PythonQtShell_SocExplorerPlot::~PythonQt
3512 3815 }
3513 3816 void PythonQtShell_SocExplorerPlot::actionEvent(QActionEvent* arg__1)
3514 3817 {
3515 if (_wrapper) {
3516 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
3517 PyErr_Clear();
3518 if (obj && !PythonQtSlotFunction_Check(obj)) {
3818 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3819 static PyObject* name = PyString_FromString("actionEvent");
3820 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3821 if (obj) {
3519 3822 static const char* argumentList[] ={"" , "QActionEvent*"};
3520 3823 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3521 3824 void* args[2] = {NULL, (void*)&arg__1};
@@ -3523,16 +3826,18 if (_wrapper) {
3523 3826 if (result) { Py_DECREF(result); }
3524 3827 Py_DECREF(obj);
3525 3828 return;
3829 } else {
3830 PyErr_Clear();
3526 3831 }
3527 3832 }
3528 3833 SocExplorerPlot::actionEvent(arg__1);
3529 3834 }
3530 3835 void PythonQtShell_SocExplorerPlot::changeEvent(QEvent* arg__1)
3531 3836 {
3532 if (_wrapper) {
3533 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
3534 PyErr_Clear();
3535 if (obj && !PythonQtSlotFunction_Check(obj)) {
3837 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3838 static PyObject* name = PyString_FromString("changeEvent");
3839 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3840 if (obj) {
3536 3841 static const char* argumentList[] ={"" , "QEvent*"};
3537 3842 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3538 3843 void* args[2] = {NULL, (void*)&arg__1};
@@ -3540,16 +3845,18 if (_wrapper) {
3540 3845 if (result) { Py_DECREF(result); }
3541 3846 Py_DECREF(obj);
3542 3847 return;
3848 } else {
3849 PyErr_Clear();
3543 3850 }
3544 3851 }
3545 3852 SocExplorerPlot::changeEvent(arg__1);
3546 3853 }
3547 3854 void PythonQtShell_SocExplorerPlot::childEvent(QChildEvent* arg__1)
3548 3855 {
3549 if (_wrapper) {
3550 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
3551 PyErr_Clear();
3552 if (obj && !PythonQtSlotFunction_Check(obj)) {
3856 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3857 static PyObject* name = PyString_FromString("childEvent");
3858 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3859 if (obj) {
3553 3860 static const char* argumentList[] ={"" , "QChildEvent*"};
3554 3861 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3555 3862 void* args[2] = {NULL, (void*)&arg__1};
@@ -3557,16 +3864,18 if (_wrapper) {
3557 3864 if (result) { Py_DECREF(result); }
3558 3865 Py_DECREF(obj);
3559 3866 return;
3867 } else {
3868 PyErr_Clear();
3560 3869 }
3561 3870 }
3562 3871 SocExplorerPlot::childEvent(arg__1);
3563 3872 }
3564 3873 void PythonQtShell_SocExplorerPlot::closeEvent(QCloseEvent* arg__1)
3565 3874 {
3566 if (_wrapper) {
3567 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
3568 PyErr_Clear();
3569 if (obj && !PythonQtSlotFunction_Check(obj)) {
3875 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3876 static PyObject* name = PyString_FromString("closeEvent");
3877 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3878 if (obj) {
3570 3879 static const char* argumentList[] ={"" , "QCloseEvent*"};
3571 3880 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3572 3881 void* args[2] = {NULL, (void*)&arg__1};
@@ -3574,16 +3883,18 if (_wrapper) {
3574 3883 if (result) { Py_DECREF(result); }
3575 3884 Py_DECREF(obj);
3576 3885 return;
3886 } else {
3887 PyErr_Clear();
3577 3888 }
3578 3889 }
3579 3890 SocExplorerPlot::closeEvent(arg__1);
3580 3891 }
3581 3892 void PythonQtShell_SocExplorerPlot::contextMenuEvent(QContextMenuEvent* arg__1)
3582 3893 {
3583 if (_wrapper) {
3584 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
3585 PyErr_Clear();
3586 if (obj && !PythonQtSlotFunction_Check(obj)) {
3894 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3895 static PyObject* name = PyString_FromString("contextMenuEvent");
3896 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3897 if (obj) {
3587 3898 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
3588 3899 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3589 3900 void* args[2] = {NULL, (void*)&arg__1};
@@ -3591,16 +3902,18 if (_wrapper) {
3591 3902 if (result) { Py_DECREF(result); }
3592 3903 Py_DECREF(obj);
3593 3904 return;
3905 } else {
3906 PyErr_Clear();
3594 3907 }
3595 3908 }
3596 3909 SocExplorerPlot::contextMenuEvent(arg__1);
3597 3910 }
3598 3911 void PythonQtShell_SocExplorerPlot::customEvent(QEvent* arg__1)
3599 3912 {
3600 if (_wrapper) {
3601 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
3602 PyErr_Clear();
3603 if (obj && !PythonQtSlotFunction_Check(obj)) {
3913 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3914 static PyObject* name = PyString_FromString("customEvent");
3915 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3916 if (obj) {
3604 3917 static const char* argumentList[] ={"" , "QEvent*"};
3605 3918 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3606 3919 void* args[2] = {NULL, (void*)&arg__1};
@@ -3608,16 +3921,18 if (_wrapper) {
3608 3921 if (result) { Py_DECREF(result); }
3609 3922 Py_DECREF(obj);
3610 3923 return;
3924 } else {
3925 PyErr_Clear();
3611 3926 }
3612 3927 }
3613 3928 SocExplorerPlot::customEvent(arg__1);
3614 3929 }
3615 3930 int PythonQtShell_SocExplorerPlot::devType() const
3616 3931 {
3617 if (_wrapper) {
3618 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
3619 PyErr_Clear();
3620 if (obj && !PythonQtSlotFunction_Check(obj)) {
3932 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3933 static PyObject* name = PyString_FromString("devType");
3934 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3935 if (obj) {
3621 3936 static const char* argumentList[] ={"int"};
3622 3937 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3623 3938 int returnValue;
@@ -3636,16 +3951,18 if (_wrapper) {
3636 3951 if (result) { Py_DECREF(result); }
3637 3952 Py_DECREF(obj);
3638 3953 return returnValue;
3954 } else {
3955 PyErr_Clear();
3639 3956 }
3640 3957 }
3641 3958 return SocExplorerPlot::devType();
3642 3959 }
3643 3960 void PythonQtShell_SocExplorerPlot::dragEnterEvent(QDragEnterEvent* arg__1)
3644 3961 {
3645 if (_wrapper) {
3646 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
3647 PyErr_Clear();
3648 if (obj && !PythonQtSlotFunction_Check(obj)) {
3962 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3963 static PyObject* name = PyString_FromString("dragEnterEvent");
3964 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3965 if (obj) {
3649 3966 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
3650 3967 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3651 3968 void* args[2] = {NULL, (void*)&arg__1};
@@ -3653,16 +3970,18 if (_wrapper) {
3653 3970 if (result) { Py_DECREF(result); }
3654 3971 Py_DECREF(obj);
3655 3972 return;
3973 } else {
3974 PyErr_Clear();
3656 3975 }
3657 3976 }
3658 3977 SocExplorerPlot::dragEnterEvent(arg__1);
3659 3978 }
3660 3979 void PythonQtShell_SocExplorerPlot::dragLeaveEvent(QDragLeaveEvent* arg__1)
3661 3980 {
3662 if (_wrapper) {
3663 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
3664 PyErr_Clear();
3665 if (obj && !PythonQtSlotFunction_Check(obj)) {
3981 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3982 static PyObject* name = PyString_FromString("dragLeaveEvent");
3983 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3984 if (obj) {
3666 3985 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
3667 3986 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3668 3987 void* args[2] = {NULL, (void*)&arg__1};
@@ -3670,16 +3989,18 if (_wrapper) {
3670 3989 if (result) { Py_DECREF(result); }
3671 3990 Py_DECREF(obj);
3672 3991 return;
3992 } else {
3993 PyErr_Clear();
3673 3994 }
3674 3995 }
3675 3996 SocExplorerPlot::dragLeaveEvent(arg__1);
3676 3997 }
3677 3998 void PythonQtShell_SocExplorerPlot::dragMoveEvent(QDragMoveEvent* arg__1)
3678 3999 {
3679 if (_wrapper) {
3680 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
3681 PyErr_Clear();
3682 if (obj && !PythonQtSlotFunction_Check(obj)) {
4000 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4001 static PyObject* name = PyString_FromString("dragMoveEvent");
4002 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4003 if (obj) {
3683 4004 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
3684 4005 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3685 4006 void* args[2] = {NULL, (void*)&arg__1};
@@ -3687,16 +4008,18 if (_wrapper) {
3687 4008 if (result) { Py_DECREF(result); }
3688 4009 Py_DECREF(obj);
3689 4010 return;
4011 } else {
4012 PyErr_Clear();
3690 4013 }
3691 4014 }
3692 4015 SocExplorerPlot::dragMoveEvent(arg__1);
3693 4016 }
3694 4017 void PythonQtShell_SocExplorerPlot::dropEvent(QDropEvent* arg__1)
3695 4018 {
3696 if (_wrapper) {
3697 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
3698 PyErr_Clear();
3699 if (obj && !PythonQtSlotFunction_Check(obj)) {
4019 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4020 static PyObject* name = PyString_FromString("dropEvent");
4021 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4022 if (obj) {
3700 4023 static const char* argumentList[] ={"" , "QDropEvent*"};
3701 4024 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3702 4025 void* args[2] = {NULL, (void*)&arg__1};
@@ -3704,16 +4027,18 if (_wrapper) {
3704 4027 if (result) { Py_DECREF(result); }
3705 4028 Py_DECREF(obj);
3706 4029 return;
4030 } else {
4031 PyErr_Clear();
3707 4032 }
3708 4033 }
3709 4034 SocExplorerPlot::dropEvent(arg__1);
3710 4035 }
3711 4036 void PythonQtShell_SocExplorerPlot::enterEvent(QEvent* arg__1)
3712 4037 {
3713 if (_wrapper) {
3714 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
3715 PyErr_Clear();
3716 if (obj && !PythonQtSlotFunction_Check(obj)) {
4038 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4039 static PyObject* name = PyString_FromString("enterEvent");
4040 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4041 if (obj) {
3717 4042 static const char* argumentList[] ={"" , "QEvent*"};
3718 4043 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3719 4044 void* args[2] = {NULL, (void*)&arg__1};
@@ -3721,16 +4046,18 if (_wrapper) {
3721 4046 if (result) { Py_DECREF(result); }
3722 4047 Py_DECREF(obj);
3723 4048 return;
4049 } else {
4050 PyErr_Clear();
3724 4051 }
3725 4052 }
3726 4053 SocExplorerPlot::enterEvent(arg__1);
3727 4054 }
3728 4055 bool PythonQtShell_SocExplorerPlot::event(QEvent* arg__1)
3729 4056 {
3730 if (_wrapper) {
3731 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
3732 PyErr_Clear();
3733 if (obj && !PythonQtSlotFunction_Check(obj)) {
4057 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4058 static PyObject* name = PyString_FromString("event");
4059 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4060 if (obj) {
3734 4061 static const char* argumentList[] ={"bool" , "QEvent*"};
3735 4062 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3736 4063 bool returnValue;
@@ -3749,16 +4076,18 if (_wrapper) {
3749 4076 if (result) { Py_DECREF(result); }
3750 4077 Py_DECREF(obj);
3751 4078 return returnValue;
4079 } else {
4080 PyErr_Clear();
3752 4081 }
3753 4082 }
3754 4083 return SocExplorerPlot::event(arg__1);
3755 4084 }
3756 4085 bool PythonQtShell_SocExplorerPlot::eventFilter(QObject* arg__1, QEvent* arg__2)
3757 4086 {
3758 if (_wrapper) {
3759 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
3760 PyErr_Clear();
3761 if (obj && !PythonQtSlotFunction_Check(obj)) {
4087 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4088 static PyObject* name = PyString_FromString("eventFilter");
4089 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4090 if (obj) {
3762 4091 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
3763 4092 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3764 4093 bool returnValue;
@@ -3777,16 +4106,18 if (_wrapper) {
3777 4106 if (result) { Py_DECREF(result); }
3778 4107 Py_DECREF(obj);
3779 4108 return returnValue;
4109 } else {
4110 PyErr_Clear();
3780 4111 }
3781 4112 }
3782 4113 return SocExplorerPlot::eventFilter(arg__1, arg__2);
3783 4114 }
3784 4115 void PythonQtShell_SocExplorerPlot::focusInEvent(QFocusEvent* arg__1)
3785 4116 {
3786 if (_wrapper) {
3787 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
3788 PyErr_Clear();
3789 if (obj && !PythonQtSlotFunction_Check(obj)) {
4117 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4118 static PyObject* name = PyString_FromString("focusInEvent");
4119 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4120 if (obj) {
3790 4121 static const char* argumentList[] ={"" , "QFocusEvent*"};
3791 4122 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3792 4123 void* args[2] = {NULL, (void*)&arg__1};
@@ -3794,20 +4125,22 if (_wrapper) {
3794 4125 if (result) { Py_DECREF(result); }
3795 4126 Py_DECREF(obj);
3796 4127 return;
4128 } else {
4129 PyErr_Clear();
3797 4130 }
3798 4131 }
3799 4132 SocExplorerPlot::focusInEvent(arg__1);
3800 4133 }
3801 bool PythonQtShell_SocExplorerPlot::focusNextPrevChild(bool next)
3802 {
3803 if (_wrapper) {
3804 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
3805 PyErr_Clear();
3806 if (obj && !PythonQtSlotFunction_Check(obj)) {
4134 bool PythonQtShell_SocExplorerPlot::focusNextPrevChild(bool next0)
4135 {
4136 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4137 static PyObject* name = PyString_FromString("focusNextPrevChild");
4138 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4139 if (obj) {
3807 4140 static const char* argumentList[] ={"bool" , "bool"};
3808 4141 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3809 4142 bool returnValue;
3810 void* args[2] = {NULL, (void*)&next};
4143 void* args[2] = {NULL, (void*)&next0};
3811 4144 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3812 4145 if (result) {
3813 4146 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -3822,16 +4155,18 if (_wrapper) {
3822 4155 if (result) { Py_DECREF(result); }
3823 4156 Py_DECREF(obj);
3824 4157 return returnValue;
3825 }
3826 }
3827 return SocExplorerPlot::focusNextPrevChild(next);
4158 } else {
4159 PyErr_Clear();
4160 }
4161 }
4162 return SocExplorerPlot::focusNextPrevChild(next0);
3828 4163 }
3829 4164 void PythonQtShell_SocExplorerPlot::focusOutEvent(QFocusEvent* arg__1)
3830 4165 {
3831 if (_wrapper) {
3832 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
3833 PyErr_Clear();
3834 if (obj && !PythonQtSlotFunction_Check(obj)) {
4166 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4167 static PyObject* name = PyString_FromString("focusOutEvent");
4168 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4169 if (obj) {
3835 4170 static const char* argumentList[] ={"" , "QFocusEvent*"};
3836 4171 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3837 4172 void* args[2] = {NULL, (void*)&arg__1};
@@ -3839,16 +4174,18 if (_wrapper) {
3839 4174 if (result) { Py_DECREF(result); }
3840 4175 Py_DECREF(obj);
3841 4176 return;
4177 } else {
4178 PyErr_Clear();
3842 4179 }
3843 4180 }
3844 4181 SocExplorerPlot::focusOutEvent(arg__1);
3845 4182 }
3846 4183 bool PythonQtShell_SocExplorerPlot::hasHeightForWidth() const
3847 4184 {
3848 if (_wrapper) {
3849 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
3850 PyErr_Clear();
3851 if (obj && !PythonQtSlotFunction_Check(obj)) {
4185 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4186 static PyObject* name = PyString_FromString("hasHeightForWidth");
4187 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4188 if (obj) {
3852 4189 static const char* argumentList[] ={"bool"};
3853 4190 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3854 4191 bool returnValue;
@@ -3867,16 +4204,18 if (_wrapper) {
3867 4204 if (result) { Py_DECREF(result); }
3868 4205 Py_DECREF(obj);
3869 4206 return returnValue;
4207 } else {
4208 PyErr_Clear();
3870 4209 }
3871 4210 }
3872 4211 return SocExplorerPlot::hasHeightForWidth();
3873 4212 }
3874 4213 int PythonQtShell_SocExplorerPlot::heightForWidth(int arg__1) const
3875 4214 {
3876 if (_wrapper) {
3877 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
3878 PyErr_Clear();
3879 if (obj && !PythonQtSlotFunction_Check(obj)) {
4215 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4216 static PyObject* name = PyString_FromString("heightForWidth");
4217 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4218 if (obj) {
3880 4219 static const char* argumentList[] ={"int" , "int"};
3881 4220 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3882 4221 int returnValue;
@@ -3895,16 +4234,18 if (_wrapper) {
3895 4234 if (result) { Py_DECREF(result); }
3896 4235 Py_DECREF(obj);
3897 4236 return returnValue;
4237 } else {
4238 PyErr_Clear();
3898 4239 }
3899 4240 }
3900 4241 return SocExplorerPlot::heightForWidth(arg__1);
3901 4242 }
3902 4243 void PythonQtShell_SocExplorerPlot::hideEvent(QHideEvent* arg__1)
3903 4244 {
3904 if (_wrapper) {
3905 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
3906 PyErr_Clear();
3907 if (obj && !PythonQtSlotFunction_Check(obj)) {
4245 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4246 static PyObject* name = PyString_FromString("hideEvent");
4247 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4248 if (obj) {
3908 4249 static const char* argumentList[] ={"" , "QHideEvent*"};
3909 4250 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3910 4251 void* args[2] = {NULL, (void*)&arg__1};
@@ -3912,33 +4253,37 if (_wrapper) {
3912 4253 if (result) { Py_DECREF(result); }
3913 4254 Py_DECREF(obj);
3914 4255 return;
4256 } else {
4257 PyErr_Clear();
3915 4258 }
3916 4259 }
3917 4260 SocExplorerPlot::hideEvent(arg__1);
3918 4261 }
3919 void PythonQtShell_SocExplorerPlot::initPainter(QPainter* painter) const
3920 {
3921 if (_wrapper) {
3922 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
3923 PyErr_Clear();
3924 if (obj && !PythonQtSlotFunction_Check(obj)) {
4262 void PythonQtShell_SocExplorerPlot::initPainter(QPainter* painter0) const
4263 {
4264 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4265 static PyObject* name = PyString_FromString("initPainter");
4266 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4267 if (obj) {
3925 4268 static const char* argumentList[] ={"" , "QPainter*"};
3926 4269 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3927 void* args[2] = {NULL, (void*)&painter};
3928 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3929 if (result) { Py_DECREF(result); }
3930 Py_DECREF(obj);
3931 return;
3932 }
3933 }
3934 SocExplorerPlot::initPainter(painter);
4270 void* args[2] = {NULL, (void*)&painter0};
4271 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4272 if (result) { Py_DECREF(result); }
4273 Py_DECREF(obj);
4274 return;
4275 } else {
4276 PyErr_Clear();
4277 }
4278 }
4279 SocExplorerPlot::initPainter(painter0);
3935 4280 }
3936 4281 void PythonQtShell_SocExplorerPlot::inputMethodEvent(QInputMethodEvent* arg__1)
3937 4282 {
3938 if (_wrapper) {
3939 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
3940 PyErr_Clear();
3941 if (obj && !PythonQtSlotFunction_Check(obj)) {
4283 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4284 static PyObject* name = PyString_FromString("inputMethodEvent");
4285 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4286 if (obj) {
3942 4287 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
3943 4288 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3944 4289 void* args[2] = {NULL, (void*)&arg__1};
@@ -3946,16 +4291,18 if (_wrapper) {
3946 4291 if (result) { Py_DECREF(result); }
3947 4292 Py_DECREF(obj);
3948 4293 return;
4294 } else {
4295 PyErr_Clear();
3949 4296 }
3950 4297 }
3951 4298 SocExplorerPlot::inputMethodEvent(arg__1);
3952 4299 }
3953 4300 QVariant PythonQtShell_SocExplorerPlot::inputMethodQuery(Qt::InputMethodQuery arg__1) const
3954 4301 {
3955 if (_wrapper) {
3956 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
3957 PyErr_Clear();
3958 if (obj && !PythonQtSlotFunction_Check(obj)) {
4302 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4303 static PyObject* name = PyString_FromString("inputMethodQuery");
4304 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4305 if (obj) {
3959 4306 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
3960 4307 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3961 4308 QVariant returnValue;
@@ -3974,16 +4321,18 if (_wrapper) {
3974 4321 if (result) { Py_DECREF(result); }
3975 4322 Py_DECREF(obj);
3976 4323 return returnValue;
4324 } else {
4325 PyErr_Clear();
3977 4326 }
3978 4327 }
3979 4328 return SocExplorerPlot::inputMethodQuery(arg__1);
3980 4329 }
3981 4330 void PythonQtShell_SocExplorerPlot::keyPressEvent(QKeyEvent* arg__1)
3982 4331 {
3983 if (_wrapper) {
3984 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
3985 PyErr_Clear();
3986 if (obj && !PythonQtSlotFunction_Check(obj)) {
4332 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4333 static PyObject* name = PyString_FromString("keyPressEvent");
4334 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4335 if (obj) {
3987 4336 static const char* argumentList[] ={"" , "QKeyEvent*"};
3988 4337 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3989 4338 void* args[2] = {NULL, (void*)&arg__1};
@@ -3991,16 +4340,18 if (_wrapper) {
3991 4340 if (result) { Py_DECREF(result); }
3992 4341 Py_DECREF(obj);
3993 4342 return;
4343 } else {
4344 PyErr_Clear();
3994 4345 }
3995 4346 }
3996 4347 SocExplorerPlot::keyPressEvent(arg__1);
3997 4348 }
3998 4349 void PythonQtShell_SocExplorerPlot::keyReleaseEvent(QKeyEvent* arg__1)
3999 4350 {
4000 if (_wrapper) {
4001 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
4002 PyErr_Clear();
4003 if (obj && !PythonQtSlotFunction_Check(obj)) {
4351 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4352 static PyObject* name = PyString_FromString("keyReleaseEvent");
4353 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4354 if (obj) {
4004 4355 static const char* argumentList[] ={"" , "QKeyEvent*"};
4005 4356 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4006 4357 void* args[2] = {NULL, (void*)&arg__1};
@@ -4008,16 +4359,18 if (_wrapper) {
4008 4359 if (result) { Py_DECREF(result); }
4009 4360 Py_DECREF(obj);
4010 4361 return;
4362 } else {
4363 PyErr_Clear();
4011 4364 }
4012 4365 }
4013 4366 SocExplorerPlot::keyReleaseEvent(arg__1);
4014 4367 }
4015 4368 void PythonQtShell_SocExplorerPlot::leaveEvent(QEvent* arg__1)
4016 4369 {
4017 if (_wrapper) {
4018 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
4019 PyErr_Clear();
4020 if (obj && !PythonQtSlotFunction_Check(obj)) {
4370 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4371 static PyObject* name = PyString_FromString("leaveEvent");
4372 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4373 if (obj) {
4021 4374 static const char* argumentList[] ={"" , "QEvent*"};
4022 4375 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4023 4376 void* args[2] = {NULL, (void*)&arg__1};
@@ -4025,16 +4378,18 if (_wrapper) {
4025 4378 if (result) { Py_DECREF(result); }
4026 4379 Py_DECREF(obj);
4027 4380 return;
4381 } else {
4382 PyErr_Clear();
4028 4383 }
4029 4384 }
4030 4385 SocExplorerPlot::leaveEvent(arg__1);
4031 4386 }
4032 4387 int PythonQtShell_SocExplorerPlot::metric(QPaintDevice::PaintDeviceMetric arg__1) const
4033 4388 {
4034 if (_wrapper) {
4035 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
4036 PyErr_Clear();
4037 if (obj && !PythonQtSlotFunction_Check(obj)) {
4389 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4390 static PyObject* name = PyString_FromString("metric");
4391 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4392 if (obj) {
4038 4393 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
4039 4394 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4040 4395 int returnValue;
@@ -4053,16 +4408,18 if (_wrapper) {
4053 4408 if (result) { Py_DECREF(result); }
4054 4409 Py_DECREF(obj);
4055 4410 return returnValue;
4411 } else {
4412 PyErr_Clear();
4056 4413 }
4057 4414 }
4058 4415 return SocExplorerPlot::metric(arg__1);
4059 4416 }
4060 4417 QSize PythonQtShell_SocExplorerPlot::minimumSizeHint() const
4061 4418 {
4062 if (_wrapper) {
4063 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
4064 PyErr_Clear();
4065 if (obj && !PythonQtSlotFunction_Check(obj)) {
4419 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4420 static PyObject* name = PyString_FromString("getMinimumSizeHint");
4421 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4422 if (obj) {
4066 4423 static const char* argumentList[] ={"QSize"};
4067 4424 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4068 4425 QSize returnValue;
@@ -4081,16 +4438,18 if (_wrapper) {
4081 4438 if (result) { Py_DECREF(result); }
4082 4439 Py_DECREF(obj);
4083 4440 return returnValue;
4441 } else {
4442 PyErr_Clear();
4084 4443 }
4085 4444 }
4086 4445 return SocExplorerPlot::minimumSizeHint();
4087 4446 }
4088 4447 void PythonQtShell_SocExplorerPlot::mouseDoubleClickEvent(QMouseEvent* arg__1)
4089 4448 {
4090 if (_wrapper) {
4091 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
4092 PyErr_Clear();
4093 if (obj && !PythonQtSlotFunction_Check(obj)) {
4449 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4450 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
4451 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4452 if (obj) {
4094 4453 static const char* argumentList[] ={"" , "QMouseEvent*"};
4095 4454 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4096 4455 void* args[2] = {NULL, (void*)&arg__1};
@@ -4098,16 +4457,18 if (_wrapper) {
4098 4457 if (result) { Py_DECREF(result); }
4099 4458 Py_DECREF(obj);
4100 4459 return;
4460 } else {
4461 PyErr_Clear();
4101 4462 }
4102 4463 }
4103 4464 SocExplorerPlot::mouseDoubleClickEvent(arg__1);
4104 4465 }
4105 4466 void PythonQtShell_SocExplorerPlot::mouseMoveEvent(QMouseEvent* arg__1)
4106 4467 {
4107 if (_wrapper) {
4108 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
4109 PyErr_Clear();
4110 if (obj && !PythonQtSlotFunction_Check(obj)) {
4468 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4469 static PyObject* name = PyString_FromString("mouseMoveEvent");
4470 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4471 if (obj) {
4111 4472 static const char* argumentList[] ={"" , "QMouseEvent*"};
4112 4473 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4113 4474 void* args[2] = {NULL, (void*)&arg__1};
@@ -4115,16 +4476,18 if (_wrapper) {
4115 4476 if (result) { Py_DECREF(result); }
4116 4477 Py_DECREF(obj);
4117 4478 return;
4479 } else {
4480 PyErr_Clear();
4118 4481 }
4119 4482 }
4120 4483 SocExplorerPlot::mouseMoveEvent(arg__1);
4121 4484 }
4122 4485 void PythonQtShell_SocExplorerPlot::mousePressEvent(QMouseEvent* arg__1)
4123 4486 {
4124 if (_wrapper) {
4125 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
4126 PyErr_Clear();
4127 if (obj && !PythonQtSlotFunction_Check(obj)) {
4487 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4488 static PyObject* name = PyString_FromString("mousePressEvent");
4489 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4490 if (obj) {
4128 4491 static const char* argumentList[] ={"" , "QMouseEvent*"};
4129 4492 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4130 4493 void* args[2] = {NULL, (void*)&arg__1};
@@ -4132,16 +4495,18 if (_wrapper) {
4132 4495 if (result) { Py_DECREF(result); }
4133 4496 Py_DECREF(obj);
4134 4497 return;
4498 } else {
4499 PyErr_Clear();
4135 4500 }
4136 4501 }
4137 4502 SocExplorerPlot::mousePressEvent(arg__1);
4138 4503 }
4139 4504 void PythonQtShell_SocExplorerPlot::mouseReleaseEvent(QMouseEvent* arg__1)
4140 4505 {
4141 if (_wrapper) {
4142 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
4143 PyErr_Clear();
4144 if (obj && !PythonQtSlotFunction_Check(obj)) {
4506 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4507 static PyObject* name = PyString_FromString("mouseReleaseEvent");
4508 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4509 if (obj) {
4145 4510 static const char* argumentList[] ={"" , "QMouseEvent*"};
4146 4511 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4147 4512 void* args[2] = {NULL, (void*)&arg__1};
@@ -4149,16 +4514,18 if (_wrapper) {
4149 4514 if (result) { Py_DECREF(result); }
4150 4515 Py_DECREF(obj);
4151 4516 return;
4517 } else {
4518 PyErr_Clear();
4152 4519 }
4153 4520 }
4154 4521 SocExplorerPlot::mouseReleaseEvent(arg__1);
4155 4522 }
4156 4523 void PythonQtShell_SocExplorerPlot::moveEvent(QMoveEvent* arg__1)
4157 4524 {
4158 if (_wrapper) {
4159 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
4160 PyErr_Clear();
4161 if (obj && !PythonQtSlotFunction_Check(obj)) {
4525 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4526 static PyObject* name = PyString_FromString("moveEvent");
4527 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4528 if (obj) {
4162 4529 static const char* argumentList[] ={"" , "QMoveEvent*"};
4163 4530 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4164 4531 void* args[2] = {NULL, (void*)&arg__1};
@@ -4166,20 +4533,22 if (_wrapper) {
4166 4533 if (result) { Py_DECREF(result); }
4167 4534 Py_DECREF(obj);
4168 4535 return;
4536 } else {
4537 PyErr_Clear();
4169 4538 }
4170 4539 }
4171 4540 SocExplorerPlot::moveEvent(arg__1);
4172 4541 }
4173 bool PythonQtShell_SocExplorerPlot::nativeEvent(const QByteArray& eventType, void* message, long* result)
4174 {
4175 if (_wrapper) {
4176 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
4177 PyErr_Clear();
4178 if (obj && !PythonQtSlotFunction_Check(obj)) {
4542 bool PythonQtShell_SocExplorerPlot::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
4543 {
4544 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4545 static PyObject* name = PyString_FromString("nativeEvent");
4546 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4547 if (obj) {
4179 4548 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
4180 4549 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
4181 4550 bool returnValue;
4182 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
4551 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
4183 4552 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4184 4553 if (result) {
4185 4554 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -4194,16 +4563,18 if (_wrapper) {
4194 4563 if (result) { Py_DECREF(result); }
4195 4564 Py_DECREF(obj);
4196 4565 return returnValue;
4197 }
4198 }
4199 return SocExplorerPlot::nativeEvent(eventType, message, result);
4566 } else {
4567 PyErr_Clear();
4568 }
4569 }
4570 return SocExplorerPlot::nativeEvent(eventType0, message1, result2);
4200 4571 }
4201 4572 QPaintEngine* PythonQtShell_SocExplorerPlot::paintEngine() const
4202 4573 {
4203 if (_wrapper) {
4204 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
4205 PyErr_Clear();
4206 if (obj && !PythonQtSlotFunction_Check(obj)) {
4574 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4575 static PyObject* name = PyString_FromString("paintEngine");
4576 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4577 if (obj) {
4207 4578 static const char* argumentList[] ={"QPaintEngine*"};
4208 4579 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4209 4580 QPaintEngine* returnValue;
@@ -4222,16 +4593,18 if (_wrapper) {
4222 4593 if (result) { Py_DECREF(result); }
4223 4594 Py_DECREF(obj);
4224 4595 return returnValue;
4596 } else {
4597 PyErr_Clear();
4225 4598 }
4226 4599 }
4227 4600 return SocExplorerPlot::paintEngine();
4228 4601 }
4229 4602 void PythonQtShell_SocExplorerPlot::paintEvent(QPaintEvent* arg__1)
4230 4603 {
4231 if (_wrapper) {
4232 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
4233 PyErr_Clear();
4234 if (obj && !PythonQtSlotFunction_Check(obj)) {
4604 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4605 static PyObject* name = PyString_FromString("paintEvent");
4606 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4607 if (obj) {
4235 4608 static const char* argumentList[] ={"" , "QPaintEvent*"};
4236 4609 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4237 4610 void* args[2] = {NULL, (void*)&arg__1};
@@ -4239,20 +4612,22 if (_wrapper) {
4239 4612 if (result) { Py_DECREF(result); }
4240 4613 Py_DECREF(obj);
4241 4614 return;
4615 } else {
4616 PyErr_Clear();
4242 4617 }
4243 4618 }
4244 4619 SocExplorerPlot::paintEvent(arg__1);
4245 4620 }
4246 QPaintDevice* PythonQtShell_SocExplorerPlot::redirected(QPoint* offset) const
4247 {
4248 if (_wrapper) {
4249 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
4250 PyErr_Clear();
4251 if (obj && !PythonQtSlotFunction_Check(obj)) {
4621 QPaintDevice* PythonQtShell_SocExplorerPlot::redirected(QPoint* offset0) const
4622 {
4623 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4624 static PyObject* name = PyString_FromString("redirected");
4625 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4626 if (obj) {
4252 4627 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
4253 4628 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4254 4629 QPaintDevice* returnValue;
4255 void* args[2] = {NULL, (void*)&offset};
4630 void* args[2] = {NULL, (void*)&offset0};
4256 4631 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4257 4632 if (result) {
4258 4633 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -4267,16 +4642,18 if (_wrapper) {
4267 4642 if (result) { Py_DECREF(result); }
4268 4643 Py_DECREF(obj);
4269 4644 return returnValue;
4270 }
4271 }
4272 return SocExplorerPlot::redirected(offset);
4645 } else {
4646 PyErr_Clear();
4647 }
4648 }
4649 return SocExplorerPlot::redirected(offset0);
4273 4650 }
4274 4651 void PythonQtShell_SocExplorerPlot::resizeEvent(QResizeEvent* arg__1)
4275 4652 {
4276 if (_wrapper) {
4277 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
4278 PyErr_Clear();
4279 if (obj && !PythonQtSlotFunction_Check(obj)) {
4653 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4654 static PyObject* name = PyString_FromString("resizeEvent");
4655 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4656 if (obj) {
4280 4657 static const char* argumentList[] ={"" , "QResizeEvent*"};
4281 4658 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4282 4659 void* args[2] = {NULL, (void*)&arg__1};
@@ -4284,16 +4661,18 if (_wrapper) {
4284 4661 if (result) { Py_DECREF(result); }
4285 4662 Py_DECREF(obj);
4286 4663 return;
4664 } else {
4665 PyErr_Clear();
4287 4666 }
4288 4667 }
4289 4668 SocExplorerPlot::resizeEvent(arg__1);
4290 4669 }
4291 4670 QPainter* PythonQtShell_SocExplorerPlot::sharedPainter() const
4292 4671 {
4293 if (_wrapper) {
4294 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
4295 PyErr_Clear();
4296 if (obj && !PythonQtSlotFunction_Check(obj)) {
4672 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4673 static PyObject* name = PyString_FromString("sharedPainter");
4674 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4675 if (obj) {
4297 4676 static const char* argumentList[] ={"QPainter*"};
4298 4677 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4299 4678 QPainter* returnValue;
@@ -4312,16 +4691,18 if (_wrapper) {
4312 4691 if (result) { Py_DECREF(result); }
4313 4692 Py_DECREF(obj);
4314 4693 return returnValue;
4694 } else {
4695 PyErr_Clear();
4315 4696 }
4316 4697 }
4317 4698 return SocExplorerPlot::sharedPainter();
4318 4699 }
4319 4700 void PythonQtShell_SocExplorerPlot::showEvent(QShowEvent* arg__1)
4320 4701 {
4321 if (_wrapper) {
4322 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
4323 PyErr_Clear();
4324 if (obj && !PythonQtSlotFunction_Check(obj)) {
4702 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4703 static PyObject* name = PyString_FromString("showEvent");
4704 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4705 if (obj) {
4325 4706 static const char* argumentList[] ={"" , "QShowEvent*"};
4326 4707 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4327 4708 void* args[2] = {NULL, (void*)&arg__1};
@@ -4329,16 +4710,18 if (_wrapper) {
4329 4710 if (result) { Py_DECREF(result); }
4330 4711 Py_DECREF(obj);
4331 4712 return;
4713 } else {
4714 PyErr_Clear();
4332 4715 }
4333 4716 }
4334 4717 SocExplorerPlot::showEvent(arg__1);
4335 4718 }
4336 4719 QSize PythonQtShell_SocExplorerPlot::sizeHint() const
4337 4720 {
4338 if (_wrapper) {
4339 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
4340 PyErr_Clear();
4341 if (obj && !PythonQtSlotFunction_Check(obj)) {
4721 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4722 static PyObject* name = PyString_FromString("getSizeHint");
4723 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4724 if (obj) {
4342 4725 static const char* argumentList[] ={"QSize"};
4343 4726 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4344 4727 QSize returnValue;
@@ -4357,16 +4740,18 if (_wrapper) {
4357 4740 if (result) { Py_DECREF(result); }
4358 4741 Py_DECREF(obj);
4359 4742 return returnValue;
4743 } else {
4744 PyErr_Clear();
4360 4745 }
4361 4746 }
4362 4747 return SocExplorerPlot::sizeHint();
4363 4748 }
4364 4749 void PythonQtShell_SocExplorerPlot::tabletEvent(QTabletEvent* arg__1)
4365 4750 {
4366 if (_wrapper) {
4367 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
4368 PyErr_Clear();
4369 if (obj && !PythonQtSlotFunction_Check(obj)) {
4751 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4752 static PyObject* name = PyString_FromString("tabletEvent");
4753 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4754 if (obj) {
4370 4755 static const char* argumentList[] ={"" , "QTabletEvent*"};
4371 4756 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4372 4757 void* args[2] = {NULL, (void*)&arg__1};
@@ -4374,16 +4759,18 if (_wrapper) {
4374 4759 if (result) { Py_DECREF(result); }
4375 4760 Py_DECREF(obj);
4376 4761 return;
4762 } else {
4763 PyErr_Clear();
4377 4764 }
4378 4765 }
4379 4766 SocExplorerPlot::tabletEvent(arg__1);
4380 4767 }
4381 4768 void PythonQtShell_SocExplorerPlot::timerEvent(QTimerEvent* arg__1)
4382 4769 {
4383 if (_wrapper) {
4384 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
4385 PyErr_Clear();
4386 if (obj && !PythonQtSlotFunction_Check(obj)) {
4770 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4771 static PyObject* name = PyString_FromString("timerEvent");
4772 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4773 if (obj) {
4387 4774 static const char* argumentList[] ={"" , "QTimerEvent*"};
4388 4775 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4389 4776 void* args[2] = {NULL, (void*)&arg__1};
@@ -4391,16 +4778,18 if (_wrapper) {
4391 4778 if (result) { Py_DECREF(result); }
4392 4779 Py_DECREF(obj);
4393 4780 return;
4781 } else {
4782 PyErr_Clear();
4394 4783 }
4395 4784 }
4396 4785 SocExplorerPlot::timerEvent(arg__1);
4397 4786 }
4398 4787 void PythonQtShell_SocExplorerPlot::wheelEvent(QWheelEvent* arg__1)
4399 4788 {
4400 if (_wrapper) {
4401 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
4402 PyErr_Clear();
4403 if (obj && !PythonQtSlotFunction_Check(obj)) {
4789 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4790 static PyObject* name = PyString_FromString("wheelEvent");
4791 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4792 if (obj) {
4404 4793 static const char* argumentList[] ={"" , "QWheelEvent*"};
4405 4794 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4406 4795 void* args[2] = {NULL, (void*)&arg__1};
@@ -4408,6 +4797,8 if (_wrapper) {
4408 4797 if (result) { Py_DECREF(result); }
4409 4798 Py_DECREF(obj);
4410 4799 return;
4800 } else {
4801 PyErr_Clear();
4411 4802 }
4412 4803 }
4413 4804 SocExplorerPlot::wheelEvent(arg__1);
@@ -4549,10 +4940,10 PythonQtShell_TCP_Terminal_Client::~Pyth
4549 4940 }
4550 4941 void PythonQtShell_TCP_Terminal_Client::childEvent(QChildEvent* arg__1)
4551 4942 {
4552 if (_wrapper) {
4553 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
4554 PyErr_Clear();
4555 if (obj && !PythonQtSlotFunction_Check(obj)) {
4943 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4944 static PyObject* name = PyString_FromString("childEvent");
4945 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4946 if (obj) {
4556 4947 static const char* argumentList[] ={"" , "QChildEvent*"};
4557 4948 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4558 4949 void* args[2] = {NULL, (void*)&arg__1};
@@ -4560,16 +4951,18 if (_wrapper) {
4560 4951 if (result) { Py_DECREF(result); }
4561 4952 Py_DECREF(obj);
4562 4953 return;
4954 } else {
4955 PyErr_Clear();
4563 4956 }
4564 4957 }
4565 4958 TCP_Terminal_Client::childEvent(arg__1);
4566 4959 }
4567 4960 void PythonQtShell_TCP_Terminal_Client::customEvent(QEvent* arg__1)
4568 4961 {
4569 if (_wrapper) {
4570 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
4571 PyErr_Clear();
4572 if (obj && !PythonQtSlotFunction_Check(obj)) {
4962 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4963 static PyObject* name = PyString_FromString("customEvent");
4964 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4965 if (obj) {
4573 4966 static const char* argumentList[] ={"" , "QEvent*"};
4574 4967 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4575 4968 void* args[2] = {NULL, (void*)&arg__1};
@@ -4577,16 +4970,18 if (_wrapper) {
4577 4970 if (result) { Py_DECREF(result); }
4578 4971 Py_DECREF(obj);
4579 4972 return;
4973 } else {
4974 PyErr_Clear();
4580 4975 }
4581 4976 }
4582 4977 TCP_Terminal_Client::customEvent(arg__1);
4583 4978 }
4584 4979 bool PythonQtShell_TCP_Terminal_Client::event(QEvent* arg__1)
4585 4980 {
4586 if (_wrapper) {
4587 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
4588 PyErr_Clear();
4589 if (obj && !PythonQtSlotFunction_Check(obj)) {
4981 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4982 static PyObject* name = PyString_FromString("event");
4983 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4984 if (obj) {
4590 4985 static const char* argumentList[] ={"bool" , "QEvent*"};
4591 4986 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4592 4987 bool returnValue;
@@ -4605,16 +5000,18 if (_wrapper) {
4605 5000 if (result) { Py_DECREF(result); }
4606 5001 Py_DECREF(obj);
4607 5002 return returnValue;
5003 } else {
5004 PyErr_Clear();
4608 5005 }
4609 5006 }
4610 5007 return TCP_Terminal_Client::event(arg__1);
4611 5008 }
4612 5009 bool PythonQtShell_TCP_Terminal_Client::eventFilter(QObject* arg__1, QEvent* arg__2)
4613 5010 {
4614 if (_wrapper) {
4615 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
4616 PyErr_Clear();
4617 if (obj && !PythonQtSlotFunction_Check(obj)) {
5011 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5012 static PyObject* name = PyString_FromString("eventFilter");
5013 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5014 if (obj) {
4618 5015 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4619 5016 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4620 5017 bool returnValue;
@@ -4633,16 +5030,18 if (_wrapper) {
4633 5030 if (result) { Py_DECREF(result); }
4634 5031 Py_DECREF(obj);
4635 5032 return returnValue;
5033 } else {
5034 PyErr_Clear();
4636 5035 }
4637 5036 }
4638 5037 return TCP_Terminal_Client::eventFilter(arg__1, arg__2);
4639 5038 }
4640 5039 void PythonQtShell_TCP_Terminal_Client::timerEvent(QTimerEvent* arg__1)
4641 5040 {
4642 if (_wrapper) {
4643 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
4644 PyErr_Clear();
4645 if (obj && !PythonQtSlotFunction_Check(obj)) {
5041 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5042 static PyObject* name = PyString_FromString("timerEvent");
5043 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5044 if (obj) {
4646 5045 static const char* argumentList[] ={"" , "QTimerEvent*"};
4647 5046 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4648 5047 void* args[2] = {NULL, (void*)&arg__1};
@@ -4650,6 +5049,8 if (_wrapper) {
4650 5049 if (result) { Py_DECREF(result); }
4651 5050 Py_DECREF(obj);
4652 5051 return;
5052 } else {
5053 PyErr_Clear();
4653 5054 }
4654 5055 }
4655 5056 TCP_Terminal_Client::timerEvent(arg__1);
@@ -4802,10 +5203,10 PythonQtShell_abstractBinFile::~PythonQt
4802 5203 }
4803 5204 void PythonQtShell_abstractBinFile::childEvent(QChildEvent* arg__1)
4804 5205 {
4805 if (_wrapper) {
4806 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
4807 PyErr_Clear();
4808 if (obj && !PythonQtSlotFunction_Check(obj)) {
5206 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5207 static PyObject* name = PyString_FromString("childEvent");
5208 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5209 if (obj) {
4809 5210 static const char* argumentList[] ={"" , "QChildEvent*"};
4810 5211 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4811 5212 void* args[2] = {NULL, (void*)&arg__1};
@@ -4813,16 +5214,18 if (_wrapper) {
4813 5214 if (result) { Py_DECREF(result); }
4814 5215 Py_DECREF(obj);
4815 5216 return;
5217 } else {
5218 PyErr_Clear();
4816 5219 }
4817 5220 }
4818 5221 abstractBinFile::childEvent(arg__1);
4819 5222 }
4820 5223 int PythonQtShell_abstractBinFile::closeFile()
4821 5224 {
4822 if (_wrapper) {
4823 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
4824 PyErr_Clear();
4825 if (obj && !PythonQtSlotFunction_Check(obj)) {
5225 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5226 static PyObject* name = PyString_FromString("closeFile");
5227 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5228 if (obj) {
4826 5229 static const char* argumentList[] ={"int"};
4827 5230 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4828 5231 int returnValue;
@@ -4841,16 +5244,18 if (_wrapper) {
4841 5244 if (result) { Py_DECREF(result); }
4842 5245 Py_DECREF(obj);
4843 5246 return returnValue;
5247 } else {
5248 PyErr_Clear();
4844 5249 }
4845 5250 }
4846 5251 return int();
4847 5252 }
4848 5253 void PythonQtShell_abstractBinFile::customEvent(QEvent* arg__1)
4849 5254 {
4850 if (_wrapper) {
4851 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
4852 PyErr_Clear();
4853 if (obj && !PythonQtSlotFunction_Check(obj)) {
5255 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5256 static PyObject* name = PyString_FromString("customEvent");
5257 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5258 if (obj) {
4854 5259 static const char* argumentList[] ={"" , "QEvent*"};
4855 5260 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4856 5261 void* args[2] = {NULL, (void*)&arg__1};
@@ -4858,16 +5263,18 if (_wrapper) {
4858 5263 if (result) { Py_DECREF(result); }
4859 5264 Py_DECREF(obj);
4860 5265 return;
5266 } else {
5267 PyErr_Clear();
4861 5268 }
4862 5269 }
4863 5270 abstractBinFile::customEvent(arg__1);
4864 5271 }
4865 5272 bool PythonQtShell_abstractBinFile::event(QEvent* arg__1)
4866 5273 {
4867 if (_wrapper) {
4868 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
4869 PyErr_Clear();
4870 if (obj && !PythonQtSlotFunction_Check(obj)) {
5274 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5275 static PyObject* name = PyString_FromString("event");
5276 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5277 if (obj) {
4871 5278 static const char* argumentList[] ={"bool" , "QEvent*"};
4872 5279 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4873 5280 bool returnValue;
@@ -4886,16 +5293,18 if (_wrapper) {
4886 5293 if (result) { Py_DECREF(result); }
4887 5294 Py_DECREF(obj);
4888 5295 return returnValue;
5296 } else {
5297 PyErr_Clear();
4889 5298 }
4890 5299 }
4891 5300 return abstractBinFile::event(arg__1);
4892 5301 }
4893 5302 bool PythonQtShell_abstractBinFile::eventFilter(QObject* arg__1, QEvent* arg__2)
4894 5303 {
4895 if (_wrapper) {
4896 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
4897 PyErr_Clear();
4898 if (obj && !PythonQtSlotFunction_Check(obj)) {
5304 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5305 static PyObject* name = PyString_FromString("eventFilter");
5306 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5307 if (obj) {
4899 5308 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4900 5309 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4901 5310 bool returnValue;
@@ -4914,16 +5323,18 if (_wrapper) {
4914 5323 if (result) { Py_DECREF(result); }
4915 5324 Py_DECREF(obj);
4916 5325 return returnValue;
5326 } else {
5327 PyErr_Clear();
4917 5328 }
4918 5329 }
4919 5330 return abstractBinFile::eventFilter(arg__1, arg__2);
4920 5331 }
4921 5332 QList<codeFragment* > PythonQtShell_abstractBinFile::getFragments()
4922 5333 {
4923 if (_wrapper) {
4924 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
4925 PyErr_Clear();
4926 if (obj && !PythonQtSlotFunction_Check(obj)) {
5334 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5335 static PyObject* name = PyString_FromString("getFragments");
5336 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5337 if (obj) {
4927 5338 static const char* argumentList[] ={"QList<codeFragment* >"};
4928 5339 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4929 5340 QList<codeFragment* > returnValue;
@@ -4942,16 +5353,18 if (_wrapper) {
4942 5353 if (result) { Py_DECREF(result); }
4943 5354 Py_DECREF(obj);
4944 5355 return returnValue;
5356 } else {
5357 PyErr_Clear();
4945 5358 }
4946 5359 }
4947 5360 return QList<codeFragment* >();
4948 5361 }
4949 5362 bool PythonQtShell_abstractBinFile::isopened()
4950 5363 {
4951 if (_wrapper) {
4952 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
4953 PyErr_Clear();
4954 if (obj && !PythonQtSlotFunction_Check(obj)) {
5364 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5365 static PyObject* name = PyString_FromString("isopened");
5366 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5367 if (obj) {
4955 5368 static const char* argumentList[] ={"bool"};
4956 5369 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4957 5370 bool returnValue;
@@ -4970,20 +5383,22 if (_wrapper) {
4970 5383 if (result) { Py_DECREF(result); }
4971 5384 Py_DECREF(obj);
4972 5385 return returnValue;
5386 } else {
5387 PyErr_Clear();
4973 5388 }
4974 5389 }
4975 5390 return bool();
4976 5391 }
4977 bool PythonQtShell_abstractBinFile::openFile(const QString& File)
4978 {
4979 if (_wrapper) {
4980 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
4981 PyErr_Clear();
4982 if (obj && !PythonQtSlotFunction_Check(obj)) {
5392 bool PythonQtShell_abstractBinFile::openFile(const QString& File0)
5393 {
5394 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5395 static PyObject* name = PyString_FromString("openFile");
5396 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5397 if (obj) {
4983 5398 static const char* argumentList[] ={"bool" , "const QString&"};
4984 5399 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4985 5400 bool returnValue;
4986 void* args[2] = {NULL, (void*)&File};
5401 void* args[2] = {NULL, (void*)&File0};
4987 5402 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4988 5403 if (result) {
4989 5404 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -4998,16 +5413,18 if (_wrapper) {
4998 5413 if (result) { Py_DECREF(result); }
4999 5414 Py_DECREF(obj);
5000 5415 return returnValue;
5416 } else {
5417 PyErr_Clear();
5001 5418 }
5002 5419 }
5003 5420 return bool();
5004 5421 }
5005 5422 void PythonQtShell_abstractBinFile::timerEvent(QTimerEvent* arg__1)
5006 5423 {
5007 if (_wrapper) {
5008 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
5009 PyErr_Clear();
5010 if (obj && !PythonQtSlotFunction_Check(obj)) {
5424 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5425 static PyObject* name = PyString_FromString("timerEvent");
5426 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5427 if (obj) {
5011 5428 static const char* argumentList[] ={"" , "QTimerEvent*"};
5012 5429 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5013 5430 void* args[2] = {NULL, (void*)&arg__1};
@@ -5015,20 +5432,22 if (_wrapper) {
5015 5432 if (result) { Py_DECREF(result); }
5016 5433 Py_DECREF(obj);
5017 5434 return;
5435 } else {
5436 PyErr_Clear();
5018 5437 }
5019 5438 }
5020 5439 abstractBinFile::timerEvent(arg__1);
5021 5440 }
5022 bool PythonQtShell_abstractBinFile::toBinary(const QString& File)
5023 {
5024 if (_wrapper) {
5025 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
5026 PyErr_Clear();
5027 if (obj && !PythonQtSlotFunction_Check(obj)) {
5441 bool PythonQtShell_abstractBinFile::toBinary(const QString& File0)
5442 {
5443 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5444 static PyObject* name = PyString_FromString("toBinary");
5445 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5446 if (obj) {
5028 5447 static const char* argumentList[] ={"bool" , "const QString&"};
5029 5448 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5030 5449 bool returnValue;
5031 void* args[2] = {NULL, (void*)&File};
5450 void* args[2] = {NULL, (void*)&File0};
5032 5451 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5033 5452 if (result) {
5034 5453 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -5043,20 +5462,22 if (_wrapper) {
5043 5462 if (result) { Py_DECREF(result); }
5044 5463 Py_DECREF(obj);
5045 5464 return returnValue;
5465 } else {
5466 PyErr_Clear();
5046 5467 }
5047 5468 }
5048 5469 return bool();
5049 5470 }
5050 bool PythonQtShell_abstractBinFile::toSrec(const QString& File)
5051 {
5052 if (_wrapper) {
5053 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
5054 PyErr_Clear();
5055 if (obj && !PythonQtSlotFunction_Check(obj)) {
5471 bool PythonQtShell_abstractBinFile::toSrec(const QString& File0)
5472 {
5473 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5474 static PyObject* name = PyString_FromString("toSrec");
5475 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5476 if (obj) {
5056 5477 static const char* argumentList[] ={"bool" , "const QString&"};
5057 5478 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5058 5479 bool returnValue;
5059 void* args[2] = {NULL, (void*)&File};
5480 void* args[2] = {NULL, (void*)&File0};
5060 5481 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5061 5482 if (result) {
5062 5483 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -5071,6 +5492,8 if (_wrapper) {
5071 5492 if (result) { Py_DECREF(result); }
5072 5493 Py_DECREF(obj);
5073 5494 return returnValue;
5495 } else {
5496 PyErr_Clear();
5074 5497 }
5075 5498 }
5076 5499 return bool();
@@ -5079,6 +5502,36 abstractBinFile* PythonQtWrapper_abstrac
5079 5502 {
5080 5503 return new PythonQtShell_abstractBinFile(); }
5081 5504
5505 int PythonQtWrapper_abstractBinFile::closeFile(abstractBinFile* theWrappedObject)
5506 {
5507 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_closeFile());
5508 }
5509
5510 QList<codeFragment* > PythonQtWrapper_abstractBinFile::getFragments(abstractBinFile* theWrappedObject)
5511 {
5512 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_getFragments());
5513 }
5514
5515 bool PythonQtWrapper_abstractBinFile::isopened(abstractBinFile* theWrappedObject)
5516 {
5517 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_isopened());
5518 }
5519
5520 bool PythonQtWrapper_abstractBinFile::openFile(abstractBinFile* theWrappedObject, const QString& File)
5521 {
5522 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_openFile(File));
5523 }
5524
5525 bool PythonQtWrapper_abstractBinFile::toBinary(abstractBinFile* theWrappedObject, const QString& File)
5526 {
5527 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_toBinary(File));
5528 }
5529
5530 bool PythonQtWrapper_abstractBinFile::toSrec(abstractBinFile* theWrappedObject, const QString& File)
5531 {
5532 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_toSrec(File));
5533 }
5534
5082 5535
5083 5536
5084 5537 PythonQtShell_abstractBinFileWidget::~PythonQtShell_abstractBinFileWidget() {
@@ -5087,10 +5540,10 PythonQtShell_abstractBinFileWidget::~Py
5087 5540 }
5088 5541 void PythonQtShell_abstractBinFileWidget::actionEvent(QActionEvent* arg__1)
5089 5542 {
5090 if (_wrapper) {
5091 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
5092 PyErr_Clear();
5093 if (obj && !PythonQtSlotFunction_Check(obj)) {
5543 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5544 static PyObject* name = PyString_FromString("actionEvent");
5545 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5546 if (obj) {
5094 5547 static const char* argumentList[] ={"" , "QActionEvent*"};
5095 5548 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5096 5549 void* args[2] = {NULL, (void*)&arg__1};
@@ -5098,16 +5551,18 if (_wrapper) {
5098 5551 if (result) { Py_DECREF(result); }
5099 5552 Py_DECREF(obj);
5100 5553 return;
5554 } else {
5555 PyErr_Clear();
5101 5556 }
5102 5557 }
5103 5558 abstractBinFileWidget::actionEvent(arg__1);
5104 5559 }
5105 5560 void PythonQtShell_abstractBinFileWidget::changeEvent(QEvent* arg__1)
5106 5561 {
5107 if (_wrapper) {
5108 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
5109 PyErr_Clear();
5110 if (obj && !PythonQtSlotFunction_Check(obj)) {
5562 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5563 static PyObject* name = PyString_FromString("changeEvent");
5564 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5565 if (obj) {
5111 5566 static const char* argumentList[] ={"" , "QEvent*"};
5112 5567 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5113 5568 void* args[2] = {NULL, (void*)&arg__1};
@@ -5115,16 +5570,18 if (_wrapper) {
5115 5570 if (result) { Py_DECREF(result); }
5116 5571 Py_DECREF(obj);
5117 5572 return;
5573 } else {
5574 PyErr_Clear();
5118 5575 }
5119 5576 }
5120 5577 abstractBinFileWidget::changeEvent(arg__1);
5121 5578 }
5122 5579 void PythonQtShell_abstractBinFileWidget::childEvent(QChildEvent* arg__1)
5123 5580 {
5124 if (_wrapper) {
5125 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
5126 PyErr_Clear();
5127 if (obj && !PythonQtSlotFunction_Check(obj)) {
5581 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5582 static PyObject* name = PyString_FromString("childEvent");
5583 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5584 if (obj) {
5128 5585 static const char* argumentList[] ={"" , "QChildEvent*"};
5129 5586 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5130 5587 void* args[2] = {NULL, (void*)&arg__1};
@@ -5132,16 +5589,18 if (_wrapper) {
5132 5589 if (result) { Py_DECREF(result); }
5133 5590 Py_DECREF(obj);
5134 5591 return;
5592 } else {
5593 PyErr_Clear();
5135 5594 }
5136 5595 }
5137 5596 abstractBinFileWidget::childEvent(arg__1);
5138 5597 }
5139 5598 void PythonQtShell_abstractBinFileWidget::closeEvent(QCloseEvent* arg__1)
5140 5599 {
5141 if (_wrapper) {
5142 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
5143 PyErr_Clear();
5144 if (obj && !PythonQtSlotFunction_Check(obj)) {
5600 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5601 static PyObject* name = PyString_FromString("closeEvent");
5602 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5603 if (obj) {
5145 5604 static const char* argumentList[] ={"" , "QCloseEvent*"};
5146 5605 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5147 5606 void* args[2] = {NULL, (void*)&arg__1};
@@ -5149,16 +5608,18 if (_wrapper) {
5149 5608 if (result) { Py_DECREF(result); }
5150 5609 Py_DECREF(obj);
5151 5610 return;
5611 } else {
5612 PyErr_Clear();
5152 5613 }
5153 5614 }
5154 5615 abstractBinFileWidget::closeEvent(arg__1);
5155 5616 }
5156 5617 void PythonQtShell_abstractBinFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
5157 5618 {
5158 if (_wrapper) {
5159 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
5160 PyErr_Clear();
5161 if (obj && !PythonQtSlotFunction_Check(obj)) {
5619 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5620 static PyObject* name = PyString_FromString("contextMenuEvent");
5621 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5622 if (obj) {
5162 5623 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
5163 5624 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5164 5625 void* args[2] = {NULL, (void*)&arg__1};
@@ -5166,16 +5627,18 if (_wrapper) {
5166 5627 if (result) { Py_DECREF(result); }
5167 5628 Py_DECREF(obj);
5168 5629 return;
5630 } else {
5631 PyErr_Clear();
5169 5632 }
5170 5633 }
5171 5634 abstractBinFileWidget::contextMenuEvent(arg__1);
5172 5635 }
5173 5636 void PythonQtShell_abstractBinFileWidget::customEvent(QEvent* arg__1)
5174 5637 {
5175 if (_wrapper) {
5176 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
5177 PyErr_Clear();
5178 if (obj && !PythonQtSlotFunction_Check(obj)) {
5638 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5639 static PyObject* name = PyString_FromString("customEvent");
5640 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5641 if (obj) {
5179 5642 static const char* argumentList[] ={"" , "QEvent*"};
5180 5643 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5181 5644 void* args[2] = {NULL, (void*)&arg__1};
@@ -5183,16 +5646,18 if (_wrapper) {
5183 5646 if (result) { Py_DECREF(result); }
5184 5647 Py_DECREF(obj);
5185 5648 return;
5649 } else {
5650 PyErr_Clear();
5186 5651 }
5187 5652 }
5188 5653 abstractBinFileWidget::customEvent(arg__1);
5189 5654 }
5190 5655 int PythonQtShell_abstractBinFileWidget::devType() const
5191 5656 {
5192 if (_wrapper) {
5193 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
5194 PyErr_Clear();
5195 if (obj && !PythonQtSlotFunction_Check(obj)) {
5657 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5658 static PyObject* name = PyString_FromString("devType");
5659 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5660 if (obj) {
5196 5661 static const char* argumentList[] ={"int"};
5197 5662 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5198 5663 int returnValue;
@@ -5211,16 +5676,18 if (_wrapper) {
5211 5676 if (result) { Py_DECREF(result); }
5212 5677 Py_DECREF(obj);
5213 5678 return returnValue;
5679 } else {
5680 PyErr_Clear();
5214 5681 }
5215 5682 }
5216 5683 return abstractBinFileWidget::devType();
5217 5684 }
5218 5685 void PythonQtShell_abstractBinFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
5219 5686 {
5220 if (_wrapper) {
5221 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
5222 PyErr_Clear();
5223 if (obj && !PythonQtSlotFunction_Check(obj)) {
5687 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5688 static PyObject* name = PyString_FromString("dragEnterEvent");
5689 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5690 if (obj) {
5224 5691 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
5225 5692 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5226 5693 void* args[2] = {NULL, (void*)&arg__1};
@@ -5228,16 +5695,18 if (_wrapper) {
5228 5695 if (result) { Py_DECREF(result); }
5229 5696 Py_DECREF(obj);
5230 5697 return;
5698 } else {
5699 PyErr_Clear();
5231 5700 }
5232 5701 }
5233 5702 abstractBinFileWidget::dragEnterEvent(arg__1);
5234 5703 }
5235 5704 void PythonQtShell_abstractBinFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
5236 5705 {
5237 if (_wrapper) {
5238 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
5239 PyErr_Clear();
5240 if (obj && !PythonQtSlotFunction_Check(obj)) {
5706 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5707 static PyObject* name = PyString_FromString("dragLeaveEvent");
5708 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5709 if (obj) {
5241 5710 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
5242 5711 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5243 5712 void* args[2] = {NULL, (void*)&arg__1};
@@ -5245,16 +5714,18 if (_wrapper) {
5245 5714 if (result) { Py_DECREF(result); }
5246 5715 Py_DECREF(obj);
5247 5716 return;
5717 } else {
5718 PyErr_Clear();
5248 5719 }
5249 5720 }
5250 5721 abstractBinFileWidget::dragLeaveEvent(arg__1);
5251 5722 }
5252 5723 void PythonQtShell_abstractBinFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
5253 5724 {
5254 if (_wrapper) {
5255 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
5256 PyErr_Clear();
5257 if (obj && !PythonQtSlotFunction_Check(obj)) {
5725 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5726 static PyObject* name = PyString_FromString("dragMoveEvent");
5727 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5728 if (obj) {
5258 5729 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
5259 5730 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5260 5731 void* args[2] = {NULL, (void*)&arg__1};
@@ -5262,16 +5733,18 if (_wrapper) {
5262 5733 if (result) { Py_DECREF(result); }
5263 5734 Py_DECREF(obj);
5264 5735 return;
5736 } else {
5737 PyErr_Clear();
5265 5738 }
5266 5739 }
5267 5740 abstractBinFileWidget::dragMoveEvent(arg__1);
5268 5741 }
5269 5742 void PythonQtShell_abstractBinFileWidget::dropEvent(QDropEvent* arg__1)
5270 5743 {
5271 if (_wrapper) {
5272 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
5273 PyErr_Clear();
5274 if (obj && !PythonQtSlotFunction_Check(obj)) {
5744 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5745 static PyObject* name = PyString_FromString("dropEvent");
5746 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5747 if (obj) {
5275 5748 static const char* argumentList[] ={"" , "QDropEvent*"};
5276 5749 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5277 5750 void* args[2] = {NULL, (void*)&arg__1};
@@ -5279,16 +5752,18 if (_wrapper) {
5279 5752 if (result) { Py_DECREF(result); }
5280 5753 Py_DECREF(obj);
5281 5754 return;
5755 } else {
5756 PyErr_Clear();
5282 5757 }
5283 5758 }
5284 5759 abstractBinFileWidget::dropEvent(arg__1);
5285 5760 }
5286 5761 void PythonQtShell_abstractBinFileWidget::enterEvent(QEvent* arg__1)
5287 5762 {
5288 if (_wrapper) {
5289 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
5290 PyErr_Clear();
5291 if (obj && !PythonQtSlotFunction_Check(obj)) {
5763 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5764 static PyObject* name = PyString_FromString("enterEvent");
5765 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5766 if (obj) {
5292 5767 static const char* argumentList[] ={"" , "QEvent*"};
5293 5768 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5294 5769 void* args[2] = {NULL, (void*)&arg__1};
@@ -5296,16 +5771,18 if (_wrapper) {
5296 5771 if (result) { Py_DECREF(result); }
5297 5772 Py_DECREF(obj);
5298 5773 return;
5774 } else {
5775 PyErr_Clear();
5299 5776 }
5300 5777 }
5301 5778 abstractBinFileWidget::enterEvent(arg__1);
5302 5779 }
5303 5780 bool PythonQtShell_abstractBinFileWidget::event(QEvent* arg__1)
5304 5781 {
5305 if (_wrapper) {
5306 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
5307 PyErr_Clear();
5308 if (obj && !PythonQtSlotFunction_Check(obj)) {
5782 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5783 static PyObject* name = PyString_FromString("event");
5784 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5785 if (obj) {
5309 5786 static const char* argumentList[] ={"bool" , "QEvent*"};
5310 5787 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5311 5788 bool returnValue;
@@ -5324,16 +5801,18 if (_wrapper) {
5324 5801 if (result) { Py_DECREF(result); }
5325 5802 Py_DECREF(obj);
5326 5803 return returnValue;
5804 } else {
5805 PyErr_Clear();
5327 5806 }
5328 5807 }
5329 5808 return abstractBinFileWidget::event(arg__1);
5330 5809 }
5331 5810 bool PythonQtShell_abstractBinFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
5332 5811 {
5333 if (_wrapper) {
5334 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
5335 PyErr_Clear();
5336 if (obj && !PythonQtSlotFunction_Check(obj)) {
5812 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5813 static PyObject* name = PyString_FromString("eventFilter");
5814 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5815 if (obj) {
5337 5816 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5338 5817 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5339 5818 bool returnValue;
@@ -5352,16 +5831,18 if (_wrapper) {
5352 5831 if (result) { Py_DECREF(result); }
5353 5832 Py_DECREF(obj);
5354 5833 return returnValue;
5834 } else {
5835 PyErr_Clear();
5355 5836 }
5356 5837 }
5357 5838 return abstractBinFileWidget::eventFilter(arg__1, arg__2);
5358 5839 }
5359 5840 void PythonQtShell_abstractBinFileWidget::focusInEvent(QFocusEvent* arg__1)
5360 5841 {
5361 if (_wrapper) {
5362 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
5363 PyErr_Clear();
5364 if (obj && !PythonQtSlotFunction_Check(obj)) {
5842 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5843 static PyObject* name = PyString_FromString("focusInEvent");
5844 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5845 if (obj) {
5365 5846 static const char* argumentList[] ={"" , "QFocusEvent*"};
5366 5847 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5367 5848 void* args[2] = {NULL, (void*)&arg__1};
@@ -5369,20 +5850,22 if (_wrapper) {
5369 5850 if (result) { Py_DECREF(result); }
5370 5851 Py_DECREF(obj);
5371 5852 return;
5853 } else {
5854 PyErr_Clear();
5372 5855 }
5373 5856 }
5374 5857 abstractBinFileWidget::focusInEvent(arg__1);
5375 5858 }
5376 bool PythonQtShell_abstractBinFileWidget::focusNextPrevChild(bool next)
5377 {
5378 if (_wrapper) {
5379 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
5380 PyErr_Clear();
5381 if (obj && !PythonQtSlotFunction_Check(obj)) {
5859 bool PythonQtShell_abstractBinFileWidget::focusNextPrevChild(bool next0)
5860 {
5861 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5862 static PyObject* name = PyString_FromString("focusNextPrevChild");
5863 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5864 if (obj) {
5382 5865 static const char* argumentList[] ={"bool" , "bool"};
5383 5866 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5384 5867 bool returnValue;
5385 void* args[2] = {NULL, (void*)&next};
5868 void* args[2] = {NULL, (void*)&next0};
5386 5869 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5387 5870 if (result) {
5388 5871 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -5397,16 +5880,18 if (_wrapper) {
5397 5880 if (result) { Py_DECREF(result); }
5398 5881 Py_DECREF(obj);
5399 5882 return returnValue;
5400 }
5401 }
5402 return abstractBinFileWidget::focusNextPrevChild(next);
5883 } else {
5884 PyErr_Clear();
5885 }
5886 }
5887 return abstractBinFileWidget::focusNextPrevChild(next0);
5403 5888 }
5404 5889 void PythonQtShell_abstractBinFileWidget::focusOutEvent(QFocusEvent* arg__1)
5405 5890 {
5406 if (_wrapper) {
5407 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
5408 PyErr_Clear();
5409 if (obj && !PythonQtSlotFunction_Check(obj)) {
5891 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5892 static PyObject* name = PyString_FromString("focusOutEvent");
5893 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5894 if (obj) {
5410 5895 static const char* argumentList[] ={"" , "QFocusEvent*"};
5411 5896 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5412 5897 void* args[2] = {NULL, (void*)&arg__1};
@@ -5414,16 +5899,18 if (_wrapper) {
5414 5899 if (result) { Py_DECREF(result); }
5415 5900 Py_DECREF(obj);
5416 5901 return;
5902 } else {
5903 PyErr_Clear();
5417 5904 }
5418 5905 }
5419 5906 abstractBinFileWidget::focusOutEvent(arg__1);
5420 5907 }
5421 5908 bool PythonQtShell_abstractBinFileWidget::hasHeightForWidth() const
5422 5909 {
5423 if (_wrapper) {
5424 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
5425 PyErr_Clear();
5426 if (obj && !PythonQtSlotFunction_Check(obj)) {
5910 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5911 static PyObject* name = PyString_FromString("hasHeightForWidth");
5912 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5913 if (obj) {
5427 5914 static const char* argumentList[] ={"bool"};
5428 5915 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5429 5916 bool returnValue;
@@ -5442,16 +5929,18 if (_wrapper) {
5442 5929 if (result) { Py_DECREF(result); }
5443 5930 Py_DECREF(obj);
5444 5931 return returnValue;
5932 } else {
5933 PyErr_Clear();
5445 5934 }
5446 5935 }
5447 5936 return abstractBinFileWidget::hasHeightForWidth();
5448 5937 }
5449 5938 int PythonQtShell_abstractBinFileWidget::heightForWidth(int arg__1) const
5450 5939 {
5451 if (_wrapper) {
5452 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
5453 PyErr_Clear();
5454 if (obj && !PythonQtSlotFunction_Check(obj)) {
5940 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5941 static PyObject* name = PyString_FromString("heightForWidth");
5942 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5943 if (obj) {
5455 5944 static const char* argumentList[] ={"int" , "int"};
5456 5945 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5457 5946 int returnValue;
@@ -5470,16 +5959,18 if (_wrapper) {
5470 5959 if (result) { Py_DECREF(result); }
5471 5960 Py_DECREF(obj);
5472 5961 return returnValue;
5962 } else {
5963 PyErr_Clear();
5473 5964 }
5474 5965 }
5475 5966 return abstractBinFileWidget::heightForWidth(arg__1);
5476 5967 }
5477 5968 void PythonQtShell_abstractBinFileWidget::hideEvent(QHideEvent* arg__1)
5478 5969 {
5479 if (_wrapper) {
5480 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
5481 PyErr_Clear();
5482 if (obj && !PythonQtSlotFunction_Check(obj)) {
5970 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5971 static PyObject* name = PyString_FromString("hideEvent");
5972 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5973 if (obj) {
5483 5974 static const char* argumentList[] ={"" , "QHideEvent*"};
5484 5975 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5485 5976 void* args[2] = {NULL, (void*)&arg__1};
@@ -5487,33 +5978,37 if (_wrapper) {
5487 5978 if (result) { Py_DECREF(result); }
5488 5979 Py_DECREF(obj);
5489 5980 return;
5981 } else {
5982 PyErr_Clear();
5490 5983 }
5491 5984 }
5492 5985 abstractBinFileWidget::hideEvent(arg__1);
5493 5986 }
5494 void PythonQtShell_abstractBinFileWidget::initPainter(QPainter* painter) const
5495 {
5496 if (_wrapper) {
5497 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
5498 PyErr_Clear();
5499 if (obj && !PythonQtSlotFunction_Check(obj)) {
5987 void PythonQtShell_abstractBinFileWidget::initPainter(QPainter* painter0) const
5988 {
5989 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5990 static PyObject* name = PyString_FromString("initPainter");
5991 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5992 if (obj) {
5500 5993 static const char* argumentList[] ={"" , "QPainter*"};
5501 5994 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5502 void* args[2] = {NULL, (void*)&painter};
5503 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5504 if (result) { Py_DECREF(result); }
5505 Py_DECREF(obj);
5506 return;
5507 }
5508 }
5509 abstractBinFileWidget::initPainter(painter);
5995 void* args[2] = {NULL, (void*)&painter0};
5996 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5997 if (result) { Py_DECREF(result); }
5998 Py_DECREF(obj);
5999 return;
6000 } else {
6001 PyErr_Clear();
6002 }
6003 }
6004 abstractBinFileWidget::initPainter(painter0);
5510 6005 }
5511 6006 void PythonQtShell_abstractBinFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
5512 6007 {
5513 if (_wrapper) {
5514 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
5515 PyErr_Clear();
5516 if (obj && !PythonQtSlotFunction_Check(obj)) {
6008 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6009 static PyObject* name = PyString_FromString("inputMethodEvent");
6010 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6011 if (obj) {
5517 6012 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
5518 6013 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5519 6014 void* args[2] = {NULL, (void*)&arg__1};
@@ -5521,16 +6016,18 if (_wrapper) {
5521 6016 if (result) { Py_DECREF(result); }
5522 6017 Py_DECREF(obj);
5523 6018 return;
6019 } else {
6020 PyErr_Clear();
5524 6021 }
5525 6022 }
5526 6023 abstractBinFileWidget::inputMethodEvent(arg__1);
5527 6024 }
5528 6025 QVariant PythonQtShell_abstractBinFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
5529 6026 {
5530 if (_wrapper) {
5531 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
5532 PyErr_Clear();
5533 if (obj && !PythonQtSlotFunction_Check(obj)) {
6027 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6028 static PyObject* name = PyString_FromString("inputMethodQuery");
6029 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6030 if (obj) {
5534 6031 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
5535 6032 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5536 6033 QVariant returnValue;
@@ -5549,16 +6046,18 if (_wrapper) {
5549 6046 if (result) { Py_DECREF(result); }
5550 6047 Py_DECREF(obj);
5551 6048 return returnValue;
6049 } else {
6050 PyErr_Clear();
5552 6051 }
5553 6052 }
5554 6053 return abstractBinFileWidget::inputMethodQuery(arg__1);
5555 6054 }
5556 6055 void PythonQtShell_abstractBinFileWidget::keyPressEvent(QKeyEvent* arg__1)
5557 6056 {
5558 if (_wrapper) {
5559 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
5560 PyErr_Clear();
5561 if (obj && !PythonQtSlotFunction_Check(obj)) {
6057 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6058 static PyObject* name = PyString_FromString("keyPressEvent");
6059 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6060 if (obj) {
5562 6061 static const char* argumentList[] ={"" , "QKeyEvent*"};
5563 6062 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5564 6063 void* args[2] = {NULL, (void*)&arg__1};
@@ -5566,16 +6065,18 if (_wrapper) {
5566 6065 if (result) { Py_DECREF(result); }
5567 6066 Py_DECREF(obj);
5568 6067 return;
6068 } else {
6069 PyErr_Clear();
5569 6070 }
5570 6071 }
5571 6072 abstractBinFileWidget::keyPressEvent(arg__1);
5572 6073 }
5573 6074 void PythonQtShell_abstractBinFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
5574 6075 {
5575 if (_wrapper) {
5576 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
5577 PyErr_Clear();
5578 if (obj && !PythonQtSlotFunction_Check(obj)) {
6076 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6077 static PyObject* name = PyString_FromString("keyReleaseEvent");
6078 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6079 if (obj) {
5579 6080 static const char* argumentList[] ={"" , "QKeyEvent*"};
5580 6081 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5581 6082 void* args[2] = {NULL, (void*)&arg__1};
@@ -5583,16 +6084,18 if (_wrapper) {
5583 6084 if (result) { Py_DECREF(result); }
5584 6085 Py_DECREF(obj);
5585 6086 return;
6087 } else {
6088 PyErr_Clear();
5586 6089 }
5587 6090 }
5588 6091 abstractBinFileWidget::keyReleaseEvent(arg__1);
5589 6092 }
5590 6093 void PythonQtShell_abstractBinFileWidget::leaveEvent(QEvent* arg__1)
5591 6094 {
5592 if (_wrapper) {
5593 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
5594 PyErr_Clear();
5595 if (obj && !PythonQtSlotFunction_Check(obj)) {
6095 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6096 static PyObject* name = PyString_FromString("leaveEvent");
6097 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6098 if (obj) {
5596 6099 static const char* argumentList[] ={"" , "QEvent*"};
5597 6100 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5598 6101 void* args[2] = {NULL, (void*)&arg__1};
@@ -5600,16 +6103,18 if (_wrapper) {
5600 6103 if (result) { Py_DECREF(result); }
5601 6104 Py_DECREF(obj);
5602 6105 return;
6106 } else {
6107 PyErr_Clear();
5603 6108 }
5604 6109 }
5605 6110 abstractBinFileWidget::leaveEvent(arg__1);
5606 6111 }
5607 6112 int PythonQtShell_abstractBinFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
5608 6113 {
5609 if (_wrapper) {
5610 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
5611 PyErr_Clear();
5612 if (obj && !PythonQtSlotFunction_Check(obj)) {
6114 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6115 static PyObject* name = PyString_FromString("metric");
6116 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6117 if (obj) {
5613 6118 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
5614 6119 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5615 6120 int returnValue;
@@ -5628,16 +6133,18 if (_wrapper) {
5628 6133 if (result) { Py_DECREF(result); }
5629 6134 Py_DECREF(obj);
5630 6135 return returnValue;
6136 } else {
6137 PyErr_Clear();
5631 6138 }
5632 6139 }
5633 6140 return abstractBinFileWidget::metric(arg__1);
5634 6141 }
5635 6142 QSize PythonQtShell_abstractBinFileWidget::minimumSizeHint() const
5636 6143 {
5637 if (_wrapper) {
5638 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
5639 PyErr_Clear();
5640 if (obj && !PythonQtSlotFunction_Check(obj)) {
6144 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6145 static PyObject* name = PyString_FromString("getMinimumSizeHint");
6146 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6147 if (obj) {
5641 6148 static const char* argumentList[] ={"QSize"};
5642 6149 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5643 6150 QSize returnValue;
@@ -5656,16 +6163,18 if (_wrapper) {
5656 6163 if (result) { Py_DECREF(result); }
5657 6164 Py_DECREF(obj);
5658 6165 return returnValue;
6166 } else {
6167 PyErr_Clear();
5659 6168 }
5660 6169 }
5661 6170 return abstractBinFileWidget::minimumSizeHint();
5662 6171 }
5663 6172 void PythonQtShell_abstractBinFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
5664 6173 {
5665 if (_wrapper) {
5666 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
5667 PyErr_Clear();
5668 if (obj && !PythonQtSlotFunction_Check(obj)) {
6174 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6175 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
6176 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6177 if (obj) {
5669 6178 static const char* argumentList[] ={"" , "QMouseEvent*"};
5670 6179 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5671 6180 void* args[2] = {NULL, (void*)&arg__1};
@@ -5673,16 +6182,18 if (_wrapper) {
5673 6182 if (result) { Py_DECREF(result); }
5674 6183 Py_DECREF(obj);
5675 6184 return;
6185 } else {
6186 PyErr_Clear();
5676 6187 }
5677 6188 }
5678 6189 abstractBinFileWidget::mouseDoubleClickEvent(arg__1);
5679 6190 }
5680 6191 void PythonQtShell_abstractBinFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
5681 6192 {
5682 if (_wrapper) {
5683 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
5684 PyErr_Clear();
5685 if (obj && !PythonQtSlotFunction_Check(obj)) {
6193 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6194 static PyObject* name = PyString_FromString("mouseMoveEvent");
6195 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6196 if (obj) {
5686 6197 static const char* argumentList[] ={"" , "QMouseEvent*"};
5687 6198 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5688 6199 void* args[2] = {NULL, (void*)&arg__1};
@@ -5690,16 +6201,18 if (_wrapper) {
5690 6201 if (result) { Py_DECREF(result); }
5691 6202 Py_DECREF(obj);
5692 6203 return;
6204 } else {
6205 PyErr_Clear();
5693 6206 }
5694 6207 }
5695 6208 abstractBinFileWidget::mouseMoveEvent(arg__1);
5696 6209 }
5697 6210 void PythonQtShell_abstractBinFileWidget::mousePressEvent(QMouseEvent* arg__1)
5698 6211 {
5699 if (_wrapper) {
5700 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
5701 PyErr_Clear();
5702 if (obj && !PythonQtSlotFunction_Check(obj)) {
6212 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6213 static PyObject* name = PyString_FromString("mousePressEvent");
6214 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6215 if (obj) {
5703 6216 static const char* argumentList[] ={"" , "QMouseEvent*"};
5704 6217 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5705 6218 void* args[2] = {NULL, (void*)&arg__1};
@@ -5707,16 +6220,18 if (_wrapper) {
5707 6220 if (result) { Py_DECREF(result); }
5708 6221 Py_DECREF(obj);
5709 6222 return;
6223 } else {
6224 PyErr_Clear();
5710 6225 }
5711 6226 }
5712 6227 abstractBinFileWidget::mousePressEvent(arg__1);
5713 6228 }
5714 6229 void PythonQtShell_abstractBinFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
5715 6230 {
5716 if (_wrapper) {
5717 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
5718 PyErr_Clear();
5719 if (obj && !PythonQtSlotFunction_Check(obj)) {
6231 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6232 static PyObject* name = PyString_FromString("mouseReleaseEvent");
6233 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6234 if (obj) {
5720 6235 static const char* argumentList[] ={"" , "QMouseEvent*"};
5721 6236 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5722 6237 void* args[2] = {NULL, (void*)&arg__1};
@@ -5724,16 +6239,18 if (_wrapper) {
5724 6239 if (result) { Py_DECREF(result); }
5725 6240 Py_DECREF(obj);
5726 6241 return;
6242 } else {
6243 PyErr_Clear();
5727 6244 }
5728 6245 }
5729 6246 abstractBinFileWidget::mouseReleaseEvent(arg__1);
5730 6247 }
5731 6248 void PythonQtShell_abstractBinFileWidget::moveEvent(QMoveEvent* arg__1)
5732 6249 {
5733 if (_wrapper) {
5734 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
5735 PyErr_Clear();
5736 if (obj && !PythonQtSlotFunction_Check(obj)) {
6250 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6251 static PyObject* name = PyString_FromString("moveEvent");
6252 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6253 if (obj) {
5737 6254 static const char* argumentList[] ={"" , "QMoveEvent*"};
5738 6255 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5739 6256 void* args[2] = {NULL, (void*)&arg__1};
@@ -5741,20 +6258,22 if (_wrapper) {
5741 6258 if (result) { Py_DECREF(result); }
5742 6259 Py_DECREF(obj);
5743 6260 return;
6261 } else {
6262 PyErr_Clear();
5744 6263 }
5745 6264 }
5746 6265 abstractBinFileWidget::moveEvent(arg__1);
5747 6266 }
5748 bool PythonQtShell_abstractBinFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result)
5749 {
5750 if (_wrapper) {
5751 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
5752 PyErr_Clear();
5753 if (obj && !PythonQtSlotFunction_Check(obj)) {
6267 bool PythonQtShell_abstractBinFileWidget::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
6268 {
6269 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6270 static PyObject* name = PyString_FromString("nativeEvent");
6271 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6272 if (obj) {
5754 6273 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
5755 6274 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
5756 6275 bool returnValue;
5757 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
6276 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
5758 6277 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5759 6278 if (result) {
5760 6279 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -5769,16 +6288,18 if (_wrapper) {
5769 6288 if (result) { Py_DECREF(result); }
5770 6289 Py_DECREF(obj);
5771 6290 return returnValue;
5772 }
5773 }
5774 return abstractBinFileWidget::nativeEvent(eventType, message, result);
6291 } else {
6292 PyErr_Clear();
6293 }
6294 }
6295 return abstractBinFileWidget::nativeEvent(eventType0, message1, result2);
5775 6296 }
5776 6297 QPaintEngine* PythonQtShell_abstractBinFileWidget::paintEngine() const
5777 6298 {
5778 if (_wrapper) {
5779 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
5780 PyErr_Clear();
5781 if (obj && !PythonQtSlotFunction_Check(obj)) {
6299 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6300 static PyObject* name = PyString_FromString("paintEngine");
6301 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6302 if (obj) {
5782 6303 static const char* argumentList[] ={"QPaintEngine*"};
5783 6304 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5784 6305 QPaintEngine* returnValue;
@@ -5797,16 +6318,18 if (_wrapper) {
5797 6318 if (result) { Py_DECREF(result); }
5798 6319 Py_DECREF(obj);
5799 6320 return returnValue;
6321 } else {
6322 PyErr_Clear();
5800 6323 }
5801 6324 }
5802 6325 return abstractBinFileWidget::paintEngine();
5803 6326 }
5804 6327 void PythonQtShell_abstractBinFileWidget::paintEvent(QPaintEvent* arg__1)
5805 6328 {
5806 if (_wrapper) {
5807 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
5808 PyErr_Clear();
5809 if (obj && !PythonQtSlotFunction_Check(obj)) {
6329 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6330 static PyObject* name = PyString_FromString("paintEvent");
6331 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6332 if (obj) {
5810 6333 static const char* argumentList[] ={"" , "QPaintEvent*"};
5811 6334 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5812 6335 void* args[2] = {NULL, (void*)&arg__1};
@@ -5814,20 +6337,22 if (_wrapper) {
5814 6337 if (result) { Py_DECREF(result); }
5815 6338 Py_DECREF(obj);
5816 6339 return;
6340 } else {
6341 PyErr_Clear();
5817 6342 }
5818 6343 }
5819 6344 abstractBinFileWidget::paintEvent(arg__1);
5820 6345 }
5821 QPaintDevice* PythonQtShell_abstractBinFileWidget::redirected(QPoint* offset) const
5822 {
5823 if (_wrapper) {
5824 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
5825 PyErr_Clear();
5826 if (obj && !PythonQtSlotFunction_Check(obj)) {
6346 QPaintDevice* PythonQtShell_abstractBinFileWidget::redirected(QPoint* offset0) const
6347 {
6348 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6349 static PyObject* name = PyString_FromString("redirected");
6350 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6351 if (obj) {
5827 6352 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
5828 6353 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5829 6354 QPaintDevice* returnValue;
5830 void* args[2] = {NULL, (void*)&offset};
6355 void* args[2] = {NULL, (void*)&offset0};
5831 6356 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5832 6357 if (result) {
5833 6358 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -5842,16 +6367,18 if (_wrapper) {
5842 6367 if (result) { Py_DECREF(result); }
5843 6368 Py_DECREF(obj);
5844 6369 return returnValue;
5845 }
5846 }
5847 return abstractBinFileWidget::redirected(offset);
6370 } else {
6371 PyErr_Clear();
6372 }
6373 }
6374 return abstractBinFileWidget::redirected(offset0);
5848 6375 }
5849 6376 void PythonQtShell_abstractBinFileWidget::reloadFile()
5850 6377 {
5851 if (_wrapper) {
5852 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
5853 PyErr_Clear();
5854 if (obj && !PythonQtSlotFunction_Check(obj)) {
6378 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6379 static PyObject* name = PyString_FromString("reloadFile");
6380 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6381 if (obj) {
5855 6382 static const char* argumentList[] ={""};
5856 6383 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5857 6384 void* args[1] = {NULL};
@@ -5859,16 +6386,18 if (_wrapper) {
5859 6386 if (result) { Py_DECREF(result); }
5860 6387 Py_DECREF(obj);
5861 6388 return;
6389 } else {
6390 PyErr_Clear();
5862 6391 }
5863 6392 }
5864 6393
5865 6394 }
5866 6395 void PythonQtShell_abstractBinFileWidget::resizeEvent(QResizeEvent* arg__1)
5867 6396 {
5868 if (_wrapper) {
5869 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
5870 PyErr_Clear();
5871 if (obj && !PythonQtSlotFunction_Check(obj)) {
6397 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6398 static PyObject* name = PyString_FromString("resizeEvent");
6399 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6400 if (obj) {
5872 6401 static const char* argumentList[] ={"" , "QResizeEvent*"};
5873 6402 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5874 6403 void* args[2] = {NULL, (void*)&arg__1};
@@ -5876,33 +6405,37 if (_wrapper) {
5876 6405 if (result) { Py_DECREF(result); }
5877 6406 Py_DECREF(obj);
5878 6407 return;
6408 } else {
6409 PyErr_Clear();
5879 6410 }
5880 6411 }
5881 6412 abstractBinFileWidget::resizeEvent(arg__1);
5882 6413 }
5883 void PythonQtShell_abstractBinFileWidget::setFile(abstractBinFile* file)
5884 {
5885 if (_wrapper) {
5886 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
5887 PyErr_Clear();
5888 if (obj && !PythonQtSlotFunction_Check(obj)) {
6414 void PythonQtShell_abstractBinFileWidget::setFile(abstractBinFile* file0)
6415 {
6416 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6417 static PyObject* name = PyString_FromString("setFile");
6418 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6419 if (obj) {
5889 6420 static const char* argumentList[] ={"" , "abstractBinFile*"};
5890 6421 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5891 void* args[2] = {NULL, (void*)&file};
5892 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5893 if (result) { Py_DECREF(result); }
5894 Py_DECREF(obj);
5895 return;
6422 void* args[2] = {NULL, (void*)&file0};
6423 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6424 if (result) { Py_DECREF(result); }
6425 Py_DECREF(obj);
6426 return;
6427 } else {
6428 PyErr_Clear();
5896 6429 }
5897 6430 }
5898 6431
5899 6432 }
5900 6433 QPainter* PythonQtShell_abstractBinFileWidget::sharedPainter() const
5901 6434 {
5902 if (_wrapper) {
5903 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
5904 PyErr_Clear();
5905 if (obj && !PythonQtSlotFunction_Check(obj)) {
6435 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6436 static PyObject* name = PyString_FromString("sharedPainter");
6437 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6438 if (obj) {
5906 6439 static const char* argumentList[] ={"QPainter*"};
5907 6440 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5908 6441 QPainter* returnValue;
@@ -5921,16 +6454,18 if (_wrapper) {
5921 6454 if (result) { Py_DECREF(result); }
5922 6455 Py_DECREF(obj);
5923 6456 return returnValue;
6457 } else {
6458 PyErr_Clear();
5924 6459 }
5925 6460 }
5926 6461 return abstractBinFileWidget::sharedPainter();
5927 6462 }
5928 6463 void PythonQtShell_abstractBinFileWidget::showEvent(QShowEvent* arg__1)
5929 6464 {
5930 if (_wrapper) {
5931 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
5932 PyErr_Clear();
5933 if (obj && !PythonQtSlotFunction_Check(obj)) {
6465 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6466 static PyObject* name = PyString_FromString("showEvent");
6467 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6468 if (obj) {
5934 6469 static const char* argumentList[] ={"" , "QShowEvent*"};
5935 6470 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5936 6471 void* args[2] = {NULL, (void*)&arg__1};
@@ -5938,16 +6473,18 if (_wrapper) {
5938 6473 if (result) { Py_DECREF(result); }
5939 6474 Py_DECREF(obj);
5940 6475 return;
6476 } else {
6477 PyErr_Clear();
5941 6478 }
5942 6479 }
5943 6480 abstractBinFileWidget::showEvent(arg__1);
5944 6481 }
5945 6482 QSize PythonQtShell_abstractBinFileWidget::sizeHint() const
5946 6483 {
5947 if (_wrapper) {
5948 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
5949 PyErr_Clear();
5950 if (obj && !PythonQtSlotFunction_Check(obj)) {
6484 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6485 static PyObject* name = PyString_FromString("getSizeHint");
6486 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6487 if (obj) {
5951 6488 static const char* argumentList[] ={"QSize"};
5952 6489 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5953 6490 QSize returnValue;
@@ -5966,16 +6503,18 if (_wrapper) {
5966 6503 if (result) { Py_DECREF(result); }
5967 6504 Py_DECREF(obj);
5968 6505 return returnValue;
6506 } else {
6507 PyErr_Clear();
5969 6508 }
5970 6509 }
5971 6510 return abstractBinFileWidget::sizeHint();
5972 6511 }
5973 6512 void PythonQtShell_abstractBinFileWidget::tabletEvent(QTabletEvent* arg__1)
5974 6513 {
5975 if (_wrapper) {
5976 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
5977 PyErr_Clear();
5978 if (obj && !PythonQtSlotFunction_Check(obj)) {
6514 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6515 static PyObject* name = PyString_FromString("tabletEvent");
6516 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6517 if (obj) {
5979 6518 static const char* argumentList[] ={"" , "QTabletEvent*"};
5980 6519 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5981 6520 void* args[2] = {NULL, (void*)&arg__1};
@@ -5983,16 +6522,18 if (_wrapper) {
5983 6522 if (result) { Py_DECREF(result); }
5984 6523 Py_DECREF(obj);
5985 6524 return;
6525 } else {
6526 PyErr_Clear();
5986 6527 }
5987 6528 }
5988 6529 abstractBinFileWidget::tabletEvent(arg__1);
5989 6530 }
5990 6531 void PythonQtShell_abstractBinFileWidget::timerEvent(QTimerEvent* arg__1)
5991 6532 {
5992 if (_wrapper) {
5993 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
5994 PyErr_Clear();
5995 if (obj && !PythonQtSlotFunction_Check(obj)) {
6533 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6534 static PyObject* name = PyString_FromString("timerEvent");
6535 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6536 if (obj) {
5996 6537 static const char* argumentList[] ={"" , "QTimerEvent*"};
5997 6538 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5998 6539 void* args[2] = {NULL, (void*)&arg__1};
@@ -6000,16 +6541,18 if (_wrapper) {
6000 6541 if (result) { Py_DECREF(result); }
6001 6542 Py_DECREF(obj);
6002 6543 return;
6544 } else {
6545 PyErr_Clear();
6003 6546 }
6004 6547 }
6005 6548 abstractBinFileWidget::timerEvent(arg__1);
6006 6549 }
6007 6550 void PythonQtShell_abstractBinFileWidget::wheelEvent(QWheelEvent* arg__1)
6008 6551 {
6009 if (_wrapper) {
6010 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
6011 PyErr_Clear();
6012 if (obj && !PythonQtSlotFunction_Check(obj)) {
6552 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6553 static PyObject* name = PyString_FromString("wheelEvent");
6554 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6555 if (obj) {
6013 6556 static const char* argumentList[] ={"" , "QWheelEvent*"};
6014 6557 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6015 6558 void* args[2] = {NULL, (void*)&arg__1};
@@ -6017,6 +6560,8 if (_wrapper) {
6017 6560 if (result) { Py_DECREF(result); }
6018 6561 Py_DECREF(obj);
6019 6562 return;
6563 } else {
6564 PyErr_Clear();
6020 6565 }
6021 6566 }
6022 6567 abstractBinFileWidget::wheelEvent(arg__1);
@@ -6025,6 +6570,16 abstractBinFileWidget* PythonQtWrapper_a
6025 6570 {
6026 6571 return new PythonQtShell_abstractBinFileWidget(parent); }
6027 6572
6573 void PythonQtWrapper_abstractBinFileWidget::reloadFile(abstractBinFileWidget* theWrappedObject)
6574 {
6575 ( ((PythonQtPublicPromoter_abstractBinFileWidget*)theWrappedObject)->promoted_reloadFile());
6576 }
6577
6578 void PythonQtWrapper_abstractBinFileWidget::setFile(abstractBinFileWidget* theWrappedObject, abstractBinFile* file)
6579 {
6580 ( ((PythonQtPublicPromoter_abstractBinFileWidget*)theWrappedObject)->promoted_setFile(file));
6581 }
6582
6028 6583
6029 6584
6030 6585 PythonQtShell_binaryFile::~PythonQtShell_binaryFile() {
@@ -6033,10 +6588,10 PythonQtShell_binaryFile::~PythonQtShell
6033 6588 }
6034 6589 int PythonQtShell_binaryFile::closeFile()
6035 6590 {
6036 if (_wrapper) {
6037 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
6038 PyErr_Clear();
6039 if (obj && !PythonQtSlotFunction_Check(obj)) {
6591 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6592 static PyObject* name = PyString_FromString("closeFile");
6593 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6594 if (obj) {
6040 6595 static const char* argumentList[] ={"int"};
6041 6596 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6042 6597 int returnValue;
@@ -6055,16 +6610,18 if (_wrapper) {
6055 6610 if (result) { Py_DECREF(result); }
6056 6611 Py_DECREF(obj);
6057 6612 return returnValue;
6613 } else {
6614 PyErr_Clear();
6058 6615 }
6059 6616 }
6060 6617 return binaryFile::closeFile();
6061 6618 }
6062 6619 QList<codeFragment* > PythonQtShell_binaryFile::getFragments()
6063 6620 {
6064 if (_wrapper) {
6065 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
6066 PyErr_Clear();
6067 if (obj && !PythonQtSlotFunction_Check(obj)) {
6621 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6622 static PyObject* name = PyString_FromString("getFragments");
6623 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6624 if (obj) {
6068 6625 static const char* argumentList[] ={"QList<codeFragment* >"};
6069 6626 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6070 6627 QList<codeFragment* > returnValue;
@@ -6083,16 +6640,18 if (_wrapper) {
6083 6640 if (result) { Py_DECREF(result); }
6084 6641 Py_DECREF(obj);
6085 6642 return returnValue;
6643 } else {
6644 PyErr_Clear();
6086 6645 }
6087 6646 }
6088 6647 return binaryFile::getFragments();
6089 6648 }
6090 6649 bool PythonQtShell_binaryFile::isopened()
6091 6650 {
6092 if (_wrapper) {
6093 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
6094 PyErr_Clear();
6095 if (obj && !PythonQtSlotFunction_Check(obj)) {
6651 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6652 static PyObject* name = PyString_FromString("isopened");
6653 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6654 if (obj) {
6096 6655 static const char* argumentList[] ={"bool"};
6097 6656 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6098 6657 bool returnValue;
@@ -6111,20 +6670,22 if (_wrapper) {
6111 6670 if (result) { Py_DECREF(result); }
6112 6671 Py_DECREF(obj);
6113 6672 return returnValue;
6673 } else {
6674 PyErr_Clear();
6114 6675 }
6115 6676 }
6116 6677 return binaryFile::isopened();
6117 6678 }
6118 bool PythonQtShell_binaryFile::openFile(const QString& File)
6119 {
6120 if (_wrapper) {
6121 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
6122 PyErr_Clear();
6123 if (obj && !PythonQtSlotFunction_Check(obj)) {
6679 bool PythonQtShell_binaryFile::openFile(const QString& File0)
6680 {
6681 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6682 static PyObject* name = PyString_FromString("openFile");
6683 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6684 if (obj) {
6124 6685 static const char* argumentList[] ={"bool" , "const QString&"};
6125 6686 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6126 6687 bool returnValue;
6127 void* args[2] = {NULL, (void*)&File};
6688 void* args[2] = {NULL, (void*)&File0};
6128 6689 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6129 6690 if (result) {
6130 6691 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -6139,20 +6700,22 if (_wrapper) {
6139 6700 if (result) { Py_DECREF(result); }
6140 6701 Py_DECREF(obj);
6141 6702 return returnValue;
6142 }
6143 }
6144 return binaryFile::openFile(File);
6145 }
6146 bool PythonQtShell_binaryFile::toBinary(const QString& fileName)
6147 {
6148 if (_wrapper) {
6149 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
6150 PyErr_Clear();
6151 if (obj && !PythonQtSlotFunction_Check(obj)) {
6703 } else {
6704 PyErr_Clear();
6705 }
6706 }
6707 return binaryFile::openFile(File0);
6708 }
6709 bool PythonQtShell_binaryFile::toBinary(const QString& fileName0)
6710 {
6711 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6712 static PyObject* name = PyString_FromString("toBinary");
6713 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6714 if (obj) {
6152 6715 static const char* argumentList[] ={"bool" , "const QString&"};
6153 6716 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6154 6717 bool returnValue;
6155 void* args[2] = {NULL, (void*)&fileName};
6718 void* args[2] = {NULL, (void*)&fileName0};
6156 6719 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6157 6720 if (result) {
6158 6721 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -6167,20 +6730,22 if (_wrapper) {
6167 6730 if (result) { Py_DECREF(result); }
6168 6731 Py_DECREF(obj);
6169 6732 return returnValue;
6170 }
6171 }
6172 return binaryFile::toBinary(fileName);
6173 }
6174 bool PythonQtShell_binaryFile::toSrec(const QString& fileName)
6175 {
6176 if (_wrapper) {
6177 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
6178 PyErr_Clear();
6179 if (obj && !PythonQtSlotFunction_Check(obj)) {
6733 } else {
6734 PyErr_Clear();
6735 }
6736 }
6737 return binaryFile::toBinary(fileName0);
6738 }
6739 bool PythonQtShell_binaryFile::toSrec(const QString& fileName0)
6740 {
6741 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6742 static PyObject* name = PyString_FromString("toSrec");
6743 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6744 if (obj) {
6180 6745 static const char* argumentList[] ={"bool" , "const QString&"};
6181 6746 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6182 6747 bool returnValue;
6183 void* args[2] = {NULL, (void*)&fileName};
6748 void* args[2] = {NULL, (void*)&fileName0};
6184 6749 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6185 6750 if (result) {
6186 6751 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -6195,9 +6760,11 if (_wrapper) {
6195 6760 if (result) { Py_DECREF(result); }
6196 6761 Py_DECREF(obj);
6197 6762 return returnValue;
6198 }
6199 }
6200 return binaryFile::toSrec(fileName);
6763 } else {
6764 PyErr_Clear();
6765 }
6766 }
6767 return binaryFile::toSrec(fileName0);
6201 6768 }
6202 6769 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile()
6203 6770 {
@@ -6289,10 +6856,10 PythonQtShell_binaryFileWidget::~PythonQ
6289 6856 }
6290 6857 void PythonQtShell_binaryFileWidget::reloadFile()
6291 6858 {
6292 if (_wrapper) {
6293 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
6294 PyErr_Clear();
6295 if (obj && !PythonQtSlotFunction_Check(obj)) {
6859 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6860 static PyObject* name = PyString_FromString("reloadFile");
6861 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6862 if (obj) {
6296 6863 static const char* argumentList[] ={""};
6297 6864 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6298 6865 void* args[1] = {NULL};
@@ -6300,26 +6867,30 if (_wrapper) {
6300 6867 if (result) { Py_DECREF(result); }
6301 6868 Py_DECREF(obj);
6302 6869 return;
6870 } else {
6871 PyErr_Clear();
6303 6872 }
6304 6873 }
6305 6874 binaryFileWidget::reloadFile();
6306 6875 }
6307 void PythonQtShell_binaryFileWidget::setFile(abstractBinFile* file)
6308 {
6309 if (_wrapper) {
6310 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
6311 PyErr_Clear();
6312 if (obj && !PythonQtSlotFunction_Check(obj)) {
6876 void PythonQtShell_binaryFileWidget::setFile(abstractBinFile* file0)
6877 {
6878 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6879 static PyObject* name = PyString_FromString("setFile");
6880 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6881 if (obj) {
6313 6882 static const char* argumentList[] ={"" , "abstractBinFile*"};
6314 6883 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6315 void* args[2] = {NULL, (void*)&file};
6316 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6317 if (result) { Py_DECREF(result); }
6318 Py_DECREF(obj);
6319 return;
6320 }
6321 }
6322 binaryFileWidget::setFile(file);
6884 void* args[2] = {NULL, (void*)&file0};
6885 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6886 if (result) { Py_DECREF(result); }
6887 Py_DECREF(obj);
6888 return;
6889 } else {
6890 PyErr_Clear();
6891 }
6892 }
6893 binaryFileWidget::setFile(file0);
6323 6894 }
6324 6895 binaryFileWidget* PythonQtWrapper_binaryFileWidget::new_binaryFileWidget(QWidget* parent)
6325 6896 {
@@ -6357,10 +6928,10 PythonQtShell_elfFileWidget::~PythonQtSh
6357 6928 }
6358 6929 void PythonQtShell_elfFileWidget::reloadFile()
6359 6930 {
6360 if (_wrapper) {
6361 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
6362 PyErr_Clear();
6363 if (obj && !PythonQtSlotFunction_Check(obj)) {
6931 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6932 static PyObject* name = PyString_FromString("reloadFile");
6933 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6934 if (obj) {
6364 6935 static const char* argumentList[] ={""};
6365 6936 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6366 6937 void* args[1] = {NULL};
@@ -6368,26 +6939,30 if (_wrapper) {
6368 6939 if (result) { Py_DECREF(result); }
6369 6940 Py_DECREF(obj);
6370 6941 return;
6942 } else {
6943 PyErr_Clear();
6371 6944 }
6372 6945 }
6373 6946 elfFileWidget::reloadFile();
6374 6947 }
6375 void PythonQtShell_elfFileWidget::setFile(abstractBinFile* file)
6376 {
6377 if (_wrapper) {
6378 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
6379 PyErr_Clear();
6380 if (obj && !PythonQtSlotFunction_Check(obj)) {
6948 void PythonQtShell_elfFileWidget::setFile(abstractBinFile* file0)
6949 {
6950 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6951 static PyObject* name = PyString_FromString("setFile");
6952 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6953 if (obj) {
6381 6954 static const char* argumentList[] ={"" , "abstractBinFile*"};
6382 6955 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6383 void* args[2] = {NULL, (void*)&file};
6384 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6385 if (result) { Py_DECREF(result); }
6386 Py_DECREF(obj);
6387 return;
6388 }
6389 }
6390 elfFileWidget::setFile(file);
6956 void* args[2] = {NULL, (void*)&file0};
6957 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6958 if (result) { Py_DECREF(result); }
6959 Py_DECREF(obj);
6960 return;
6961 } else {
6962 PyErr_Clear();
6963 }
6964 }
6965 elfFileWidget::setFile(file0);
6391 6966 }
6392 6967 elfFileWidget* PythonQtWrapper_elfFileWidget::new_elfFileWidget(QWidget* parent)
6393 6968 {
@@ -6411,10 +6986,10 PythonQtShell_elfInfoWdgt::~PythonQtShel
6411 6986 }
6412 6987 void PythonQtShell_elfInfoWdgt::actionEvent(QActionEvent* arg__1)
6413 6988 {
6414 if (_wrapper) {
6415 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
6416 PyErr_Clear();
6417 if (obj && !PythonQtSlotFunction_Check(obj)) {
6989 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6990 static PyObject* name = PyString_FromString("actionEvent");
6991 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6992 if (obj) {
6418 6993 static const char* argumentList[] ={"" , "QActionEvent*"};
6419 6994 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6420 6995 void* args[2] = {NULL, (void*)&arg__1};
@@ -6422,16 +6997,18 if (_wrapper) {
6422 6997 if (result) { Py_DECREF(result); }
6423 6998 Py_DECREF(obj);
6424 6999 return;
7000 } else {
7001 PyErr_Clear();
6425 7002 }
6426 7003 }
6427 7004 elfInfoWdgt::actionEvent(arg__1);
6428 7005 }
6429 7006 void PythonQtShell_elfInfoWdgt::changeEvent(QEvent* arg__1)
6430 7007 {
6431 if (_wrapper) {
6432 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
6433 PyErr_Clear();
6434 if (obj && !PythonQtSlotFunction_Check(obj)) {
7008 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7009 static PyObject* name = PyString_FromString("changeEvent");
7010 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7011 if (obj) {
6435 7012 static const char* argumentList[] ={"" , "QEvent*"};
6436 7013 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6437 7014 void* args[2] = {NULL, (void*)&arg__1};
@@ -6439,16 +7016,18 if (_wrapper) {
6439 7016 if (result) { Py_DECREF(result); }
6440 7017 Py_DECREF(obj);
6441 7018 return;
7019 } else {
7020 PyErr_Clear();
6442 7021 }
6443 7022 }
6444 7023 elfInfoWdgt::changeEvent(arg__1);
6445 7024 }
6446 7025 void PythonQtShell_elfInfoWdgt::childEvent(QChildEvent* arg__1)
6447 7026 {
6448 if (_wrapper) {
6449 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
6450 PyErr_Clear();
6451 if (obj && !PythonQtSlotFunction_Check(obj)) {
7027 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7028 static PyObject* name = PyString_FromString("childEvent");
7029 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7030 if (obj) {
6452 7031 static const char* argumentList[] ={"" , "QChildEvent*"};
6453 7032 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6454 7033 void* args[2] = {NULL, (void*)&arg__1};
@@ -6456,16 +7035,18 if (_wrapper) {
6456 7035 if (result) { Py_DECREF(result); }
6457 7036 Py_DECREF(obj);
6458 7037 return;
7038 } else {
7039 PyErr_Clear();
6459 7040 }
6460 7041 }
6461 7042 elfInfoWdgt::childEvent(arg__1);
6462 7043 }
6463 7044 void PythonQtShell_elfInfoWdgt::closeEvent(QCloseEvent* arg__1)
6464 7045 {
6465 if (_wrapper) {
6466 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
6467 PyErr_Clear();
6468 if (obj && !PythonQtSlotFunction_Check(obj)) {
7046 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7047 static PyObject* name = PyString_FromString("closeEvent");
7048 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7049 if (obj) {
6469 7050 static const char* argumentList[] ={"" , "QCloseEvent*"};
6470 7051 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6471 7052 void* args[2] = {NULL, (void*)&arg__1};
@@ -6473,16 +7054,18 if (_wrapper) {
6473 7054 if (result) { Py_DECREF(result); }
6474 7055 Py_DECREF(obj);
6475 7056 return;
7057 } else {
7058 PyErr_Clear();
6476 7059 }
6477 7060 }
6478 7061 elfInfoWdgt::closeEvent(arg__1);
6479 7062 }
6480 7063 void PythonQtShell_elfInfoWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
6481 7064 {
6482 if (_wrapper) {
6483 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
6484 PyErr_Clear();
6485 if (obj && !PythonQtSlotFunction_Check(obj)) {
7065 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7066 static PyObject* name = PyString_FromString("contextMenuEvent");
7067 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7068 if (obj) {
6486 7069 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
6487 7070 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6488 7071 void* args[2] = {NULL, (void*)&arg__1};
@@ -6490,16 +7073,18 if (_wrapper) {
6490 7073 if (result) { Py_DECREF(result); }
6491 7074 Py_DECREF(obj);
6492 7075 return;
7076 } else {
7077 PyErr_Clear();
6493 7078 }
6494 7079 }
6495 7080 elfInfoWdgt::contextMenuEvent(arg__1);
6496 7081 }
6497 7082 void PythonQtShell_elfInfoWdgt::customEvent(QEvent* arg__1)
6498 7083 {
6499 if (_wrapper) {
6500 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
6501 PyErr_Clear();
6502 if (obj && !PythonQtSlotFunction_Check(obj)) {
7084 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7085 static PyObject* name = PyString_FromString("customEvent");
7086 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7087 if (obj) {
6503 7088 static const char* argumentList[] ={"" , "QEvent*"};
6504 7089 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6505 7090 void* args[2] = {NULL, (void*)&arg__1};
@@ -6507,16 +7092,18 if (_wrapper) {
6507 7092 if (result) { Py_DECREF(result); }
6508 7093 Py_DECREF(obj);
6509 7094 return;
7095 } else {
7096 PyErr_Clear();
6510 7097 }
6511 7098 }
6512 7099 elfInfoWdgt::customEvent(arg__1);
6513 7100 }
6514 7101 int PythonQtShell_elfInfoWdgt::devType() const
6515 7102 {
6516 if (_wrapper) {
6517 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
6518 PyErr_Clear();
6519 if (obj && !PythonQtSlotFunction_Check(obj)) {
7103 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7104 static PyObject* name = PyString_FromString("devType");
7105 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7106 if (obj) {
6520 7107 static const char* argumentList[] ={"int"};
6521 7108 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6522 7109 int returnValue;
@@ -6535,16 +7122,18 if (_wrapper) {
6535 7122 if (result) { Py_DECREF(result); }
6536 7123 Py_DECREF(obj);
6537 7124 return returnValue;
7125 } else {
7126 PyErr_Clear();
6538 7127 }
6539 7128 }
6540 7129 return elfInfoWdgt::devType();
6541 7130 }
6542 7131 void PythonQtShell_elfInfoWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
6543 7132 {
6544 if (_wrapper) {
6545 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
6546 PyErr_Clear();
6547 if (obj && !PythonQtSlotFunction_Check(obj)) {
7133 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7134 static PyObject* name = PyString_FromString("dragEnterEvent");
7135 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7136 if (obj) {
6548 7137 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
6549 7138 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6550 7139 void* args[2] = {NULL, (void*)&arg__1};
@@ -6552,16 +7141,18 if (_wrapper) {
6552 7141 if (result) { Py_DECREF(result); }
6553 7142 Py_DECREF(obj);
6554 7143 return;
7144 } else {
7145 PyErr_Clear();
6555 7146 }
6556 7147 }
6557 7148 elfInfoWdgt::dragEnterEvent(arg__1);
6558 7149 }
6559 7150 void PythonQtShell_elfInfoWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
6560 7151 {
6561 if (_wrapper) {
6562 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
6563 PyErr_Clear();
6564 if (obj && !PythonQtSlotFunction_Check(obj)) {
7152 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7153 static PyObject* name = PyString_FromString("dragLeaveEvent");
7154 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7155 if (obj) {
6565 7156 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
6566 7157 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6567 7158 void* args[2] = {NULL, (void*)&arg__1};
@@ -6569,16 +7160,18 if (_wrapper) {
6569 7160 if (result) { Py_DECREF(result); }
6570 7161 Py_DECREF(obj);
6571 7162 return;
7163 } else {
7164 PyErr_Clear();
6572 7165 }
6573 7166 }
6574 7167 elfInfoWdgt::dragLeaveEvent(arg__1);
6575 7168 }
6576 7169 void PythonQtShell_elfInfoWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
6577 7170 {
6578 if (_wrapper) {
6579 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
6580 PyErr_Clear();
6581 if (obj && !PythonQtSlotFunction_Check(obj)) {
7171 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7172 static PyObject* name = PyString_FromString("dragMoveEvent");
7173 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7174 if (obj) {
6582 7175 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
6583 7176 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6584 7177 void* args[2] = {NULL, (void*)&arg__1};
@@ -6586,16 +7179,18 if (_wrapper) {
6586 7179 if (result) { Py_DECREF(result); }
6587 7180 Py_DECREF(obj);
6588 7181 return;
7182 } else {
7183 PyErr_Clear();
6589 7184 }
6590 7185 }
6591 7186 elfInfoWdgt::dragMoveEvent(arg__1);
6592 7187 }
6593 7188 void PythonQtShell_elfInfoWdgt::dropEvent(QDropEvent* arg__1)
6594 7189 {
6595 if (_wrapper) {
6596 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
6597 PyErr_Clear();
6598 if (obj && !PythonQtSlotFunction_Check(obj)) {
7190 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7191 static PyObject* name = PyString_FromString("dropEvent");
7192 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7193 if (obj) {
6599 7194 static const char* argumentList[] ={"" , "QDropEvent*"};
6600 7195 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6601 7196 void* args[2] = {NULL, (void*)&arg__1};
@@ -6603,16 +7198,18 if (_wrapper) {
6603 7198 if (result) { Py_DECREF(result); }
6604 7199 Py_DECREF(obj);
6605 7200 return;
7201 } else {
7202 PyErr_Clear();
6606 7203 }
6607 7204 }
6608 7205 elfInfoWdgt::dropEvent(arg__1);
6609 7206 }
6610 7207 void PythonQtShell_elfInfoWdgt::enterEvent(QEvent* arg__1)
6611 7208 {
6612 if (_wrapper) {
6613 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
6614 PyErr_Clear();
6615 if (obj && !PythonQtSlotFunction_Check(obj)) {
7209 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7210 static PyObject* name = PyString_FromString("enterEvent");
7211 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7212 if (obj) {
6616 7213 static const char* argumentList[] ={"" , "QEvent*"};
6617 7214 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6618 7215 void* args[2] = {NULL, (void*)&arg__1};
@@ -6620,16 +7217,18 if (_wrapper) {
6620 7217 if (result) { Py_DECREF(result); }
6621 7218 Py_DECREF(obj);
6622 7219 return;
7220 } else {
7221 PyErr_Clear();
6623 7222 }
6624 7223 }
6625 7224 elfInfoWdgt::enterEvent(arg__1);
6626 7225 }
6627 7226 bool PythonQtShell_elfInfoWdgt::event(QEvent* arg__1)
6628 7227 {
6629 if (_wrapper) {
6630 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
6631 PyErr_Clear();
6632 if (obj && !PythonQtSlotFunction_Check(obj)) {
7228 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7229 static PyObject* name = PyString_FromString("event");
7230 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7231 if (obj) {
6633 7232 static const char* argumentList[] ={"bool" , "QEvent*"};
6634 7233 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6635 7234 bool returnValue;
@@ -6648,16 +7247,18 if (_wrapper) {
6648 7247 if (result) { Py_DECREF(result); }
6649 7248 Py_DECREF(obj);
6650 7249 return returnValue;
7250 } else {
7251 PyErr_Clear();
6651 7252 }
6652 7253 }
6653 7254 return elfInfoWdgt::event(arg__1);
6654 7255 }
6655 7256 bool PythonQtShell_elfInfoWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
6656 7257 {
6657 if (_wrapper) {
6658 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
6659 PyErr_Clear();
6660 if (obj && !PythonQtSlotFunction_Check(obj)) {
7258 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7259 static PyObject* name = PyString_FromString("eventFilter");
7260 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7261 if (obj) {
6661 7262 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
6662 7263 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
6663 7264 bool returnValue;
@@ -6676,16 +7277,18 if (_wrapper) {
6676 7277 if (result) { Py_DECREF(result); }
6677 7278 Py_DECREF(obj);
6678 7279 return returnValue;
7280 } else {
7281 PyErr_Clear();
6679 7282 }
6680 7283 }
6681 7284 return elfInfoWdgt::eventFilter(arg__1, arg__2);
6682 7285 }
6683 7286 void PythonQtShell_elfInfoWdgt::focusInEvent(QFocusEvent* arg__1)
6684 7287 {
6685 if (_wrapper) {
6686 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
6687 PyErr_Clear();
6688 if (obj && !PythonQtSlotFunction_Check(obj)) {
7288 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7289 static PyObject* name = PyString_FromString("focusInEvent");
7290 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7291 if (obj) {
6689 7292 static const char* argumentList[] ={"" , "QFocusEvent*"};
6690 7293 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6691 7294 void* args[2] = {NULL, (void*)&arg__1};
@@ -6693,20 +7296,22 if (_wrapper) {
6693 7296 if (result) { Py_DECREF(result); }
6694 7297 Py_DECREF(obj);
6695 7298 return;
7299 } else {
7300 PyErr_Clear();
6696 7301 }
6697 7302 }
6698 7303 elfInfoWdgt::focusInEvent(arg__1);
6699 7304 }
6700 bool PythonQtShell_elfInfoWdgt::focusNextPrevChild(bool next)
6701 {
6702 if (_wrapper) {
6703 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
6704 PyErr_Clear();
6705 if (obj && !PythonQtSlotFunction_Check(obj)) {
7305 bool PythonQtShell_elfInfoWdgt::focusNextPrevChild(bool next0)
7306 {
7307 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7308 static PyObject* name = PyString_FromString("focusNextPrevChild");
7309 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7310 if (obj) {
6706 7311 static const char* argumentList[] ={"bool" , "bool"};
6707 7312 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6708 7313 bool returnValue;
6709 void* args[2] = {NULL, (void*)&next};
7314 void* args[2] = {NULL, (void*)&next0};
6710 7315 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6711 7316 if (result) {
6712 7317 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -6721,16 +7326,18 if (_wrapper) {
6721 7326 if (result) { Py_DECREF(result); }
6722 7327 Py_DECREF(obj);
6723 7328 return returnValue;
6724 }
6725 }
6726 return elfInfoWdgt::focusNextPrevChild(next);
7329 } else {
7330 PyErr_Clear();
7331 }
7332 }
7333 return elfInfoWdgt::focusNextPrevChild(next0);
6727 7334 }
6728 7335 void PythonQtShell_elfInfoWdgt::focusOutEvent(QFocusEvent* arg__1)
6729 7336 {
6730 if (_wrapper) {
6731 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
6732 PyErr_Clear();
6733 if (obj && !PythonQtSlotFunction_Check(obj)) {
7337 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7338 static PyObject* name = PyString_FromString("focusOutEvent");
7339 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7340 if (obj) {
6734 7341 static const char* argumentList[] ={"" , "QFocusEvent*"};
6735 7342 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6736 7343 void* args[2] = {NULL, (void*)&arg__1};
@@ -6738,16 +7345,18 if (_wrapper) {
6738 7345 if (result) { Py_DECREF(result); }
6739 7346 Py_DECREF(obj);
6740 7347 return;
7348 } else {
7349 PyErr_Clear();
6741 7350 }
6742 7351 }
6743 7352 elfInfoWdgt::focusOutEvent(arg__1);
6744 7353 }
6745 7354 bool PythonQtShell_elfInfoWdgt::hasHeightForWidth() const
6746 7355 {
6747 if (_wrapper) {
6748 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
6749 PyErr_Clear();
6750 if (obj && !PythonQtSlotFunction_Check(obj)) {
7356 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7357 static PyObject* name = PyString_FromString("hasHeightForWidth");
7358 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7359 if (obj) {
6751 7360 static const char* argumentList[] ={"bool"};
6752 7361 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6753 7362 bool returnValue;
@@ -6766,16 +7375,18 if (_wrapper) {
6766 7375 if (result) { Py_DECREF(result); }
6767 7376 Py_DECREF(obj);
6768 7377 return returnValue;
7378 } else {
7379 PyErr_Clear();
6769 7380 }
6770 7381 }
6771 7382 return elfInfoWdgt::hasHeightForWidth();
6772 7383 }
6773 7384 int PythonQtShell_elfInfoWdgt::heightForWidth(int arg__1) const
6774 7385 {
6775 if (_wrapper) {
6776 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
6777 PyErr_Clear();
6778 if (obj && !PythonQtSlotFunction_Check(obj)) {
7386 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7387 static PyObject* name = PyString_FromString("heightForWidth");
7388 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7389 if (obj) {
6779 7390 static const char* argumentList[] ={"int" , "int"};
6780 7391 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6781 7392 int returnValue;
@@ -6794,16 +7405,18 if (_wrapper) {
6794 7405 if (result) { Py_DECREF(result); }
6795 7406 Py_DECREF(obj);
6796 7407 return returnValue;
7408 } else {
7409 PyErr_Clear();
6797 7410 }
6798 7411 }
6799 7412 return elfInfoWdgt::heightForWidth(arg__1);
6800 7413 }
6801 7414 void PythonQtShell_elfInfoWdgt::hideEvent(QHideEvent* arg__1)
6802 7415 {
6803 if (_wrapper) {
6804 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
6805 PyErr_Clear();
6806 if (obj && !PythonQtSlotFunction_Check(obj)) {
7416 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7417 static PyObject* name = PyString_FromString("hideEvent");
7418 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7419 if (obj) {
6807 7420 static const char* argumentList[] ={"" , "QHideEvent*"};
6808 7421 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6809 7422 void* args[2] = {NULL, (void*)&arg__1};
@@ -6811,33 +7424,37 if (_wrapper) {
6811 7424 if (result) { Py_DECREF(result); }
6812 7425 Py_DECREF(obj);
6813 7426 return;
7427 } else {
7428 PyErr_Clear();
6814 7429 }
6815 7430 }
6816 7431 elfInfoWdgt::hideEvent(arg__1);
6817 7432 }
6818 void PythonQtShell_elfInfoWdgt::initPainter(QPainter* painter) const
6819 {
6820 if (_wrapper) {
6821 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
6822 PyErr_Clear();
6823 if (obj && !PythonQtSlotFunction_Check(obj)) {
7433 void PythonQtShell_elfInfoWdgt::initPainter(QPainter* painter0) const
7434 {
7435 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7436 static PyObject* name = PyString_FromString("initPainter");
7437 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7438 if (obj) {
6824 7439 static const char* argumentList[] ={"" , "QPainter*"};
6825 7440 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6826 void* args[2] = {NULL, (void*)&painter};
6827 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6828 if (result) { Py_DECREF(result); }
6829 Py_DECREF(obj);
6830 return;
6831 }
6832 }
6833 elfInfoWdgt::initPainter(painter);
7441 void* args[2] = {NULL, (void*)&painter0};
7442 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7443 if (result) { Py_DECREF(result); }
7444 Py_DECREF(obj);
7445 return;
7446 } else {
7447 PyErr_Clear();
7448 }
7449 }
7450 elfInfoWdgt::initPainter(painter0);
6834 7451 }
6835 7452 void PythonQtShell_elfInfoWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
6836 7453 {
6837 if (_wrapper) {
6838 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
6839 PyErr_Clear();
6840 if (obj && !PythonQtSlotFunction_Check(obj)) {
7454 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7455 static PyObject* name = PyString_FromString("inputMethodEvent");
7456 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7457 if (obj) {
6841 7458 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
6842 7459 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6843 7460 void* args[2] = {NULL, (void*)&arg__1};
@@ -6845,16 +7462,18 if (_wrapper) {
6845 7462 if (result) { Py_DECREF(result); }
6846 7463 Py_DECREF(obj);
6847 7464 return;
7465 } else {
7466 PyErr_Clear();
6848 7467 }
6849 7468 }
6850 7469 elfInfoWdgt::inputMethodEvent(arg__1);
6851 7470 }
6852 7471 QVariant PythonQtShell_elfInfoWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
6853 7472 {
6854 if (_wrapper) {
6855 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
6856 PyErr_Clear();
6857 if (obj && !PythonQtSlotFunction_Check(obj)) {
7473 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7474 static PyObject* name = PyString_FromString("inputMethodQuery");
7475 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7476 if (obj) {
6858 7477 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
6859 7478 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6860 7479 QVariant returnValue;
@@ -6873,16 +7492,18 if (_wrapper) {
6873 7492 if (result) { Py_DECREF(result); }
6874 7493 Py_DECREF(obj);
6875 7494 return returnValue;
7495 } else {
7496 PyErr_Clear();
6876 7497 }
6877 7498 }
6878 7499 return elfInfoWdgt::inputMethodQuery(arg__1);
6879 7500 }
6880 7501 void PythonQtShell_elfInfoWdgt::keyPressEvent(QKeyEvent* arg__1)
6881 7502 {
6882 if (_wrapper) {
6883 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
6884 PyErr_Clear();
6885 if (obj && !PythonQtSlotFunction_Check(obj)) {
7503 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7504 static PyObject* name = PyString_FromString("keyPressEvent");
7505 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7506 if (obj) {
6886 7507 static const char* argumentList[] ={"" , "QKeyEvent*"};
6887 7508 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6888 7509 void* args[2] = {NULL, (void*)&arg__1};
@@ -6890,16 +7511,18 if (_wrapper) {
6890 7511 if (result) { Py_DECREF(result); }
6891 7512 Py_DECREF(obj);
6892 7513 return;
7514 } else {
7515 PyErr_Clear();
6893 7516 }
6894 7517 }
6895 7518 elfInfoWdgt::keyPressEvent(arg__1);
6896 7519 }
6897 7520 void PythonQtShell_elfInfoWdgt::keyReleaseEvent(QKeyEvent* arg__1)
6898 7521 {
6899 if (_wrapper) {
6900 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
6901 PyErr_Clear();
6902 if (obj && !PythonQtSlotFunction_Check(obj)) {
7522 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7523 static PyObject* name = PyString_FromString("keyReleaseEvent");
7524 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7525 if (obj) {
6903 7526 static const char* argumentList[] ={"" , "QKeyEvent*"};
6904 7527 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6905 7528 void* args[2] = {NULL, (void*)&arg__1};
@@ -6907,16 +7530,18 if (_wrapper) {
6907 7530 if (result) { Py_DECREF(result); }
6908 7531 Py_DECREF(obj);
6909 7532 return;
7533 } else {
7534 PyErr_Clear();
6910 7535 }
6911 7536 }
6912 7537 elfInfoWdgt::keyReleaseEvent(arg__1);
6913 7538 }
6914 7539 void PythonQtShell_elfInfoWdgt::leaveEvent(QEvent* arg__1)
6915 7540 {
6916 if (_wrapper) {
6917 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
6918 PyErr_Clear();
6919 if (obj && !PythonQtSlotFunction_Check(obj)) {
7541 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7542 static PyObject* name = PyString_FromString("leaveEvent");
7543 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7544 if (obj) {
6920 7545 static const char* argumentList[] ={"" , "QEvent*"};
6921 7546 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6922 7547 void* args[2] = {NULL, (void*)&arg__1};
@@ -6924,16 +7549,18 if (_wrapper) {
6924 7549 if (result) { Py_DECREF(result); }
6925 7550 Py_DECREF(obj);
6926 7551 return;
7552 } else {
7553 PyErr_Clear();
6927 7554 }
6928 7555 }
6929 7556 elfInfoWdgt::leaveEvent(arg__1);
6930 7557 }
6931 7558 int PythonQtShell_elfInfoWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
6932 7559 {
6933 if (_wrapper) {
6934 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
6935 PyErr_Clear();
6936 if (obj && !PythonQtSlotFunction_Check(obj)) {
7560 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7561 static PyObject* name = PyString_FromString("metric");
7562 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7563 if (obj) {
6937 7564 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
6938 7565 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6939 7566 int returnValue;
@@ -6952,16 +7579,18 if (_wrapper) {
6952 7579 if (result) { Py_DECREF(result); }
6953 7580 Py_DECREF(obj);
6954 7581 return returnValue;
7582 } else {
7583 PyErr_Clear();
6955 7584 }
6956 7585 }
6957 7586 return elfInfoWdgt::metric(arg__1);
6958 7587 }
6959 7588 QSize PythonQtShell_elfInfoWdgt::minimumSizeHint() const
6960 7589 {
6961 if (_wrapper) {
6962 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
6963 PyErr_Clear();
6964 if (obj && !PythonQtSlotFunction_Check(obj)) {
7590 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7591 static PyObject* name = PyString_FromString("getMinimumSizeHint");
7592 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7593 if (obj) {
6965 7594 static const char* argumentList[] ={"QSize"};
6966 7595 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6967 7596 QSize returnValue;
@@ -6980,16 +7609,18 if (_wrapper) {
6980 7609 if (result) { Py_DECREF(result); }
6981 7610 Py_DECREF(obj);
6982 7611 return returnValue;
7612 } else {
7613 PyErr_Clear();
6983 7614 }
6984 7615 }
6985 7616 return elfInfoWdgt::minimumSizeHint();
6986 7617 }
6987 7618 void PythonQtShell_elfInfoWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
6988 7619 {
6989 if (_wrapper) {
6990 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
6991 PyErr_Clear();
6992 if (obj && !PythonQtSlotFunction_Check(obj)) {
7620 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7621 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
7622 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7623 if (obj) {
6993 7624 static const char* argumentList[] ={"" , "QMouseEvent*"};
6994 7625 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6995 7626 void* args[2] = {NULL, (void*)&arg__1};
@@ -6997,16 +7628,18 if (_wrapper) {
6997 7628 if (result) { Py_DECREF(result); }
6998 7629 Py_DECREF(obj);
6999 7630 return;
7631 } else {
7632 PyErr_Clear();
7000 7633 }
7001 7634 }
7002 7635 elfInfoWdgt::mouseDoubleClickEvent(arg__1);
7003 7636 }
7004 7637 void PythonQtShell_elfInfoWdgt::mouseMoveEvent(QMouseEvent* arg__1)
7005 7638 {
7006 if (_wrapper) {
7007 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
7008 PyErr_Clear();
7009 if (obj && !PythonQtSlotFunction_Check(obj)) {
7639 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7640 static PyObject* name = PyString_FromString("mouseMoveEvent");
7641 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7642 if (obj) {
7010 7643 static const char* argumentList[] ={"" , "QMouseEvent*"};
7011 7644 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7012 7645 void* args[2] = {NULL, (void*)&arg__1};
@@ -7014,16 +7647,18 if (_wrapper) {
7014 7647 if (result) { Py_DECREF(result); }
7015 7648 Py_DECREF(obj);
7016 7649 return;
7650 } else {
7651 PyErr_Clear();
7017 7652 }
7018 7653 }
7019 7654 elfInfoWdgt::mouseMoveEvent(arg__1);
7020 7655 }
7021 7656 void PythonQtShell_elfInfoWdgt::mousePressEvent(QMouseEvent* arg__1)
7022 7657 {
7023 if (_wrapper) {
7024 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
7025 PyErr_Clear();
7026 if (obj && !PythonQtSlotFunction_Check(obj)) {
7658 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7659 static PyObject* name = PyString_FromString("mousePressEvent");
7660 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7661 if (obj) {
7027 7662 static const char* argumentList[] ={"" , "QMouseEvent*"};
7028 7663 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7029 7664 void* args[2] = {NULL, (void*)&arg__1};
@@ -7031,16 +7666,18 if (_wrapper) {
7031 7666 if (result) { Py_DECREF(result); }
7032 7667 Py_DECREF(obj);
7033 7668 return;
7669 } else {
7670 PyErr_Clear();
7034 7671 }
7035 7672 }
7036 7673 elfInfoWdgt::mousePressEvent(arg__1);
7037 7674 }
7038 7675 void PythonQtShell_elfInfoWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
7039 7676 {
7040 if (_wrapper) {
7041 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
7042 PyErr_Clear();
7043 if (obj && !PythonQtSlotFunction_Check(obj)) {
7677 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7678 static PyObject* name = PyString_FromString("mouseReleaseEvent");
7679 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7680 if (obj) {
7044 7681 static const char* argumentList[] ={"" , "QMouseEvent*"};
7045 7682 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7046 7683 void* args[2] = {NULL, (void*)&arg__1};
@@ -7048,16 +7685,18 if (_wrapper) {
7048 7685 if (result) { Py_DECREF(result); }
7049 7686 Py_DECREF(obj);
7050 7687 return;
7688 } else {
7689 PyErr_Clear();
7051 7690 }
7052 7691 }
7053 7692 elfInfoWdgt::mouseReleaseEvent(arg__1);
7054 7693 }
7055 7694 void PythonQtShell_elfInfoWdgt::moveEvent(QMoveEvent* arg__1)
7056 7695 {
7057 if (_wrapper) {
7058 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
7059 PyErr_Clear();
7060 if (obj && !PythonQtSlotFunction_Check(obj)) {
7696 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7697 static PyObject* name = PyString_FromString("moveEvent");
7698 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7699 if (obj) {
7061 7700 static const char* argumentList[] ={"" , "QMoveEvent*"};
7062 7701 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7063 7702 void* args[2] = {NULL, (void*)&arg__1};
@@ -7065,20 +7704,22 if (_wrapper) {
7065 7704 if (result) { Py_DECREF(result); }
7066 7705 Py_DECREF(obj);
7067 7706 return;
7707 } else {
7708 PyErr_Clear();
7068 7709 }
7069 7710 }
7070 7711 elfInfoWdgt::moveEvent(arg__1);
7071 7712 }
7072 bool PythonQtShell_elfInfoWdgt::nativeEvent(const QByteArray& eventType, void* message, long* result)
7073 {
7074 if (_wrapper) {
7075 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
7076 PyErr_Clear();
7077 if (obj && !PythonQtSlotFunction_Check(obj)) {
7713 bool PythonQtShell_elfInfoWdgt::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
7714 {
7715 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7716 static PyObject* name = PyString_FromString("nativeEvent");
7717 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7718 if (obj) {
7078 7719 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
7079 7720 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
7080 7721 bool returnValue;
7081 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
7722 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
7082 7723 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7083 7724 if (result) {
7084 7725 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -7093,16 +7734,18 if (_wrapper) {
7093 7734 if (result) { Py_DECREF(result); }
7094 7735 Py_DECREF(obj);
7095 7736 return returnValue;
7096 }
7097 }
7098 return elfInfoWdgt::nativeEvent(eventType, message, result);
7737 } else {
7738 PyErr_Clear();
7739 }
7740 }
7741 return elfInfoWdgt::nativeEvent(eventType0, message1, result2);
7099 7742 }
7100 7743 QPaintEngine* PythonQtShell_elfInfoWdgt::paintEngine() const
7101 7744 {
7102 if (_wrapper) {
7103 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
7104 PyErr_Clear();
7105 if (obj && !PythonQtSlotFunction_Check(obj)) {
7745 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7746 static PyObject* name = PyString_FromString("paintEngine");
7747 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7748 if (obj) {
7106 7749 static const char* argumentList[] ={"QPaintEngine*"};
7107 7750 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7108 7751 QPaintEngine* returnValue;
@@ -7121,16 +7764,18 if (_wrapper) {
7121 7764 if (result) { Py_DECREF(result); }
7122 7765 Py_DECREF(obj);
7123 7766 return returnValue;
7767 } else {
7768 PyErr_Clear();
7124 7769 }
7125 7770 }
7126 7771 return elfInfoWdgt::paintEngine();
7127 7772 }
7128 7773 void PythonQtShell_elfInfoWdgt::paintEvent(QPaintEvent* arg__1)
7129 7774 {
7130 if (_wrapper) {
7131 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
7132 PyErr_Clear();
7133 if (obj && !PythonQtSlotFunction_Check(obj)) {
7775 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7776 static PyObject* name = PyString_FromString("paintEvent");
7777 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7778 if (obj) {
7134 7779 static const char* argumentList[] ={"" , "QPaintEvent*"};
7135 7780 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7136 7781 void* args[2] = {NULL, (void*)&arg__1};
@@ -7138,20 +7783,22 if (_wrapper) {
7138 7783 if (result) { Py_DECREF(result); }
7139 7784 Py_DECREF(obj);
7140 7785 return;
7786 } else {
7787 PyErr_Clear();
7141 7788 }
7142 7789 }
7143 7790 elfInfoWdgt::paintEvent(arg__1);
7144 7791 }
7145 QPaintDevice* PythonQtShell_elfInfoWdgt::redirected(QPoint* offset) const
7146 {
7147 if (_wrapper) {
7148 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
7149 PyErr_Clear();
7150 if (obj && !PythonQtSlotFunction_Check(obj)) {
7792 QPaintDevice* PythonQtShell_elfInfoWdgt::redirected(QPoint* offset0) const
7793 {
7794 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7795 static PyObject* name = PyString_FromString("redirected");
7796 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7797 if (obj) {
7151 7798 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
7152 7799 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7153 7800 QPaintDevice* returnValue;
7154 void* args[2] = {NULL, (void*)&offset};
7801 void* args[2] = {NULL, (void*)&offset0};
7155 7802 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7156 7803 if (result) {
7157 7804 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -7166,16 +7813,18 if (_wrapper) {
7166 7813 if (result) { Py_DECREF(result); }
7167 7814 Py_DECREF(obj);
7168 7815 return returnValue;
7169 }
7170 }
7171 return elfInfoWdgt::redirected(offset);
7816 } else {
7817 PyErr_Clear();
7818 }
7819 }
7820 return elfInfoWdgt::redirected(offset0);
7172 7821 }
7173 7822 void PythonQtShell_elfInfoWdgt::resizeEvent(QResizeEvent* arg__1)
7174 7823 {
7175 if (_wrapper) {
7176 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
7177 PyErr_Clear();
7178 if (obj && !PythonQtSlotFunction_Check(obj)) {
7824 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7825 static PyObject* name = PyString_FromString("resizeEvent");
7826 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7827 if (obj) {
7179 7828 static const char* argumentList[] ={"" , "QResizeEvent*"};
7180 7829 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7181 7830 void* args[2] = {NULL, (void*)&arg__1};
@@ -7183,16 +7832,18 if (_wrapper) {
7183 7832 if (result) { Py_DECREF(result); }
7184 7833 Py_DECREF(obj);
7185 7834 return;
7835 } else {
7836 PyErr_Clear();
7186 7837 }
7187 7838 }
7188 7839 elfInfoWdgt::resizeEvent(arg__1);
7189 7840 }
7190 7841 QPainter* PythonQtShell_elfInfoWdgt::sharedPainter() const
7191 7842 {
7192 if (_wrapper) {
7193 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
7194 PyErr_Clear();
7195 if (obj && !PythonQtSlotFunction_Check(obj)) {
7843 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7844 static PyObject* name = PyString_FromString("sharedPainter");
7845 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7846 if (obj) {
7196 7847 static const char* argumentList[] ={"QPainter*"};
7197 7848 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7198 7849 QPainter* returnValue;
@@ -7211,16 +7862,18 if (_wrapper) {
7211 7862 if (result) { Py_DECREF(result); }
7212 7863 Py_DECREF(obj);
7213 7864 return returnValue;
7865 } else {
7866 PyErr_Clear();
7214 7867 }
7215 7868 }
7216 7869 return elfInfoWdgt::sharedPainter();
7217 7870 }
7218 7871 void PythonQtShell_elfInfoWdgt::showEvent(QShowEvent* arg__1)
7219 7872 {
7220 if (_wrapper) {
7221 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
7222 PyErr_Clear();
7223 if (obj && !PythonQtSlotFunction_Check(obj)) {
7873 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7874 static PyObject* name = PyString_FromString("showEvent");
7875 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7876 if (obj) {
7224 7877 static const char* argumentList[] ={"" , "QShowEvent*"};
7225 7878 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7226 7879 void* args[2] = {NULL, (void*)&arg__1};
@@ -7228,16 +7881,18 if (_wrapper) {
7228 7881 if (result) { Py_DECREF(result); }
7229 7882 Py_DECREF(obj);
7230 7883 return;
7884 } else {
7885 PyErr_Clear();
7231 7886 }
7232 7887 }
7233 7888 elfInfoWdgt::showEvent(arg__1);
7234 7889 }
7235 7890 QSize PythonQtShell_elfInfoWdgt::sizeHint() const
7236 7891 {
7237 if (_wrapper) {
7238 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
7239 PyErr_Clear();
7240 if (obj && !PythonQtSlotFunction_Check(obj)) {
7892 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7893 static PyObject* name = PyString_FromString("getSizeHint");
7894 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7895 if (obj) {
7241 7896 static const char* argumentList[] ={"QSize"};
7242 7897 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7243 7898 QSize returnValue;
@@ -7256,16 +7911,18 if (_wrapper) {
7256 7911 if (result) { Py_DECREF(result); }
7257 7912 Py_DECREF(obj);
7258 7913 return returnValue;
7914 } else {
7915 PyErr_Clear();
7259 7916 }
7260 7917 }
7261 7918 return elfInfoWdgt::sizeHint();
7262 7919 }
7263 7920 void PythonQtShell_elfInfoWdgt::tabletEvent(QTabletEvent* arg__1)
7264 7921 {
7265 if (_wrapper) {
7266 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
7267 PyErr_Clear();
7268 if (obj && !PythonQtSlotFunction_Check(obj)) {
7922 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7923 static PyObject* name = PyString_FromString("tabletEvent");
7924 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7925 if (obj) {
7269 7926 static const char* argumentList[] ={"" , "QTabletEvent*"};
7270 7927 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7271 7928 void* args[2] = {NULL, (void*)&arg__1};
@@ -7273,16 +7930,18 if (_wrapper) {
7273 7930 if (result) { Py_DECREF(result); }
7274 7931 Py_DECREF(obj);
7275 7932 return;
7933 } else {
7934 PyErr_Clear();
7276 7935 }
7277 7936 }
7278 7937 elfInfoWdgt::tabletEvent(arg__1);
7279 7938 }
7280 7939 void PythonQtShell_elfInfoWdgt::timerEvent(QTimerEvent* arg__1)
7281 7940 {
7282 if (_wrapper) {
7283 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
7284 PyErr_Clear();
7285 if (obj && !PythonQtSlotFunction_Check(obj)) {
7941 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7942 static PyObject* name = PyString_FromString("timerEvent");
7943 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7944 if (obj) {
7286 7945 static const char* argumentList[] ={"" , "QTimerEvent*"};
7287 7946 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7288 7947 void* args[2] = {NULL, (void*)&arg__1};
@@ -7290,16 +7949,18 if (_wrapper) {
7290 7949 if (result) { Py_DECREF(result); }
7291 7950 Py_DECREF(obj);
7292 7951 return;
7952 } else {
7953 PyErr_Clear();
7293 7954 }
7294 7955 }
7295 7956 elfInfoWdgt::timerEvent(arg__1);
7296 7957 }
7297 7958 void PythonQtShell_elfInfoWdgt::wheelEvent(QWheelEvent* arg__1)
7298 7959 {
7299 if (_wrapper) {
7300 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
7301 PyErr_Clear();
7302 if (obj && !PythonQtSlotFunction_Check(obj)) {
7960 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7961 static PyObject* name = PyString_FromString("wheelEvent");
7962 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7963 if (obj) {
7303 7964 static const char* argumentList[] ={"" , "QWheelEvent*"};
7304 7965 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7305 7966 void* args[2] = {NULL, (void*)&arg__1};
@@ -7307,6 +7968,8 if (_wrapper) {
7307 7968 if (result) { Py_DECREF(result); }
7308 7969 Py_DECREF(obj);
7309 7970 return;
7971 } else {
7972 PyErr_Clear();
7310 7973 }
7311 7974 }
7312 7975 elfInfoWdgt::wheelEvent(arg__1);
@@ -7464,10 +8127,10 PythonQtShell_genericBinaryFileWidget::~
7464 8127 }
7465 8128 void PythonQtShell_genericBinaryFileWidget::actionEvent(QActionEvent* arg__1)
7466 8129 {
7467 if (_wrapper) {
7468 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
7469 PyErr_Clear();
7470 if (obj && !PythonQtSlotFunction_Check(obj)) {
8130 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8131 static PyObject* name = PyString_FromString("actionEvent");
8132 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8133 if (obj) {
7471 8134 static const char* argumentList[] ={"" , "QActionEvent*"};
7472 8135 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7473 8136 void* args[2] = {NULL, (void*)&arg__1};
@@ -7475,16 +8138,18 if (_wrapper) {
7475 8138 if (result) { Py_DECREF(result); }
7476 8139 Py_DECREF(obj);
7477 8140 return;
8141 } else {
8142 PyErr_Clear();
7478 8143 }
7479 8144 }
7480 8145 genericBinaryFileWidget::actionEvent(arg__1);
7481 8146 }
7482 8147 void PythonQtShell_genericBinaryFileWidget::changeEvent(QEvent* arg__1)
7483 8148 {
7484 if (_wrapper) {
7485 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
7486 PyErr_Clear();
7487 if (obj && !PythonQtSlotFunction_Check(obj)) {
8149 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8150 static PyObject* name = PyString_FromString("changeEvent");
8151 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8152 if (obj) {
7488 8153 static const char* argumentList[] ={"" , "QEvent*"};
7489 8154 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7490 8155 void* args[2] = {NULL, (void*)&arg__1};
@@ -7492,16 +8157,18 if (_wrapper) {
7492 8157 if (result) { Py_DECREF(result); }
7493 8158 Py_DECREF(obj);
7494 8159 return;
8160 } else {
8161 PyErr_Clear();
7495 8162 }
7496 8163 }
7497 8164 genericBinaryFileWidget::changeEvent(arg__1);
7498 8165 }
7499 8166 void PythonQtShell_genericBinaryFileWidget::childEvent(QChildEvent* arg__1)
7500 8167 {
7501 if (_wrapper) {
7502 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
7503 PyErr_Clear();
7504 if (obj && !PythonQtSlotFunction_Check(obj)) {
8168 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8169 static PyObject* name = PyString_FromString("childEvent");
8170 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8171 if (obj) {
7505 8172 static const char* argumentList[] ={"" , "QChildEvent*"};
7506 8173 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7507 8174 void* args[2] = {NULL, (void*)&arg__1};
@@ -7509,16 +8176,18 if (_wrapper) {
7509 8176 if (result) { Py_DECREF(result); }
7510 8177 Py_DECREF(obj);
7511 8178 return;
8179 } else {
8180 PyErr_Clear();
7512 8181 }
7513 8182 }
7514 8183 genericBinaryFileWidget::childEvent(arg__1);
7515 8184 }
7516 8185 void PythonQtShell_genericBinaryFileWidget::closeEvent(QCloseEvent* arg__1)
7517 8186 {
7518 if (_wrapper) {
7519 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
7520 PyErr_Clear();
7521 if (obj && !PythonQtSlotFunction_Check(obj)) {
8187 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8188 static PyObject* name = PyString_FromString("closeEvent");
8189 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8190 if (obj) {
7522 8191 static const char* argumentList[] ={"" , "QCloseEvent*"};
7523 8192 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7524 8193 void* args[2] = {NULL, (void*)&arg__1};
@@ -7526,16 +8195,18 if (_wrapper) {
7526 8195 if (result) { Py_DECREF(result); }
7527 8196 Py_DECREF(obj);
7528 8197 return;
8198 } else {
8199 PyErr_Clear();
7529 8200 }
7530 8201 }
7531 8202 genericBinaryFileWidget::closeEvent(arg__1);
7532 8203 }
7533 8204 void PythonQtShell_genericBinaryFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
7534 8205 {
7535 if (_wrapper) {
7536 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
7537 PyErr_Clear();
7538 if (obj && !PythonQtSlotFunction_Check(obj)) {
8206 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8207 static PyObject* name = PyString_FromString("contextMenuEvent");
8208 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8209 if (obj) {
7539 8210 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
7540 8211 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7541 8212 void* args[2] = {NULL, (void*)&arg__1};
@@ -7543,16 +8214,18 if (_wrapper) {
7543 8214 if (result) { Py_DECREF(result); }
7544 8215 Py_DECREF(obj);
7545 8216 return;
8217 } else {
8218 PyErr_Clear();
7546 8219 }
7547 8220 }
7548 8221 genericBinaryFileWidget::contextMenuEvent(arg__1);
7549 8222 }
7550 8223 void PythonQtShell_genericBinaryFileWidget::customEvent(QEvent* arg__1)
7551 8224 {
7552 if (_wrapper) {
7553 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
7554 PyErr_Clear();
7555 if (obj && !PythonQtSlotFunction_Check(obj)) {
8225 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8226 static PyObject* name = PyString_FromString("customEvent");
8227 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8228 if (obj) {
7556 8229 static const char* argumentList[] ={"" , "QEvent*"};
7557 8230 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7558 8231 void* args[2] = {NULL, (void*)&arg__1};
@@ -7560,16 +8233,18 if (_wrapper) {
7560 8233 if (result) { Py_DECREF(result); }
7561 8234 Py_DECREF(obj);
7562 8235 return;
8236 } else {
8237 PyErr_Clear();
7563 8238 }
7564 8239 }
7565 8240 genericBinaryFileWidget::customEvent(arg__1);
7566 8241 }
7567 8242 int PythonQtShell_genericBinaryFileWidget::devType() const
7568 8243 {
7569 if (_wrapper) {
7570 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
7571 PyErr_Clear();
7572 if (obj && !PythonQtSlotFunction_Check(obj)) {
8244 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8245 static PyObject* name = PyString_FromString("devType");
8246 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8247 if (obj) {
7573 8248 static const char* argumentList[] ={"int"};
7574 8249 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7575 8250 int returnValue;
@@ -7588,16 +8263,18 if (_wrapper) {
7588 8263 if (result) { Py_DECREF(result); }
7589 8264 Py_DECREF(obj);
7590 8265 return returnValue;
8266 } else {
8267 PyErr_Clear();
7591 8268 }
7592 8269 }
7593 8270 return genericBinaryFileWidget::devType();
7594 8271 }
7595 8272 void PythonQtShell_genericBinaryFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
7596 8273 {
7597 if (_wrapper) {
7598 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
7599 PyErr_Clear();
7600 if (obj && !PythonQtSlotFunction_Check(obj)) {
8274 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8275 static PyObject* name = PyString_FromString("dragEnterEvent");
8276 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8277 if (obj) {
7601 8278 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
7602 8279 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7603 8280 void* args[2] = {NULL, (void*)&arg__1};
@@ -7605,16 +8282,18 if (_wrapper) {
7605 8282 if (result) { Py_DECREF(result); }
7606 8283 Py_DECREF(obj);
7607 8284 return;
8285 } else {
8286 PyErr_Clear();
7608 8287 }
7609 8288 }
7610 8289 genericBinaryFileWidget::dragEnterEvent(arg__1);
7611 8290 }
7612 8291 void PythonQtShell_genericBinaryFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
7613 8292 {
7614 if (_wrapper) {
7615 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
7616 PyErr_Clear();
7617 if (obj && !PythonQtSlotFunction_Check(obj)) {
8293 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8294 static PyObject* name = PyString_FromString("dragLeaveEvent");
8295 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8296 if (obj) {
7618 8297 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
7619 8298 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7620 8299 void* args[2] = {NULL, (void*)&arg__1};
@@ -7622,16 +8301,18 if (_wrapper) {
7622 8301 if (result) { Py_DECREF(result); }
7623 8302 Py_DECREF(obj);
7624 8303 return;
8304 } else {
8305 PyErr_Clear();
7625 8306 }
7626 8307 }
7627 8308 genericBinaryFileWidget::dragLeaveEvent(arg__1);
7628 8309 }
7629 8310 void PythonQtShell_genericBinaryFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
7630 8311 {
7631 if (_wrapper) {
7632 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
7633 PyErr_Clear();
7634 if (obj && !PythonQtSlotFunction_Check(obj)) {
8312 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8313 static PyObject* name = PyString_FromString("dragMoveEvent");
8314 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8315 if (obj) {
7635 8316 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
7636 8317 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7637 8318 void* args[2] = {NULL, (void*)&arg__1};
@@ -7639,16 +8320,18 if (_wrapper) {
7639 8320 if (result) { Py_DECREF(result); }
7640 8321 Py_DECREF(obj);
7641 8322 return;
8323 } else {
8324 PyErr_Clear();
7642 8325 }
7643 8326 }
7644 8327 genericBinaryFileWidget::dragMoveEvent(arg__1);
7645 8328 }
7646 8329 void PythonQtShell_genericBinaryFileWidget::dropEvent(QDropEvent* arg__1)
7647 8330 {
7648 if (_wrapper) {
7649 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
7650 PyErr_Clear();
7651 if (obj && !PythonQtSlotFunction_Check(obj)) {
8331 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8332 static PyObject* name = PyString_FromString("dropEvent");
8333 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8334 if (obj) {
7652 8335 static const char* argumentList[] ={"" , "QDropEvent*"};
7653 8336 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7654 8337 void* args[2] = {NULL, (void*)&arg__1};
@@ -7656,16 +8339,18 if (_wrapper) {
7656 8339 if (result) { Py_DECREF(result); }
7657 8340 Py_DECREF(obj);
7658 8341 return;
8342 } else {
8343 PyErr_Clear();
7659 8344 }
7660 8345 }
7661 8346 genericBinaryFileWidget::dropEvent(arg__1);
7662 8347 }
7663 8348 void PythonQtShell_genericBinaryFileWidget::enterEvent(QEvent* arg__1)
7664 8349 {
7665 if (_wrapper) {
7666 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
7667 PyErr_Clear();
7668 if (obj && !PythonQtSlotFunction_Check(obj)) {
8350 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8351 static PyObject* name = PyString_FromString("enterEvent");
8352 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8353 if (obj) {
7669 8354 static const char* argumentList[] ={"" , "QEvent*"};
7670 8355 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7671 8356 void* args[2] = {NULL, (void*)&arg__1};
@@ -7673,16 +8358,18 if (_wrapper) {
7673 8358 if (result) { Py_DECREF(result); }
7674 8359 Py_DECREF(obj);
7675 8360 return;
8361 } else {
8362 PyErr_Clear();
7676 8363 }
7677 8364 }
7678 8365 genericBinaryFileWidget::enterEvent(arg__1);
7679 8366 }
7680 8367 bool PythonQtShell_genericBinaryFileWidget::event(QEvent* arg__1)
7681 8368 {
7682 if (_wrapper) {
7683 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
7684 PyErr_Clear();
7685 if (obj && !PythonQtSlotFunction_Check(obj)) {
8369 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8370 static PyObject* name = PyString_FromString("event");
8371 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8372 if (obj) {
7686 8373 static const char* argumentList[] ={"bool" , "QEvent*"};
7687 8374 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7688 8375 bool returnValue;
@@ -7701,16 +8388,18 if (_wrapper) {
7701 8388 if (result) { Py_DECREF(result); }
7702 8389 Py_DECREF(obj);
7703 8390 return returnValue;
8391 } else {
8392 PyErr_Clear();
7704 8393 }
7705 8394 }
7706 8395 return genericBinaryFileWidget::event(arg__1);
7707 8396 }
7708 8397 bool PythonQtShell_genericBinaryFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
7709 8398 {
7710 if (_wrapper) {
7711 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
7712 PyErr_Clear();
7713 if (obj && !PythonQtSlotFunction_Check(obj)) {
8399 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8400 static PyObject* name = PyString_FromString("eventFilter");
8401 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8402 if (obj) {
7714 8403 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
7715 8404 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
7716 8405 bool returnValue;
@@ -7729,16 +8418,18 if (_wrapper) {
7729 8418 if (result) { Py_DECREF(result); }
7730 8419 Py_DECREF(obj);
7731 8420 return returnValue;
8421 } else {
8422 PyErr_Clear();
7732 8423 }
7733 8424 }
7734 8425 return genericBinaryFileWidget::eventFilter(arg__1, arg__2);
7735 8426 }
7736 8427 void PythonQtShell_genericBinaryFileWidget::focusInEvent(QFocusEvent* arg__1)
7737 8428 {
7738 if (_wrapper) {
7739 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
7740 PyErr_Clear();
7741 if (obj && !PythonQtSlotFunction_Check(obj)) {
8429 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8430 static PyObject* name = PyString_FromString("focusInEvent");
8431 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8432 if (obj) {
7742 8433 static const char* argumentList[] ={"" , "QFocusEvent*"};
7743 8434 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7744 8435 void* args[2] = {NULL, (void*)&arg__1};
@@ -7746,20 +8437,22 if (_wrapper) {
7746 8437 if (result) { Py_DECREF(result); }
7747 8438 Py_DECREF(obj);
7748 8439 return;
8440 } else {
8441 PyErr_Clear();
7749 8442 }
7750 8443 }
7751 8444 genericBinaryFileWidget::focusInEvent(arg__1);
7752 8445 }
7753 bool PythonQtShell_genericBinaryFileWidget::focusNextPrevChild(bool next)
7754 {
7755 if (_wrapper) {
7756 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
7757 PyErr_Clear();
7758 if (obj && !PythonQtSlotFunction_Check(obj)) {
8446 bool PythonQtShell_genericBinaryFileWidget::focusNextPrevChild(bool next0)
8447 {
8448 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8449 static PyObject* name = PyString_FromString("focusNextPrevChild");
8450 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8451 if (obj) {
7759 8452 static const char* argumentList[] ={"bool" , "bool"};
7760 8453 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7761 8454 bool returnValue;
7762 void* args[2] = {NULL, (void*)&next};
8455 void* args[2] = {NULL, (void*)&next0};
7763 8456 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7764 8457 if (result) {
7765 8458 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -7774,16 +8467,18 if (_wrapper) {
7774 8467 if (result) { Py_DECREF(result); }
7775 8468 Py_DECREF(obj);
7776 8469 return returnValue;
7777 }
7778 }
7779 return genericBinaryFileWidget::focusNextPrevChild(next);
8470 } else {
8471 PyErr_Clear();
8472 }
8473 }
8474 return genericBinaryFileWidget::focusNextPrevChild(next0);
7780 8475 }
7781 8476 void PythonQtShell_genericBinaryFileWidget::focusOutEvent(QFocusEvent* arg__1)
7782 8477 {
7783 if (_wrapper) {
7784 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
7785 PyErr_Clear();
7786 if (obj && !PythonQtSlotFunction_Check(obj)) {
8478 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8479 static PyObject* name = PyString_FromString("focusOutEvent");
8480 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8481 if (obj) {
7787 8482 static const char* argumentList[] ={"" , "QFocusEvent*"};
7788 8483 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7789 8484 void* args[2] = {NULL, (void*)&arg__1};
@@ -7791,16 +8486,18 if (_wrapper) {
7791 8486 if (result) { Py_DECREF(result); }
7792 8487 Py_DECREF(obj);
7793 8488 return;
8489 } else {
8490 PyErr_Clear();
7794 8491 }
7795 8492 }
7796 8493 genericBinaryFileWidget::focusOutEvent(arg__1);
7797 8494 }
7798 8495 bool PythonQtShell_genericBinaryFileWidget::hasHeightForWidth() const
7799 8496 {
7800 if (_wrapper) {
7801 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
7802 PyErr_Clear();
7803 if (obj && !PythonQtSlotFunction_Check(obj)) {
8497 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8498 static PyObject* name = PyString_FromString("hasHeightForWidth");
8499 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8500 if (obj) {
7804 8501 static const char* argumentList[] ={"bool"};
7805 8502 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7806 8503 bool returnValue;
@@ -7819,16 +8516,18 if (_wrapper) {
7819 8516 if (result) { Py_DECREF(result); }
7820 8517 Py_DECREF(obj);
7821 8518 return returnValue;
8519 } else {
8520 PyErr_Clear();
7822 8521 }
7823 8522 }
7824 8523 return genericBinaryFileWidget::hasHeightForWidth();
7825 8524 }
7826 8525 int PythonQtShell_genericBinaryFileWidget::heightForWidth(int arg__1) const
7827 8526 {
7828 if (_wrapper) {
7829 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
7830 PyErr_Clear();
7831 if (obj && !PythonQtSlotFunction_Check(obj)) {
8527 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8528 static PyObject* name = PyString_FromString("heightForWidth");
8529 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8530 if (obj) {
7832 8531 static const char* argumentList[] ={"int" , "int"};
7833 8532 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7834 8533 int returnValue;
@@ -7847,16 +8546,18 if (_wrapper) {
7847 8546 if (result) { Py_DECREF(result); }
7848 8547 Py_DECREF(obj);
7849 8548 return returnValue;
8549 } else {
8550 PyErr_Clear();
7850 8551 }
7851 8552 }
7852 8553 return genericBinaryFileWidget::heightForWidth(arg__1);
7853 8554 }
7854 8555 void PythonQtShell_genericBinaryFileWidget::hideEvent(QHideEvent* arg__1)
7855 8556 {
7856 if (_wrapper) {
7857 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
7858 PyErr_Clear();
7859 if (obj && !PythonQtSlotFunction_Check(obj)) {
8557 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8558 static PyObject* name = PyString_FromString("hideEvent");
8559 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8560 if (obj) {
7860 8561 static const char* argumentList[] ={"" , "QHideEvent*"};
7861 8562 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7862 8563 void* args[2] = {NULL, (void*)&arg__1};
@@ -7864,33 +8565,37 if (_wrapper) {
7864 8565 if (result) { Py_DECREF(result); }
7865 8566 Py_DECREF(obj);
7866 8567 return;
8568 } else {
8569 PyErr_Clear();
7867 8570 }
7868 8571 }
7869 8572 genericBinaryFileWidget::hideEvent(arg__1);
7870 8573 }
7871 void PythonQtShell_genericBinaryFileWidget::initPainter(QPainter* painter) const
7872 {
7873 if (_wrapper) {
7874 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
7875 PyErr_Clear();
7876 if (obj && !PythonQtSlotFunction_Check(obj)) {
8574 void PythonQtShell_genericBinaryFileWidget::initPainter(QPainter* painter0) const
8575 {
8576 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8577 static PyObject* name = PyString_FromString("initPainter");
8578 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8579 if (obj) {
7877 8580 static const char* argumentList[] ={"" , "QPainter*"};
7878 8581 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7879 void* args[2] = {NULL, (void*)&painter};
7880 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7881 if (result) { Py_DECREF(result); }
7882 Py_DECREF(obj);
7883 return;
7884 }
7885 }
7886 genericBinaryFileWidget::initPainter(painter);
8582 void* args[2] = {NULL, (void*)&painter0};
8583 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8584 if (result) { Py_DECREF(result); }
8585 Py_DECREF(obj);
8586 return;
8587 } else {
8588 PyErr_Clear();
8589 }
8590 }
8591 genericBinaryFileWidget::initPainter(painter0);
7887 8592 }
7888 8593 void PythonQtShell_genericBinaryFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
7889 8594 {
7890 if (_wrapper) {
7891 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
7892 PyErr_Clear();
7893 if (obj && !PythonQtSlotFunction_Check(obj)) {
8595 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8596 static PyObject* name = PyString_FromString("inputMethodEvent");
8597 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8598 if (obj) {
7894 8599 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
7895 8600 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7896 8601 void* args[2] = {NULL, (void*)&arg__1};
@@ -7898,16 +8603,18 if (_wrapper) {
7898 8603 if (result) { Py_DECREF(result); }
7899 8604 Py_DECREF(obj);
7900 8605 return;
8606 } else {
8607 PyErr_Clear();
7901 8608 }
7902 8609 }
7903 8610 genericBinaryFileWidget::inputMethodEvent(arg__1);
7904 8611 }
7905 8612 QVariant PythonQtShell_genericBinaryFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
7906 8613 {
7907 if (_wrapper) {
7908 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
7909 PyErr_Clear();
7910 if (obj && !PythonQtSlotFunction_Check(obj)) {
8614 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8615 static PyObject* name = PyString_FromString("inputMethodQuery");
8616 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8617 if (obj) {
7911 8618 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
7912 8619 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7913 8620 QVariant returnValue;
@@ -7926,16 +8633,18 if (_wrapper) {
7926 8633 if (result) { Py_DECREF(result); }
7927 8634 Py_DECREF(obj);
7928 8635 return returnValue;
8636 } else {
8637 PyErr_Clear();
7929 8638 }
7930 8639 }
7931 8640 return genericBinaryFileWidget::inputMethodQuery(arg__1);
7932 8641 }
7933 8642 void PythonQtShell_genericBinaryFileWidget::keyPressEvent(QKeyEvent* arg__1)
7934 8643 {
7935 if (_wrapper) {
7936 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
7937 PyErr_Clear();
7938 if (obj && !PythonQtSlotFunction_Check(obj)) {
8644 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8645 static PyObject* name = PyString_FromString("keyPressEvent");
8646 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8647 if (obj) {
7939 8648 static const char* argumentList[] ={"" , "QKeyEvent*"};
7940 8649 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7941 8650 void* args[2] = {NULL, (void*)&arg__1};
@@ -7943,16 +8652,18 if (_wrapper) {
7943 8652 if (result) { Py_DECREF(result); }
7944 8653 Py_DECREF(obj);
7945 8654 return;
8655 } else {
8656 PyErr_Clear();
7946 8657 }
7947 8658 }
7948 8659 genericBinaryFileWidget::keyPressEvent(arg__1);
7949 8660 }
7950 8661 void PythonQtShell_genericBinaryFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
7951 8662 {
7952 if (_wrapper) {
7953 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
7954 PyErr_Clear();
7955 if (obj && !PythonQtSlotFunction_Check(obj)) {
8663 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8664 static PyObject* name = PyString_FromString("keyReleaseEvent");
8665 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8666 if (obj) {
7956 8667 static const char* argumentList[] ={"" , "QKeyEvent*"};
7957 8668 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7958 8669 void* args[2] = {NULL, (void*)&arg__1};
@@ -7960,16 +8671,18 if (_wrapper) {
7960 8671 if (result) { Py_DECREF(result); }
7961 8672 Py_DECREF(obj);
7962 8673 return;
8674 } else {
8675 PyErr_Clear();
7963 8676 }
7964 8677 }
7965 8678 genericBinaryFileWidget::keyReleaseEvent(arg__1);
7966 8679 }
7967 8680 void PythonQtShell_genericBinaryFileWidget::leaveEvent(QEvent* arg__1)
7968 8681 {
7969 if (_wrapper) {
7970 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
7971 PyErr_Clear();
7972 if (obj && !PythonQtSlotFunction_Check(obj)) {
8682 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8683 static PyObject* name = PyString_FromString("leaveEvent");
8684 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8685 if (obj) {
7973 8686 static const char* argumentList[] ={"" , "QEvent*"};
7974 8687 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7975 8688 void* args[2] = {NULL, (void*)&arg__1};
@@ -7977,16 +8690,18 if (_wrapper) {
7977 8690 if (result) { Py_DECREF(result); }
7978 8691 Py_DECREF(obj);
7979 8692 return;
8693 } else {
8694 PyErr_Clear();
7980 8695 }
7981 8696 }
7982 8697 genericBinaryFileWidget::leaveEvent(arg__1);
7983 8698 }
7984 8699 int PythonQtShell_genericBinaryFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
7985 8700 {
7986 if (_wrapper) {
7987 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
7988 PyErr_Clear();
7989 if (obj && !PythonQtSlotFunction_Check(obj)) {
8701 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8702 static PyObject* name = PyString_FromString("metric");
8703 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8704 if (obj) {
7990 8705 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
7991 8706 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7992 8707 int returnValue;
@@ -8005,16 +8720,18 if (_wrapper) {
8005 8720 if (result) { Py_DECREF(result); }
8006 8721 Py_DECREF(obj);
8007 8722 return returnValue;
8723 } else {
8724 PyErr_Clear();
8008 8725 }
8009 8726 }
8010 8727 return genericBinaryFileWidget::metric(arg__1);
8011 8728 }
8012 8729 QSize PythonQtShell_genericBinaryFileWidget::minimumSizeHint() const
8013 8730 {
8014 if (_wrapper) {
8015 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
8016 PyErr_Clear();
8017 if (obj && !PythonQtSlotFunction_Check(obj)) {
8731 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8732 static PyObject* name = PyString_FromString("getMinimumSizeHint");
8733 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8734 if (obj) {
8018 8735 static const char* argumentList[] ={"QSize"};
8019 8736 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8020 8737 QSize returnValue;
@@ -8033,16 +8750,18 if (_wrapper) {
8033 8750 if (result) { Py_DECREF(result); }
8034 8751 Py_DECREF(obj);
8035 8752 return returnValue;
8753 } else {
8754 PyErr_Clear();
8036 8755 }
8037 8756 }
8038 8757 return genericBinaryFileWidget::minimumSizeHint();
8039 8758 }
8040 8759 void PythonQtShell_genericBinaryFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
8041 8760 {
8042 if (_wrapper) {
8043 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
8044 PyErr_Clear();
8045 if (obj && !PythonQtSlotFunction_Check(obj)) {
8761 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8762 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
8763 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8764 if (obj) {
8046 8765 static const char* argumentList[] ={"" , "QMouseEvent*"};
8047 8766 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8048 8767 void* args[2] = {NULL, (void*)&arg__1};
@@ -8050,16 +8769,18 if (_wrapper) {
8050 8769 if (result) { Py_DECREF(result); }
8051 8770 Py_DECREF(obj);
8052 8771 return;
8772 } else {
8773 PyErr_Clear();
8053 8774 }
8054 8775 }
8055 8776 genericBinaryFileWidget::mouseDoubleClickEvent(arg__1);
8056 8777 }
8057 8778 void PythonQtShell_genericBinaryFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
8058 8779 {
8059 if (_wrapper) {
8060 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
8061 PyErr_Clear();
8062 if (obj && !PythonQtSlotFunction_Check(obj)) {
8780 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8781 static PyObject* name = PyString_FromString("mouseMoveEvent");
8782 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8783 if (obj) {
8063 8784 static const char* argumentList[] ={"" , "QMouseEvent*"};
8064 8785 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8065 8786 void* args[2] = {NULL, (void*)&arg__1};
@@ -8067,16 +8788,18 if (_wrapper) {
8067 8788 if (result) { Py_DECREF(result); }
8068 8789 Py_DECREF(obj);
8069 8790 return;
8791 } else {
8792 PyErr_Clear();
8070 8793 }
8071 8794 }
8072 8795 genericBinaryFileWidget::mouseMoveEvent(arg__1);
8073 8796 }
8074 8797 void PythonQtShell_genericBinaryFileWidget::mousePressEvent(QMouseEvent* arg__1)
8075 8798 {
8076 if (_wrapper) {
8077 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
8078 PyErr_Clear();
8079 if (obj && !PythonQtSlotFunction_Check(obj)) {
8799 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8800 static PyObject* name = PyString_FromString("mousePressEvent");
8801 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8802 if (obj) {
8080 8803 static const char* argumentList[] ={"" , "QMouseEvent*"};
8081 8804 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8082 8805 void* args[2] = {NULL, (void*)&arg__1};
@@ -8084,16 +8807,18 if (_wrapper) {
8084 8807 if (result) { Py_DECREF(result); }
8085 8808 Py_DECREF(obj);
8086 8809 return;
8810 } else {
8811 PyErr_Clear();
8087 8812 }
8088 8813 }
8089 8814 genericBinaryFileWidget::mousePressEvent(arg__1);
8090 8815 }
8091 8816 void PythonQtShell_genericBinaryFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
8092 8817 {
8093 if (_wrapper) {
8094 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
8095 PyErr_Clear();
8096 if (obj && !PythonQtSlotFunction_Check(obj)) {
8818 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8819 static PyObject* name = PyString_FromString("mouseReleaseEvent");
8820 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8821 if (obj) {
8097 8822 static const char* argumentList[] ={"" , "QMouseEvent*"};
8098 8823 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8099 8824 void* args[2] = {NULL, (void*)&arg__1};
@@ -8101,16 +8826,18 if (_wrapper) {
8101 8826 if (result) { Py_DECREF(result); }
8102 8827 Py_DECREF(obj);
8103 8828 return;
8829 } else {
8830 PyErr_Clear();
8104 8831 }
8105 8832 }
8106 8833 genericBinaryFileWidget::mouseReleaseEvent(arg__1);
8107 8834 }
8108 8835 void PythonQtShell_genericBinaryFileWidget::moveEvent(QMoveEvent* arg__1)
8109 8836 {
8110 if (_wrapper) {
8111 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
8112 PyErr_Clear();
8113 if (obj && !PythonQtSlotFunction_Check(obj)) {
8837 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8838 static PyObject* name = PyString_FromString("moveEvent");
8839 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8840 if (obj) {
8114 8841 static const char* argumentList[] ={"" , "QMoveEvent*"};
8115 8842 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8116 8843 void* args[2] = {NULL, (void*)&arg__1};
@@ -8118,20 +8845,22 if (_wrapper) {
8118 8845 if (result) { Py_DECREF(result); }
8119 8846 Py_DECREF(obj);
8120 8847 return;
8848 } else {
8849 PyErr_Clear();
8121 8850 }
8122 8851 }
8123 8852 genericBinaryFileWidget::moveEvent(arg__1);
8124 8853 }
8125 bool PythonQtShell_genericBinaryFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result)
8126 {
8127 if (_wrapper) {
8128 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
8129 PyErr_Clear();
8130 if (obj && !PythonQtSlotFunction_Check(obj)) {
8854 bool PythonQtShell_genericBinaryFileWidget::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
8855 {
8856 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8857 static PyObject* name = PyString_FromString("nativeEvent");
8858 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8859 if (obj) {
8131 8860 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
8132 8861 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
8133 8862 bool returnValue;
8134 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
8863 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
8135 8864 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8136 8865 if (result) {
8137 8866 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -8146,16 +8875,18 if (_wrapper) {
8146 8875 if (result) { Py_DECREF(result); }
8147 8876 Py_DECREF(obj);
8148 8877 return returnValue;
8149 }
8150 }
8151 return genericBinaryFileWidget::nativeEvent(eventType, message, result);
8878 } else {
8879 PyErr_Clear();
8880 }
8881 }
8882 return genericBinaryFileWidget::nativeEvent(eventType0, message1, result2);
8152 8883 }
8153 8884 QPaintEngine* PythonQtShell_genericBinaryFileWidget::paintEngine() const
8154 8885 {
8155 if (_wrapper) {
8156 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
8157 PyErr_Clear();
8158 if (obj && !PythonQtSlotFunction_Check(obj)) {
8886 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8887 static PyObject* name = PyString_FromString("paintEngine");
8888 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8889 if (obj) {
8159 8890 static const char* argumentList[] ={"QPaintEngine*"};
8160 8891 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8161 8892 QPaintEngine* returnValue;
@@ -8174,16 +8905,18 if (_wrapper) {
8174 8905 if (result) { Py_DECREF(result); }
8175 8906 Py_DECREF(obj);
8176 8907 return returnValue;
8908 } else {
8909 PyErr_Clear();
8177 8910 }
8178 8911 }
8179 8912 return genericBinaryFileWidget::paintEngine();
8180 8913 }
8181 8914 void PythonQtShell_genericBinaryFileWidget::paintEvent(QPaintEvent* arg__1)
8182 8915 {
8183 if (_wrapper) {
8184 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
8185 PyErr_Clear();
8186 if (obj && !PythonQtSlotFunction_Check(obj)) {
8916 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8917 static PyObject* name = PyString_FromString("paintEvent");
8918 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8919 if (obj) {
8187 8920 static const char* argumentList[] ={"" , "QPaintEvent*"};
8188 8921 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8189 8922 void* args[2] = {NULL, (void*)&arg__1};
@@ -8191,20 +8924,22 if (_wrapper) {
8191 8924 if (result) { Py_DECREF(result); }
8192 8925 Py_DECREF(obj);
8193 8926 return;
8927 } else {
8928 PyErr_Clear();
8194 8929 }
8195 8930 }
8196 8931 genericBinaryFileWidget::paintEvent(arg__1);
8197 8932 }
8198 QPaintDevice* PythonQtShell_genericBinaryFileWidget::redirected(QPoint* offset) const
8199 {
8200 if (_wrapper) {
8201 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
8202 PyErr_Clear();
8203 if (obj && !PythonQtSlotFunction_Check(obj)) {
8933 QPaintDevice* PythonQtShell_genericBinaryFileWidget::redirected(QPoint* offset0) const
8934 {
8935 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8936 static PyObject* name = PyString_FromString("redirected");
8937 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8938 if (obj) {
8204 8939 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
8205 8940 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8206 8941 QPaintDevice* returnValue;
8207 void* args[2] = {NULL, (void*)&offset};
8942 void* args[2] = {NULL, (void*)&offset0};
8208 8943 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8209 8944 if (result) {
8210 8945 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -8219,16 +8954,18 if (_wrapper) {
8219 8954 if (result) { Py_DECREF(result); }
8220 8955 Py_DECREF(obj);
8221 8956 return returnValue;
8222 }
8223 }
8224 return genericBinaryFileWidget::redirected(offset);
8957 } else {
8958 PyErr_Clear();
8959 }
8960 }
8961 return genericBinaryFileWidget::redirected(offset0);
8225 8962 }
8226 8963 void PythonQtShell_genericBinaryFileWidget::resizeEvent(QResizeEvent* arg__1)
8227 8964 {
8228 if (_wrapper) {
8229 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
8230 PyErr_Clear();
8231 if (obj && !PythonQtSlotFunction_Check(obj)) {
8965 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8966 static PyObject* name = PyString_FromString("resizeEvent");
8967 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8968 if (obj) {
8232 8969 static const char* argumentList[] ={"" , "QResizeEvent*"};
8233 8970 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8234 8971 void* args[2] = {NULL, (void*)&arg__1};
@@ -8236,16 +8973,18 if (_wrapper) {
8236 8973 if (result) { Py_DECREF(result); }
8237 8974 Py_DECREF(obj);
8238 8975 return;
8976 } else {
8977 PyErr_Clear();
8239 8978 }
8240 8979 }
8241 8980 genericBinaryFileWidget::resizeEvent(arg__1);
8242 8981 }
8243 8982 QPainter* PythonQtShell_genericBinaryFileWidget::sharedPainter() const
8244 8983 {
8245 if (_wrapper) {
8246 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
8247 PyErr_Clear();
8248 if (obj && !PythonQtSlotFunction_Check(obj)) {
8984 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8985 static PyObject* name = PyString_FromString("sharedPainter");
8986 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8987 if (obj) {
8249 8988 static const char* argumentList[] ={"QPainter*"};
8250 8989 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8251 8990 QPainter* returnValue;
@@ -8264,16 +9003,18 if (_wrapper) {
8264 9003 if (result) { Py_DECREF(result); }
8265 9004 Py_DECREF(obj);
8266 9005 return returnValue;
9006 } else {
9007 PyErr_Clear();
8267 9008 }
8268 9009 }
8269 9010 return genericBinaryFileWidget::sharedPainter();
8270 9011 }
8271 9012 void PythonQtShell_genericBinaryFileWidget::showEvent(QShowEvent* arg__1)
8272 9013 {
8273 if (_wrapper) {
8274 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
8275 PyErr_Clear();
8276 if (obj && !PythonQtSlotFunction_Check(obj)) {
9014 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9015 static PyObject* name = PyString_FromString("showEvent");
9016 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9017 if (obj) {
8277 9018 static const char* argumentList[] ={"" , "QShowEvent*"};
8278 9019 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8279 9020 void* args[2] = {NULL, (void*)&arg__1};
@@ -8281,16 +9022,18 if (_wrapper) {
8281 9022 if (result) { Py_DECREF(result); }
8282 9023 Py_DECREF(obj);
8283 9024 return;
9025 } else {
9026 PyErr_Clear();
8284 9027 }
8285 9028 }
8286 9029 genericBinaryFileWidget::showEvent(arg__1);
8287 9030 }
8288 9031 QSize PythonQtShell_genericBinaryFileWidget::sizeHint() const
8289 9032 {
8290 if (_wrapper) {
8291 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
8292 PyErr_Clear();
8293 if (obj && !PythonQtSlotFunction_Check(obj)) {
9033 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9034 static PyObject* name = PyString_FromString("getSizeHint");
9035 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9036 if (obj) {
8294 9037 static const char* argumentList[] ={"QSize"};
8295 9038 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8296 9039 QSize returnValue;
@@ -8309,16 +9052,18 if (_wrapper) {
8309 9052 if (result) { Py_DECREF(result); }
8310 9053 Py_DECREF(obj);
8311 9054 return returnValue;
9055 } else {
9056 PyErr_Clear();
8312 9057 }
8313 9058 }
8314 9059 return genericBinaryFileWidget::sizeHint();
8315 9060 }
8316 9061 void PythonQtShell_genericBinaryFileWidget::tabletEvent(QTabletEvent* arg__1)
8317 9062 {
8318 if (_wrapper) {
8319 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
8320 PyErr_Clear();
8321 if (obj && !PythonQtSlotFunction_Check(obj)) {
9063 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9064 static PyObject* name = PyString_FromString("tabletEvent");
9065 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9066 if (obj) {
8322 9067 static const char* argumentList[] ={"" , "QTabletEvent*"};
8323 9068 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8324 9069 void* args[2] = {NULL, (void*)&arg__1};
@@ -8326,16 +9071,18 if (_wrapper) {
8326 9071 if (result) { Py_DECREF(result); }
8327 9072 Py_DECREF(obj);
8328 9073 return;
9074 } else {
9075 PyErr_Clear();
8329 9076 }
8330 9077 }
8331 9078 genericBinaryFileWidget::tabletEvent(arg__1);
8332 9079 }
8333 9080 void PythonQtShell_genericBinaryFileWidget::timerEvent(QTimerEvent* arg__1)
8334 9081 {
8335 if (_wrapper) {
8336 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
8337 PyErr_Clear();
8338 if (obj && !PythonQtSlotFunction_Check(obj)) {
9082 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9083 static PyObject* name = PyString_FromString("timerEvent");
9084 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9085 if (obj) {
8339 9086 static const char* argumentList[] ={"" , "QTimerEvent*"};
8340 9087 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8341 9088 void* args[2] = {NULL, (void*)&arg__1};
@@ -8343,16 +9090,18 if (_wrapper) {
8343 9090 if (result) { Py_DECREF(result); }
8344 9091 Py_DECREF(obj);
8345 9092 return;
9093 } else {
9094 PyErr_Clear();
8346 9095 }
8347 9096 }
8348 9097 genericBinaryFileWidget::timerEvent(arg__1);
8349 9098 }
8350 9099 void PythonQtShell_genericBinaryFileWidget::wheelEvent(QWheelEvent* arg__1)
8351 9100 {
8352 if (_wrapper) {
8353 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
8354 PyErr_Clear();
8355 if (obj && !PythonQtSlotFunction_Check(obj)) {
9101 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9102 static PyObject* name = PyString_FromString("wheelEvent");
9103 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9104 if (obj) {
8356 9105 static const char* argumentList[] ={"" , "QWheelEvent*"};
8357 9106 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8358 9107 void* args[2] = {NULL, (void*)&arg__1};
@@ -8360,6 +9109,8 if (_wrapper) {
8360 9109 if (result) { Py_DECREF(result); }
8361 9110 Py_DECREF(obj);
8362 9111 return;
9112 } else {
9113 PyErr_Clear();
8363 9114 }
8364 9115 }
8365 9116 genericBinaryFileWidget::wheelEvent(arg__1);
@@ -8376,10 +9127,10 PythonQtShell_srecFile::~PythonQtShell_s
8376 9127 }
8377 9128 int PythonQtShell_srecFile::closeFile()
8378 9129 {
8379 if (_wrapper) {
8380 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
8381 PyErr_Clear();
8382 if (obj && !PythonQtSlotFunction_Check(obj)) {
9130 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9131 static PyObject* name = PyString_FromString("closeFile");
9132 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9133 if (obj) {
8383 9134 static const char* argumentList[] ={"int"};
8384 9135 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8385 9136 int returnValue;
@@ -8398,16 +9149,18 if (_wrapper) {
8398 9149 if (result) { Py_DECREF(result); }
8399 9150 Py_DECREF(obj);
8400 9151 return returnValue;
9152 } else {
9153 PyErr_Clear();
8401 9154 }
8402 9155 }
8403 9156 return srecFile::closeFile();
8404 9157 }
8405 9158 QList<codeFragment* > PythonQtShell_srecFile::getFragments()
8406 9159 {
8407 if (_wrapper) {
8408 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
8409 PyErr_Clear();
8410 if (obj && !PythonQtSlotFunction_Check(obj)) {
9160 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9161 static PyObject* name = PyString_FromString("getFragments");
9162 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9163 if (obj) {
8411 9164 static const char* argumentList[] ={"QList<codeFragment* >"};
8412 9165 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8413 9166 QList<codeFragment* > returnValue;
@@ -8426,16 +9179,18 if (_wrapper) {
8426 9179 if (result) { Py_DECREF(result); }
8427 9180 Py_DECREF(obj);
8428 9181 return returnValue;
9182 } else {
9183 PyErr_Clear();
8429 9184 }
8430 9185 }
8431 9186 return srecFile::getFragments();
8432 9187 }
8433 9188 bool PythonQtShell_srecFile::isopened()
8434 9189 {
8435 if (_wrapper) {
8436 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
8437 PyErr_Clear();
8438 if (obj && !PythonQtSlotFunction_Check(obj)) {
9190 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9191 static PyObject* name = PyString_FromString("isopened");
9192 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9193 if (obj) {
8439 9194 static const char* argumentList[] ={"bool"};
8440 9195 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8441 9196 bool returnValue;
@@ -8454,20 +9209,22 if (_wrapper) {
8454 9209 if (result) { Py_DECREF(result); }
8455 9210 Py_DECREF(obj);
8456 9211 return returnValue;
9212 } else {
9213 PyErr_Clear();
8457 9214 }
8458 9215 }
8459 9216 return srecFile::isopened();
8460 9217 }
8461 bool PythonQtShell_srecFile::openFile(const QString& File)
8462 {
8463 if (_wrapper) {
8464 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
8465 PyErr_Clear();
8466 if (obj && !PythonQtSlotFunction_Check(obj)) {
9218 bool PythonQtShell_srecFile::openFile(const QString& File0)
9219 {
9220 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9221 static PyObject* name = PyString_FromString("openFile");
9222 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9223 if (obj) {
8467 9224 static const char* argumentList[] ={"bool" , "const QString&"};
8468 9225 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8469 9226 bool returnValue;
8470 void* args[2] = {NULL, (void*)&File};
9227 void* args[2] = {NULL, (void*)&File0};
8471 9228 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8472 9229 if (result) {
8473 9230 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -8482,20 +9239,22 if (_wrapper) {
8482 9239 if (result) { Py_DECREF(result); }
8483 9240 Py_DECREF(obj);
8484 9241 return returnValue;
8485 }
8486 }
8487 return srecFile::openFile(File);
8488 }
8489 bool PythonQtShell_srecFile::toBinary(const QString& File)
8490 {
8491 if (_wrapper) {
8492 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
8493 PyErr_Clear();
8494 if (obj && !PythonQtSlotFunction_Check(obj)) {
9242 } else {
9243 PyErr_Clear();
9244 }
9245 }
9246 return srecFile::openFile(File0);
9247 }
9248 bool PythonQtShell_srecFile::toBinary(const QString& File0)
9249 {
9250 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9251 static PyObject* name = PyString_FromString("toBinary");
9252 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9253 if (obj) {
8495 9254 static const char* argumentList[] ={"bool" , "const QString&"};
8496 9255 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8497 9256 bool returnValue;
8498 void* args[2] = {NULL, (void*)&File};
9257 void* args[2] = {NULL, (void*)&File0};
8499 9258 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8500 9259 if (result) {
8501 9260 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -8510,20 +9269,22 if (_wrapper) {
8510 9269 if (result) { Py_DECREF(result); }
8511 9270 Py_DECREF(obj);
8512 9271 return returnValue;
8513 }
8514 }
8515 return srecFile::toBinary(File);
8516 }
8517 bool PythonQtShell_srecFile::toSrec(const QString& File)
8518 {
8519 if (_wrapper) {
8520 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
8521 PyErr_Clear();
8522 if (obj && !PythonQtSlotFunction_Check(obj)) {
9272 } else {
9273 PyErr_Clear();
9274 }
9275 }
9276 return srecFile::toBinary(File0);
9277 }
9278 bool PythonQtShell_srecFile::toSrec(const QString& File0)
9279 {
9280 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9281 static PyObject* name = PyString_FromString("toSrec");
9282 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9283 if (obj) {
8523 9284 static const char* argumentList[] ={"bool" , "const QString&"};
8524 9285 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8525 9286 bool returnValue;
8526 void* args[2] = {NULL, (void*)&File};
9287 void* args[2] = {NULL, (void*)&File0};
8527 9288 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8528 9289 if (result) {
8529 9290 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -8538,9 +9299,11 if (_wrapper) {
8538 9299 if (result) { Py_DECREF(result); }
8539 9300 Py_DECREF(obj);
8540 9301 return returnValue;
8541 }
8542 }
8543 return srecFile::toSrec(File);
9302 } else {
9303 PyErr_Clear();
9304 }
9305 }
9306 return srecFile::toSrec(File0);
8544 9307 }
8545 9308 srecFile* PythonQtWrapper_srecFile::new_srecFile()
8546 9309 {
@@ -8662,10 +9425,10 PythonQtShell_srecFileWidget::~PythonQtS
8662 9425 }
8663 9426 void PythonQtShell_srecFileWidget::reloadFile()
8664 9427 {
8665 if (_wrapper) {
8666 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
8667 PyErr_Clear();
8668 if (obj && !PythonQtSlotFunction_Check(obj)) {
9428 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9429 static PyObject* name = PyString_FromString("reloadFile");
9430 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9431 if (obj) {
8669 9432 static const char* argumentList[] ={""};
8670 9433 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8671 9434 void* args[1] = {NULL};
@@ -8673,26 +9436,30 if (_wrapper) {
8673 9436 if (result) { Py_DECREF(result); }
8674 9437 Py_DECREF(obj);
8675 9438 return;
9439 } else {
9440 PyErr_Clear();
8676 9441 }
8677 9442 }
8678 9443 srecFileWidget::reloadFile();
8679 9444 }
8680 void PythonQtShell_srecFileWidget::setFile(abstractBinFile* file)
8681 {
8682 if (_wrapper) {
8683 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
8684 PyErr_Clear();
8685 if (obj && !PythonQtSlotFunction_Check(obj)) {
9445 void PythonQtShell_srecFileWidget::setFile(abstractBinFile* file0)
9446 {
9447 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9448 static PyObject* name = PyString_FromString("setFile");
9449 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9450 if (obj) {
8686 9451 static const char* argumentList[] ={"" , "abstractBinFile*"};
8687 9452 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8688 void* args[2] = {NULL, (void*)&file};
8689 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8690 if (result) { Py_DECREF(result); }
8691 Py_DECREF(obj);
8692 return;
8693 }
8694 }
8695 srecFileWidget::setFile(file);
9453 void* args[2] = {NULL, (void*)&file0};
9454 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9455 if (result) { Py_DECREF(result); }
9456 Py_DECREF(obj);
9457 return;
9458 } else {
9459 PyErr_Clear();
9460 }
9461 }
9462 srecFileWidget::setFile(file0);
8696 9463 }
8697 9464 srecFileWidget* PythonQtWrapper_srecFileWidget::new_srecFileWidget(QWidget* parent)
8698 9465 {
Show file before | Show file after | Hide comments
@@ -1,5 +1,4
1 1 #include <PythonQt.h>
2 #include <QIconEngine>
3 2 #include <QObject>
4 3 #include <QVariant>
5 4 #include <SocExplorerPlot.h>
@@ -13,6 +12,7
13 12 #include <genericbinaryfilewidget.h>
14 13 #include <memsizewdgt.h>
15 14 #include <qaction.h>
15 #include <qbackingstore.h>
16 16 #include <qbitmap.h>
17 17 #include <qbytearray.h>
18 18 #include <qcolor.h>
@@ -25,12 +25,14
25 25 #include <qgraphicsproxywidget.h>
26 26 #include <qhexedit.h>
27 27 #include <qhexspinbox.h>
28 #include <qicon.h>
28 29 #include <qkeysequence.h>
29 30 #include <qlayout.h>
30 31 #include <qlineedit.h>
31 32 #include <qlist.h>
32 33 #include <qlocale.h>
33 34 #include <qmargins.h>
35 #include <qmetaobject.h>
34 36 #include <qobject.h>
35 37 #include <qpaintdevice.h>
36 38 #include <qpaintengine.h>
@@ -50,6 +52,7
50 52 #include <qstyle.h>
51 53 #include <qstyleoption.h>
52 54 #include <qwidget.h>
55 #include <qwindow.h>
53 56 #include <srecfile.h>
54 57 #include <srecfilewidget.h>
55 58 #include <tcp_terminal_client.h>
@@ -60,8 +63,8
60 63 class PythonQtShell_ElfFile : public ElfFile
61 64 {
62 65 public:
63 PythonQtShell_ElfFile():ElfFile(),_wrapper(NULL) {};
64 PythonQtShell_ElfFile(const QString& File):ElfFile(File),_wrapper(NULL) {};
66 PythonQtShell_ElfFile():ElfFile(),_wrapper(NULL) { };
67 PythonQtShell_ElfFile(const QString& File):ElfFile(File),_wrapper(NULL) { };
65 68
66 69 ~PythonQtShell_ElfFile();
67 70
@@ -126,7 +129,9 void delete_ElfFile(ElfFile* obj) { dele
126 129 QString getSymbolType(ElfFile* theWrappedObject, int index);
127 130 QString getType(ElfFile* theWrappedObject);
128 131 qint64 getVersion(ElfFile* theWrappedObject);
132 bool isBigEndian(ElfFile* theWrappedObject);
129 133 bool static_ElfFile_isElf(const QString& File);
134 bool isLitleEndian(ElfFile* theWrappedObject);
130 135 bool iself(ElfFile* theWrappedObject);
131 136 bool isopened(ElfFile* theWrappedObject);
132 137 bool openFile(ElfFile* theWrappedObject, const QString& File);
@@ -142,8 +147,8 void delete_ElfFile(ElfFile* obj) { dele
142 147 class PythonQtShell_MemSizeWdgt : public MemSizeWdgt
143 148 {
144 149 public:
145 PythonQtShell_MemSizeWdgt(QWidget* parent = 0):MemSizeWdgt(parent),_wrapper(NULL) {};
146 PythonQtShell_MemSizeWdgt(int defaultSize, QWidget* parent = 0):MemSizeWdgt(defaultSize, parent),_wrapper(NULL) {};
150 PythonQtShell_MemSizeWdgt(QWidget* parent = 0):MemSizeWdgt(parent),_wrapper(NULL) { };
151 PythonQtShell_MemSizeWdgt(int defaultSize, QWidget* parent = 0):MemSizeWdgt(defaultSize, parent),_wrapper(NULL) { };
147 152
148 153 ~PythonQtShell_MemSizeWdgt();
149 154
@@ -215,7 +220,7 void delete_MemSizeWdgt(MemSizeWdgt* obj
215 220 class PythonQtShell_QHexEdit : public QHexEdit
216 221 {
217 222 public:
218 PythonQtShell_QHexEdit(QWidget* parent = 0):QHexEdit(parent),_wrapper(NULL) {};
223 PythonQtShell_QHexEdit(QWidget* parent = 0):QHexEdit(parent),_wrapper(NULL) { };
219 224
220 225 ~PythonQtShell_QHexEdit();
221 226
@@ -315,7 +320,7 void delete_QHexEdit(QHexEdit* obj) { de
315 320 class PythonQtShell_QHexSpinBox : public QHexSpinBox
316 321 {
317 322 public:
318 PythonQtShell_QHexSpinBox(QWidget* parent = 0):QHexSpinBox(parent),_wrapper(NULL) {};
323 PythonQtShell_QHexSpinBox(QWidget* parent = 0):QHexSpinBox(parent),_wrapper(NULL) { };
319 324
320 325 ~PythonQtShell_QHexSpinBox();
321 326
@@ -398,7 +403,7 void delete_QHexSpinBox(QHexSpinBox* obj
398 403 class PythonQtShell_SocExplorerPlot : public SocExplorerPlot
399 404 {
400 405 public:
401 PythonQtShell_SocExplorerPlot(QWidget* parent = 0):SocExplorerPlot(parent),_wrapper(NULL) {};
406 PythonQtShell_SocExplorerPlot(QWidget* parent = 0):SocExplorerPlot(parent),_wrapper(NULL) { };
402 407
403 408 ~PythonQtShell_SocExplorerPlot();
404 409
@@ -500,7 +505,7 void delete_SocExplorerPlot(SocExplorerP
500 505 class PythonQtShell_TCP_Terminal_Client : public TCP_Terminal_Client
501 506 {
502 507 public:
503 PythonQtShell_TCP_Terminal_Client(QObject* parent = 0):TCP_Terminal_Client(parent),_wrapper(NULL) {};
508 PythonQtShell_TCP_Terminal_Client(QObject* parent = 0):TCP_Terminal_Client(parent),_wrapper(NULL) { };
504 509
505 510 ~PythonQtShell_TCP_Terminal_Client();
506 511
@@ -566,7 +571,7 void delete_XByteArray(XByteArray* obj)
566 571 class PythonQtShell_abstractBinFile : public abstractBinFile
567 572 {
568 573 public:
569 PythonQtShell_abstractBinFile():abstractBinFile(),_wrapper(NULL) {};
574 PythonQtShell_abstractBinFile():abstractBinFile(),_wrapper(NULL) { };
570 575
571 576 ~PythonQtShell_abstractBinFile();
572 577
@@ -585,12 +590,30 virtual bool toSrec(const QString& Fil
585 590 PythonQtInstanceWrapper* _wrapper;
586 591 };
587 592
593 class PythonQtPublicPromoter_abstractBinFile : public abstractBinFile
594 { public:
595 inline int promoted_closeFile() { return closeFile(); }
596 inline QList<codeFragment* > promoted_getFragments() { return getFragments(); }
597 inline bool promoted_isopened() { return isopened(); }
598 inline bool promoted_openFile(const QString& File) { return openFile(File); }
599 inline bool promoted_toBinary(const QString& File) { return toBinary(File); }
600 inline bool promoted_toSrec(const QString& File) { return toSrec(File); }
601 };
602
588 603 class PythonQtWrapper_abstractBinFile : public QObject
589 604 { Q_OBJECT
590 605 public:
591 606 public slots:
592 607 abstractBinFile* new_abstractBinFile();
593 608 void delete_abstractBinFile(abstractBinFile* obj) { delete obj; }
609 int closeFile(abstractBinFile* theWrappedObject);
610 QList<codeFragment* > getFragments(abstractBinFile* theWrappedObject);
611 bool isopened(abstractBinFile* theWrappedObject);
612 bool openFile(abstractBinFile* theWrappedObject, const QString& File);
613 bool toBinary(abstractBinFile* theWrappedObject, const QString& File);
614 bool toSrec(abstractBinFile* theWrappedObject, const QString& File);
615 void py_set_litleendian(abstractBinFile* theWrappedObject, bool litleendian){ theWrappedObject->litleendian = litleendian; }
616 bool py_get_litleendian(abstractBinFile* theWrappedObject){ return theWrappedObject->litleendian; }
594 617 };
595 618
596 619
@@ -600,7 +623,7 void delete_abstractBinFile(abstractBinF
600 623 class PythonQtShell_abstractBinFileWidget : public abstractBinFileWidget
601 624 {
602 625 public:
603 PythonQtShell_abstractBinFileWidget(QWidget* parent = 0):abstractBinFileWidget(parent),_wrapper(NULL) {};
626 PythonQtShell_abstractBinFileWidget(QWidget* parent = 0):abstractBinFileWidget(parent),_wrapper(NULL) { };
604 627
605 628 ~PythonQtShell_abstractBinFileWidget();
606 629
@@ -654,12 +677,20 virtual void wheelEvent(QWheelEvent* ar
654 677 PythonQtInstanceWrapper* _wrapper;
655 678 };
656 679
680 class PythonQtPublicPromoter_abstractBinFileWidget : public abstractBinFileWidget
681 { public:
682 inline void promoted_reloadFile() { reloadFile(); }
683 inline void promoted_setFile(abstractBinFile* file) { setFile(file); }
684 };
685
657 686 class PythonQtWrapper_abstractBinFileWidget : public QObject
658 687 { Q_OBJECT
659 688 public:
660 689 public slots:
661 690 abstractBinFileWidget* new_abstractBinFileWidget(QWidget* parent = 0);
662 691 void delete_abstractBinFileWidget(abstractBinFileWidget* obj) { delete obj; }
692 void reloadFile(abstractBinFileWidget* theWrappedObject);
693 void setFile(abstractBinFileWidget* theWrappedObject, abstractBinFile* file);
663 694 };
664 695
665 696
@@ -669,9 +700,9 void delete_abstractBinFileWidget(abstra
669 700 class PythonQtShell_binaryFile : public binaryFile
670 701 {
671 702 public:
672 PythonQtShell_binaryFile():binaryFile(),_wrapper(NULL) {};
673 PythonQtShell_binaryFile(const QString& File):binaryFile(File),_wrapper(NULL) {};
674 PythonQtShell_binaryFile(const QStringList& Files):binaryFile(Files),_wrapper(NULL) {};
703 PythonQtShell_binaryFile():binaryFile(),_wrapper(NULL) { };
704 PythonQtShell_binaryFile(const QString& File):binaryFile(File),_wrapper(NULL) { };
705 PythonQtShell_binaryFile(const QStringList& Files):binaryFile(Files),_wrapper(NULL) { };
675 706
676 707 ~PythonQtShell_binaryFile();
677 708
@@ -726,7 +757,7 void delete_binaryFile(binaryFile* obj)
726 757 class PythonQtShell_binaryFileWidget : public binaryFileWidget
727 758 {
728 759 public:
729 PythonQtShell_binaryFileWidget(QWidget* parent = 0):binaryFileWidget(parent),_wrapper(NULL) {};
760 PythonQtShell_binaryFileWidget(QWidget* parent = 0):binaryFileWidget(parent),_wrapper(NULL) { };
730 761
731 762 ~PythonQtShell_binaryFileWidget();
732 763
@@ -759,8 +790,8 void delete_binaryFileWidget(binaryFileW
759 790 class PythonQtShell_codeFragment : public codeFragment
760 791 {
761 792 public:
762 PythonQtShell_codeFragment():codeFragment(),_wrapper(NULL) {};
763 PythonQtShell_codeFragment(char* data, quint64 size, quint64 address):codeFragment(data, size, address),_wrapper(NULL) {};
793 PythonQtShell_codeFragment():codeFragment(),_wrapper(NULL) { };
794 PythonQtShell_codeFragment(char* data, quint64 size, quint64 address):codeFragment(data, size, address),_wrapper(NULL) { };
764 795
765 796 ~PythonQtShell_codeFragment();
766 797
@@ -775,14 +806,14 public slots:
775 806 codeFragment* new_codeFragment();
776 807 codeFragment* new_codeFragment(char* data, quint64 size, quint64 address);
777 808 void delete_codeFragment(codeFragment* obj) { delete obj; }
778 void py_set_size(codeFragment* theWrappedObject, quint64 size){ theWrappedObject->size = size; }
779 quint64 py_get_size(codeFragment* theWrappedObject){ return theWrappedObject->size; }
809 void py_set_address(codeFragment* theWrappedObject, quint64 address){ theWrappedObject->address = address; }
810 quint64 py_get_address(codeFragment* theWrappedObject){ return theWrappedObject->address; }
780 811 void py_set_data(codeFragment* theWrappedObject, char* data){ theWrappedObject->data = data; }
781 812 char* py_get_data(codeFragment* theWrappedObject){ return theWrappedObject->data; }
782 void py_set_address(codeFragment* theWrappedObject, quint64 address){ theWrappedObject->address = address; }
783 quint64 py_get_address(codeFragment* theWrappedObject){ return theWrappedObject->address; }
784 813 void py_set_header(codeFragment* theWrappedObject, QString header){ theWrappedObject->header = header; }
785 814 QString py_get_header(codeFragment* theWrappedObject){ return theWrappedObject->header; }
815 void py_set_size(codeFragment* theWrappedObject, quint64 size){ theWrappedObject->size = size; }
816 quint64 py_get_size(codeFragment* theWrappedObject){ return theWrappedObject->size; }
786 817 };
787 818
788 819
@@ -792,7 +823,7 QString py_get_header(codeFragment* the
792 823 class PythonQtShell_elfFileWidget : public elfFileWidget
793 824 {
794 825 public:
795 PythonQtShell_elfFileWidget(QWidget* parent = 0):elfFileWidget(parent),_wrapper(NULL) {};
826 PythonQtShell_elfFileWidget(QWidget* parent = 0):elfFileWidget(parent),_wrapper(NULL) { };
796 827
797 828 ~PythonQtShell_elfFileWidget();
798 829
@@ -825,7 +856,7 void delete_elfFileWidget(elfFileWidget*
825 856 class PythonQtShell_elfInfoWdgt : public elfInfoWdgt
826 857 {
827 858 public:
828 PythonQtShell_elfInfoWdgt(QWidget* parent = 0):elfInfoWdgt(parent),_wrapper(NULL) {};
859 PythonQtShell_elfInfoWdgt(QWidget* parent = 0):elfInfoWdgt(parent),_wrapper(NULL) { };
829 860
830 861 ~PythonQtShell_elfInfoWdgt();
831 862
@@ -931,7 +962,7 void delete_elfparser(elfparser* obj) {
931 962 class PythonQtShell_genericBinaryFileWidget : public genericBinaryFileWidget
932 963 {
933 964 public:
934 PythonQtShell_genericBinaryFileWidget(QWidget* parent = 0):genericBinaryFileWidget(parent),_wrapper(NULL) {};
965 PythonQtShell_genericBinaryFileWidget(QWidget* parent = 0):genericBinaryFileWidget(parent),_wrapper(NULL) { };
935 966
936 967 ~PythonQtShell_genericBinaryFileWidget();
937 968
@@ -998,9 +1029,9 void delete_genericBinaryFileWidget(gene
998 1029 class PythonQtShell_srecFile : public srecFile
999 1030 {
1000 1031 public:
1001 PythonQtShell_srecFile():srecFile(),_wrapper(NULL) {};
1002 PythonQtShell_srecFile(const QString& File):srecFile(File),_wrapper(NULL) {};
1003 PythonQtShell_srecFile(const QStringList& Files):srecFile(Files),_wrapper(NULL) {};
1032 PythonQtShell_srecFile():srecFile(),_wrapper(NULL) { };
1033 PythonQtShell_srecFile(const QString& File):srecFile(File),_wrapper(NULL) { };
1034 PythonQtShell_srecFile(const QStringList& Files):srecFile(Files),_wrapper(NULL) { };
1004 1035
1005 1036 ~PythonQtShell_srecFile();
1006 1037
@@ -1061,7 +1092,7 void delete_srecFile(srecFile* obj) { de
1061 1092 class PythonQtShell_srecFileWidget : public srecFileWidget
1062 1093 {
1063 1094 public:
1064 PythonQtShell_srecFileWidget(QWidget* parent = 0):srecFileWidget(parent),_wrapper(NULL) {};
1095 PythonQtShell_srecFileWidget(QWidget* parent = 0):srecFileWidget(parent),_wrapper(NULL) { };
1065 1096
1066 1097 ~PythonQtShell_srecFileWidget();
1067 1098
Show file before | Show file after | Hide comments
@@ -1,7 +1,9
1 1 #include <PythonQt.h>
2 #include <PythonQtConversion.h>
2 3 #include "PySocExplorer0.h"
3 4
4 5
6
5 7 void PythonQt_init_PySocExplorer(PyObject* module) {
6 8 PythonQt::priv()->registerClass(&ElfFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_ElfFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_ElfFile>, module, 0);
7 9 PythonQt::self()->addParentClass("ElfFile", "abstractBinFile",PythonQtUpcastingOffset<ElfFile,abstractBinFile>());
@@ -28,4 +30,5 PythonQt::self()->addParentClass("srecFi
28 30 PythonQt::priv()->registerClass(&srecFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_srecFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_srecFileWidget>, module, 0);
29 31 PythonQt::self()->addParentClass("srecFileWidget", "abstractBinFileWidget",PythonQtUpcastingOffset<srecFileWidget,abstractBinFileWidget>());
30 32
33
31 34 }
Show file before | Show file after | Hide comments
@@ -30,13 +30,10
30 30 #include <QStringList>
31 31 #include <QFile>
32 32
33 void usage();
33 34
34 35 int main(int argc, char *argv[])
35 36 {
36 // Q_INIT_RESOURCE(socexplorer);
37 #ifdef Q_OS_LINUX
38 // QApplication::setGraphicsSystem("raster");
39 #endif
40 37 QApplication a(argc, argv);
41 38 QString scriptToEval;
42 39 QStringList args= a.arguments();
@@ -69,3 +66,10 int main(int argc, char *argv[])
69 66 w.show();
70 67 return a.exec();
71 68 }
69
70
71 void usage()
72 {
73 // TODO respect usual Linux Cli interface, socexplore [OPTION]...FILES...
74 // TODO write an usage helper.
75 }
Show file before | Show file after | Hide comments
@@ -32,7 +32,7 SocExplorerMainWindow::SocExplorerMainWi
32 32 this->makeLayout();
33 33 this->makeMenu();
34 34 this->makeConnections();
35 this->setWindowIcon(QIcon(tr(":/images/icon.png")));
35 this->setWindowIcon(QIcon(":/images/icon.png"));
36 36 this->setAcceptDrops(true);
37 37 this->pluginManager->setRootLoadable(true);
38 38 this->PythonConsoleInst->pyConsoleRunFile(ScriptToEval);
General Comments 0
You need to be logged in to leave comments. Login now