##// 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 2c82d72694590cbc2aebb946667f11f60ea89afe src/SocExplorerEngine/PeripheralWidget
1 2c82d72694590cbc2aebb946667f11f60ea89afe src/SocExplorerEngine/PeripheralWidget
2 e0f25227d6283e833fbb70c5fc1bdc6c3ca8060e src/common/genericBinaryFiles
2 cc958c79ba0939809a70e63b8bac798930160243 src/common/genericBinaryFiles
3 2dce25b198558be573f56c1cf337aa95ddd666d6 src/common/lppserial
3 2dce25b198558be573f56c1cf337aa95ddd666d6 src/common/lppserial
4 923afde9cc96bb419cf898560d080ec96991aeca src/common/qhexedit
4 923afde9cc96bb419cf898560d080ec96991aeca src/common/qhexedit
Show file before | Show file after | Hide comments
@@ -3,6 +3,7 QT += core gui xml svg network
3 contains(QT_MAJOR_VERSION, 5) {
3 contains(QT_MAJOR_VERSION, 5) {
4 QT += widgets
4 QT += widgets
5 QT += printsupport
5 QT += printsupport
6 QT += multimedia multimediawidgets
6 }
7 }
7
8
8 SOCEXPLORER_SDK_BUILD="SOCEXPLORER_SDK_BUILD"
9 SOCEXPLORER_SDK_BUILD="SOCEXPLORER_SDK_BUILD"
Show file before | Show file after | Hide comments
@@ -27,6 +27,7 SOCModel::SOCModel(socexplorerplugin *ro
27 QObject(parent)
27 QObject(parent)
28 {
28 {
29 p_rootDev = rootDev;
29 p_rootDev = rootDev;
30 p_litleEndian = false;
30 }
31 }
31
32
32 qint32 SOCModel::getEnumDeviceBaseAddress(int VID, int PID, int count)
33 qint32 SOCModel::getEnumDeviceBaseAddress(int VID, int PID, int count)
@@ -110,3 +111,8 qint32 SOCModel::readReg(qint32 address)
110 p_rootDev->Read(&valueInt,1,addressInt);
111 p_rootDev->Read(&valueInt,1,addressInt);
111 return (qint32)valueInt;
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 int addEnumDevice(socExplorerEnumDevice* device);
94 int addEnumDevice(socExplorerEnumDevice* device);
95 void writeReg(qint32 address,qint32 value);
95 void writeReg(qint32 address,qint32 value);
96 qint32 readReg(qint32 address);
96 qint32 readReg(qint32 address);
97 bool isLitleEndian();
97 private:
98 private:
98 socexplorerplugin* p_rootDev;
99 socexplorerplugin* p_rootDev;
99 QList<socExplorerEnumDevice*> p_enumeratedDevices;
100 QList<socExplorerEnumDevice*> p_enumeratedDevices;
100 QList<SOCclk*> clktree;
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 plugins \
89 plugins \
90 pluginManagerWdgt \
90 pluginManagerWdgt \
91 ../common \
91 ../common \
92 ../common/genericBinaryFiles \
92 ../ \
93 ../ \
93 RegisterMVS \
94 RegisterMVS \
94 XmlEngine \
95 XmlEngine \
Show file before | Show file after | Hide comments
@@ -281,5 +281,10 void SocExplorerEngine::setLogLevel(int
281 loglvl = level;
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 static void removeSOC(socexplorerplugin* rootPlugin);
107 static void removeSOC(socexplorerplugin* rootPlugin);
108 static void message(socexplorerplugin* sender,const QString& message,int debugLevel=0);
108 static void message(socexplorerplugin* sender,const QString& message,int debugLevel=0);
109 static void setLogLevel(int level);
109 static void setLogLevel(int level);
110 static bool isSocLitleEndian(socexplorerplugin* plugin);
110 signals:
111 signals:
111 void enumDeviceAdded(socExplorerEnumDevice* device);
112 void enumDeviceAdded(socExplorerEnumDevice* device);
112 public slots:
113 public slots:
Show file before | Show file after | Hide comments
@@ -11,7 +11,7
11 #endif
11 #endif
12 #endif
12 #endif
13
13
14
14 #include <socexplorerengine.h>
15
15
16
16
17 genericPySysdriver::genericPySysdriver(socexplorerplugin* plugin,QObject* parent):
17 genericPySysdriver::genericPySysdriver(socexplorerplugin* plugin,QObject* parent):
@@ -44,56 +44,28 void genericPySysdriver::Write(unsigned
44
44
45 bool genericPySysdriver::dumpMemory(unsigned int address,unsigned int count,QString file)
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));
47 return this->plugin->dumpMemory(address,count,file);
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;
63 }
48 }
64
49
65 bool genericPySysdriver::memSet(unsigned int address,int value, unsigned int count)
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));
52 return this->plugin->memSet(address,value,count);
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;
76 }
53 }
77
54
78 bool genericPySysdriver::loadbin(unsigned int address,QString file)
55 bool genericPySysdriver::loadbin(unsigned int address,QString file)
79 {
56 {
80 QFile infile(file);
57 return this->plugin->loadbin(address,file);
81 if (!infile.open(QIODevice::ReadOnly))
58
82 return false;
59 }
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;
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 QString genericPySysdriver::instance()
71 QString genericPySysdriver::instance()
Show file before | Show file after | Hide comments
@@ -28,6 +28,7
28 #include <QFile>
28 #include <QFile>
29 #include <stdint.h>
29 #include <stdint.h>
30 #include <QTextStream>
30 #include <QTextStream>
31 #include <abstractbinfile.h>
31 #if defined(SOCEXPLORER_SDK_BUILD)
32 #if defined(SOCEXPLORER_SDK_BUILD)
32 # define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
33 # define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
33 #else
34 #else
@@ -49,6 +50,8 public slots:
49 bool dumpMemory(unsigned int address,unsigned int count,QString file);
50 bool dumpMemory(unsigned int address,unsigned int count,QString file);
50 bool memSet(unsigned int address,int value, unsigned int count);
51 bool memSet(unsigned int address,int value, unsigned int count);
51 bool loadbin(unsigned int address,QString file);
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 QString instance();
55 QString instance();
53 private:
56 private:
54 socexplorerplugin* plugin;
57 socexplorerplugin* plugin;
Show file before | Show file after | Hide comments
@@ -21,7 +21,9
21 ----------------------------------------------------------------------------*/
21 ----------------------------------------------------------------------------*/
22
22
23 #include <socexplorerplugin.h>
23 #include <socexplorerplugin.h>
24
24 #include <abstractbinfile.h>
25 #include <srec/srecfile.h>
26 #include <BinFile/binaryfile.h>
25
27
26 int socexplorerplugin::isConnected(){return this->Connected;}
28 int socexplorerplugin::isConnected(){return this->Connected;}
27
29
@@ -33,44 +35,44 void socexplorerplugin::setBaseAddress(u
33
35
34 QString socexplorerplugin::instanceName()
36 QString socexplorerplugin::instanceName()
35 {
37 {
36 return this->_instanceName;
38 return this->_instanceName;
37 }
39 }
38
40
39 int socexplorerplugin::registermenu(QMenu *menu)
41 int socexplorerplugin::registermenu(QMenu *menu)
40 {
42 {
41 this->menu = menu->addMenu(this->_instanceName);
43 this->menu = menu->addMenu(this->_instanceName);
42 this->closeAction = this->menu->addAction(tr("Close plugin"));
44 this->closeAction = this->menu->addAction(tr("Close plugin"));
43 QObject::connect(this->closeAction,SIGNAL(triggered()),this,SLOT(closeMe()));
45 QObject::connect(this->closeAction,SIGNAL(triggered()),this,SLOT(closeMe()));
44 this->ChildsMenu = this->menu->addMenu(QString("Childs"));
46 this->ChildsMenu = this->menu->addMenu(QString("Childs"));
45 for(int i=0;i<this->childs.count();i++)
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());
51 if(this->pyObject!=NULL)emit this->registerObject((QObject*)this->pyObject,this->instanceName());
50 return 0;
52 return 0;
51 }
53 }
52
54
53 void socexplorerplugin::postInstantiationTrigger()
55 void socexplorerplugin::postInstantiationTrigger()
54 {
56 {
55 return;
57 return;
56 }
58 }
57
59
58 unsigned int socexplorerplugin::Write(unsigned int *Value, unsigned int count, unsigned int address)
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 unsigned int socexplorerplugin::Read(unsigned int *Value, unsigned int count, unsigned int address)
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 void socexplorerplugin::closeMe(){emit this->closePlugin(this);}
78 void socexplorerplugin::closeMe(){emit this->closePlugin(this);}
@@ -79,13 +81,164 void socexplorerplugin::activate(bool fl
79
81
80 void socexplorerplugin::setInstanceName(const QString &newName)
82 void socexplorerplugin::setInstanceName(const QString &newName)
81 {
83 {
82 this->_instanceName = newName;
84 this->_instanceName = newName;
83 if(this->menu)
85 if(this->menu)
84 this->menu->setTitle(this->_instanceName);
86 this->menu->setTitle(this->_instanceName);
85 this->setWindowTitle(newName);
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 void socexplorerplugin::makeGenericPyWrapper()
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 #include <stdint.h>
43 #include <stdint.h>
44 #include <QTextStream>
44 #include <QTextStream>
45 #include <genericPySysdriver.h>
45 #include <genericPySysdriver.h>
46 #include <abstractbinfile.h>
46 #ifndef driver_Name
47 #ifndef driver_Name
47 #define driver_Name "Plugin"
48 #define driver_Name "Plugin"
48 #endif
49 #endif
@@ -161,6 +162,12 public slots:
161 virtual void closeMe();
162 virtual void closeMe();
162 virtual void activate(bool flag);
163 virtual void activate(bool flag);
163 virtual void setInstanceName(const QString& newName);
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 protected:
171 protected:
165 void makeGenericPyWrapper();
172 void makeGenericPyWrapper();
166 int BaseAddress;
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 #include <PythonQtConversion.h>
2 #include <PythonQtConversion.h>
3 #include <PythonQtMethodInfo.h>
3 #include <PythonQtMethodInfo.h>
4 #include <PythonQtSignalReceiver.h>
4 #include <PythonQtSignalReceiver.h>
5 #include <QIconEngine>
6 #include <QVariant>
5 #include <QVariant>
7 #include <abstractbinfile.h>
6 #include <abstractbinfile.h>
8 #include <elfparser.h>
7 #include <elfparser.h>
9 #include <qaction.h>
8 #include <qaction.h>
9 #include <qbackingstore.h>
10 #include <qbitmap.h>
10 #include <qbitmap.h>
11 #include <qbytearray.h>
11 #include <qbytearray.h>
12 #include <qcolor.h>
12 #include <qcolor.h>
@@ -17,12 +17,14
17 #include <qfont.h>
17 #include <qfont.h>
18 #include <qgraphicseffect.h>
18 #include <qgraphicseffect.h>
19 #include <qgraphicsproxywidget.h>
19 #include <qgraphicsproxywidget.h>
20 #include <qicon.h>
20 #include <qkeysequence.h>
21 #include <qkeysequence.h>
21 #include <qlayout.h>
22 #include <qlayout.h>
22 #include <qlineedit.h>
23 #include <qlineedit.h>
23 #include <qlist.h>
24 #include <qlist.h>
24 #include <qlocale.h>
25 #include <qlocale.h>
25 #include <qmargins.h>
26 #include <qmargins.h>
27 #include <qmetaobject.h>
26 #include <qobject.h>
28 #include <qobject.h>
27 #include <qpaintdevice.h>
29 #include <qpaintdevice.h>
28 #include <qpaintengine.h>
30 #include <qpaintengine.h>
@@ -42,6 +44,7
42 #include <qstyle.h>
44 #include <qstyle.h>
43 #include <qstyleoption.h>
45 #include <qstyleoption.h>
44 #include <qwidget.h>
46 #include <qwidget.h>
47 #include <qwindow.h>
45
48
46 PythonQtShell_ElfFile::~PythonQtShell_ElfFile() {
49 PythonQtShell_ElfFile::~PythonQtShell_ElfFile() {
47 PythonQtPrivate* priv = PythonQt::priv();
50 PythonQtPrivate* priv = PythonQt::priv();
@@ -49,10 +52,10 PythonQtShell_ElfFile::~PythonQtShell_El
49 }
52 }
50 int PythonQtShell_ElfFile::closeFile()
53 int PythonQtShell_ElfFile::closeFile()
51 {
54 {
52 if (_wrapper) {
55 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
53 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
56 static PyObject* name = PyString_FromString("closeFile");
54 PyErr_Clear();
57 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
55 if (obj && !PythonQtSlotFunction_Check(obj)) {
58 if (obj) {
56 static const char* argumentList[] ={"int"};
59 static const char* argumentList[] ={"int"};
57 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
60 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
58 int returnValue;
61 int returnValue;
@@ -71,16 +74,18 if (_wrapper) {
71 if (result) { Py_DECREF(result); }
74 if (result) { Py_DECREF(result); }
72 Py_DECREF(obj);
75 Py_DECREF(obj);
73 return returnValue;
76 return returnValue;
77 } else {
78 PyErr_Clear();
74 }
79 }
75 }
80 }
76 return ElfFile::closeFile();
81 return ElfFile::closeFile();
77 }
82 }
78 QList<codeFragment* > PythonQtShell_ElfFile::getFragments()
83 QList<codeFragment* > PythonQtShell_ElfFile::getFragments()
79 {
84 {
80 if (_wrapper) {
85 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
81 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
86 static PyObject* name = PyString_FromString("getFragments");
82 PyErr_Clear();
87 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
83 if (obj && !PythonQtSlotFunction_Check(obj)) {
88 if (obj) {
84 static const char* argumentList[] ={"QList<codeFragment* >"};
89 static const char* argumentList[] ={"QList<codeFragment* >"};
85 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
90 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
86 QList<codeFragment* > returnValue;
91 QList<codeFragment* > returnValue;
@@ -99,16 +104,18 if (_wrapper) {
99 if (result) { Py_DECREF(result); }
104 if (result) { Py_DECREF(result); }
100 Py_DECREF(obj);
105 Py_DECREF(obj);
101 return returnValue;
106 return returnValue;
107 } else {
108 PyErr_Clear();
102 }
109 }
103 }
110 }
104 return ElfFile::getFragments();
111 return ElfFile::getFragments();
105 }
112 }
106 bool PythonQtShell_ElfFile::isopened()
113 bool PythonQtShell_ElfFile::isopened()
107 {
114 {
108 if (_wrapper) {
115 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
109 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
116 static PyObject* name = PyString_FromString("isopened");
110 PyErr_Clear();
117 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
111 if (obj && !PythonQtSlotFunction_Check(obj)) {
118 if (obj) {
112 static const char* argumentList[] ={"bool"};
119 static const char* argumentList[] ={"bool"};
113 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
120 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
114 bool returnValue;
121 bool returnValue;
@@ -127,20 +134,22 if (_wrapper) {
127 if (result) { Py_DECREF(result); }
134 if (result) { Py_DECREF(result); }
128 Py_DECREF(obj);
135 Py_DECREF(obj);
129 return returnValue;
136 return returnValue;
137 } else {
138 PyErr_Clear();
130 }
139 }
131 }
140 }
132 return ElfFile::isopened();
141 return ElfFile::isopened();
133 }
142 }
134 bool PythonQtShell_ElfFile::openFile(const QString& File)
143 bool PythonQtShell_ElfFile::openFile(const QString& File0)
135 {
144 {
136 if (_wrapper) {
145 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
137 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
146 static PyObject* name = PyString_FromString("openFile");
138 PyErr_Clear();
147 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
139 if (obj && !PythonQtSlotFunction_Check(obj)) {
148 if (obj) {
140 static const char* argumentList[] ={"bool" , "const QString&"};
149 static const char* argumentList[] ={"bool" , "const QString&"};
141 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
150 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
142 bool returnValue;
151 bool returnValue;
143 void* args[2] = {NULL, (void*)&File};
152 void* args[2] = {NULL, (void*)&File0};
144 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
153 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
145 if (result) {
154 if (result) {
146 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
155 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -155,20 +164,22 if (_wrapper) {
155 if (result) { Py_DECREF(result); }
164 if (result) { Py_DECREF(result); }
156 Py_DECREF(obj);
165 Py_DECREF(obj);
157 return returnValue;
166 return returnValue;
158 }
167 } else {
159 }
168 PyErr_Clear();
160 return ElfFile::openFile(File);
169 }
161 }
170 }
162 bool PythonQtShell_ElfFile::toBinary(const QString& File)
171 return ElfFile::openFile(File0);
163 {
172 }
164 if (_wrapper) {
173 bool PythonQtShell_ElfFile::toBinary(const QString& File0)
165 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
174 {
166 PyErr_Clear();
175 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
167 if (obj && !PythonQtSlotFunction_Check(obj)) {
176 static PyObject* name = PyString_FromString("toBinary");
177 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
178 if (obj) {
168 static const char* argumentList[] ={"bool" , "const QString&"};
179 static const char* argumentList[] ={"bool" , "const QString&"};
169 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
180 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
170 bool returnValue;
181 bool returnValue;
171 void* args[2] = {NULL, (void*)&File};
182 void* args[2] = {NULL, (void*)&File0};
172 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
183 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
173 if (result) {
184 if (result) {
174 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
185 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -183,20 +194,22 if (_wrapper) {
183 if (result) { Py_DECREF(result); }
194 if (result) { Py_DECREF(result); }
184 Py_DECREF(obj);
195 Py_DECREF(obj);
185 return returnValue;
196 return returnValue;
186 }
197 } else {
187 }
198 PyErr_Clear();
188 return ElfFile::toBinary(File);
199 }
189 }
200 }
190 bool PythonQtShell_ElfFile::toSrec(const QString& File)
201 return ElfFile::toBinary(File0);
191 {
202 }
192 if (_wrapper) {
203 bool PythonQtShell_ElfFile::toSrec(const QString& File0)
193 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
204 {
194 PyErr_Clear();
205 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
195 if (obj && !PythonQtSlotFunction_Check(obj)) {
206 static PyObject* name = PyString_FromString("toSrec");
207 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
208 if (obj) {
196 static const char* argumentList[] ={"bool" , "const QString&"};
209 static const char* argumentList[] ={"bool" , "const QString&"};
197 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
210 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
198 bool returnValue;
211 bool returnValue;
199 void* args[2] = {NULL, (void*)&File};
212 void* args[2] = {NULL, (void*)&File0};
200 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
213 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
201 if (result) {
214 if (result) {
202 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
215 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -211,9 +224,11 if (_wrapper) {
211 if (result) { Py_DECREF(result); }
224 if (result) { Py_DECREF(result); }
212 Py_DECREF(obj);
225 Py_DECREF(obj);
213 return returnValue;
226 return returnValue;
214 }
227 } else {
215 }
228 PyErr_Clear();
216 return ElfFile::toSrec(File);
229 }
230 }
231 return ElfFile::toSrec(File0);
217 }
232 }
218 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile()
233 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile()
219 {
234 {
@@ -393,11 +408,21 qint64 PythonQtWrapper_ElfFile::getVers
393 return ( theWrappedObject->getVersion());
408 return ( theWrappedObject->getVersion());
394 }
409 }
395
410
411 bool PythonQtWrapper_ElfFile::isBigEndian(ElfFile* theWrappedObject)
412 {
413 return ( theWrappedObject->isBigEndian());
414 }
415
396 bool PythonQtWrapper_ElfFile::static_ElfFile_isElf(const QString& File)
416 bool PythonQtWrapper_ElfFile::static_ElfFile_isElf(const QString& File)
397 {
417 {
398 return (ElfFile::isElf(File));
418 return (ElfFile::isElf(File));
399 }
419 }
400
420
421 bool PythonQtWrapper_ElfFile::isLitleEndian(ElfFile* theWrappedObject)
422 {
423 return ( theWrappedObject->isLitleEndian());
424 }
425
401 bool PythonQtWrapper_ElfFile::iself(ElfFile* theWrappedObject)
426 bool PythonQtWrapper_ElfFile::iself(ElfFile* theWrappedObject)
402 {
427 {
403 return ( theWrappedObject->iself());
428 return ( theWrappedObject->iself());
@@ -436,10 +461,10 PythonQtShell_MemSizeWdgt::~PythonQtShel
436 }
461 }
437 void PythonQtShell_MemSizeWdgt::actionEvent(QActionEvent* arg__1)
462 void PythonQtShell_MemSizeWdgt::actionEvent(QActionEvent* arg__1)
438 {
463 {
439 if (_wrapper) {
464 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
440 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
465 static PyObject* name = PyString_FromString("actionEvent");
441 PyErr_Clear();
466 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
442 if (obj && !PythonQtSlotFunction_Check(obj)) {
467 if (obj) {
443 static const char* argumentList[] ={"" , "QActionEvent*"};
468 static const char* argumentList[] ={"" , "QActionEvent*"};
444 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
469 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
445 void* args[2] = {NULL, (void*)&arg__1};
470 void* args[2] = {NULL, (void*)&arg__1};
@@ -447,16 +472,18 if (_wrapper) {
447 if (result) { Py_DECREF(result); }
472 if (result) { Py_DECREF(result); }
448 Py_DECREF(obj);
473 Py_DECREF(obj);
449 return;
474 return;
475 } else {
476 PyErr_Clear();
450 }
477 }
451 }
478 }
452 MemSizeWdgt::actionEvent(arg__1);
479 MemSizeWdgt::actionEvent(arg__1);
453 }
480 }
454 void PythonQtShell_MemSizeWdgt::changeEvent(QEvent* arg__1)
481 void PythonQtShell_MemSizeWdgt::changeEvent(QEvent* arg__1)
455 {
482 {
456 if (_wrapper) {
483 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
457 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
484 static PyObject* name = PyString_FromString("changeEvent");
458 PyErr_Clear();
485 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
459 if (obj && !PythonQtSlotFunction_Check(obj)) {
486 if (obj) {
460 static const char* argumentList[] ={"" , "QEvent*"};
487 static const char* argumentList[] ={"" , "QEvent*"};
461 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
488 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
462 void* args[2] = {NULL, (void*)&arg__1};
489 void* args[2] = {NULL, (void*)&arg__1};
@@ -464,16 +491,18 if (_wrapper) {
464 if (result) { Py_DECREF(result); }
491 if (result) { Py_DECREF(result); }
465 Py_DECREF(obj);
492 Py_DECREF(obj);
466 return;
493 return;
494 } else {
495 PyErr_Clear();
467 }
496 }
468 }
497 }
469 MemSizeWdgt::changeEvent(arg__1);
498 MemSizeWdgt::changeEvent(arg__1);
470 }
499 }
471 void PythonQtShell_MemSizeWdgt::childEvent(QChildEvent* arg__1)
500 void PythonQtShell_MemSizeWdgt::childEvent(QChildEvent* arg__1)
472 {
501 {
473 if (_wrapper) {
502 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
474 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
503 static PyObject* name = PyString_FromString("childEvent");
475 PyErr_Clear();
504 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
476 if (obj && !PythonQtSlotFunction_Check(obj)) {
505 if (obj) {
477 static const char* argumentList[] ={"" , "QChildEvent*"};
506 static const char* argumentList[] ={"" , "QChildEvent*"};
478 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
507 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
479 void* args[2] = {NULL, (void*)&arg__1};
508 void* args[2] = {NULL, (void*)&arg__1};
@@ -481,16 +510,18 if (_wrapper) {
481 if (result) { Py_DECREF(result); }
510 if (result) { Py_DECREF(result); }
482 Py_DECREF(obj);
511 Py_DECREF(obj);
483 return;
512 return;
513 } else {
514 PyErr_Clear();
484 }
515 }
485 }
516 }
486 MemSizeWdgt::childEvent(arg__1);
517 MemSizeWdgt::childEvent(arg__1);
487 }
518 }
488 void PythonQtShell_MemSizeWdgt::closeEvent(QCloseEvent* arg__1)
519 void PythonQtShell_MemSizeWdgt::closeEvent(QCloseEvent* arg__1)
489 {
520 {
490 if (_wrapper) {
521 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
491 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
522 static PyObject* name = PyString_FromString("closeEvent");
492 PyErr_Clear();
523 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
493 if (obj && !PythonQtSlotFunction_Check(obj)) {
524 if (obj) {
494 static const char* argumentList[] ={"" , "QCloseEvent*"};
525 static const char* argumentList[] ={"" , "QCloseEvent*"};
495 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
526 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
496 void* args[2] = {NULL, (void*)&arg__1};
527 void* args[2] = {NULL, (void*)&arg__1};
@@ -498,16 +529,18 if (_wrapper) {
498 if (result) { Py_DECREF(result); }
529 if (result) { Py_DECREF(result); }
499 Py_DECREF(obj);
530 Py_DECREF(obj);
500 return;
531 return;
532 } else {
533 PyErr_Clear();
501 }
534 }
502 }
535 }
503 MemSizeWdgt::closeEvent(arg__1);
536 MemSizeWdgt::closeEvent(arg__1);
504 }
537 }
505 void PythonQtShell_MemSizeWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
538 void PythonQtShell_MemSizeWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
506 {
539 {
507 if (_wrapper) {
540 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
508 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
541 static PyObject* name = PyString_FromString("contextMenuEvent");
509 PyErr_Clear();
542 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
510 if (obj && !PythonQtSlotFunction_Check(obj)) {
543 if (obj) {
511 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
544 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
512 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
545 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
513 void* args[2] = {NULL, (void*)&arg__1};
546 void* args[2] = {NULL, (void*)&arg__1};
@@ -515,16 +548,18 if (_wrapper) {
515 if (result) { Py_DECREF(result); }
548 if (result) { Py_DECREF(result); }
516 Py_DECREF(obj);
549 Py_DECREF(obj);
517 return;
550 return;
551 } else {
552 PyErr_Clear();
518 }
553 }
519 }
554 }
520 MemSizeWdgt::contextMenuEvent(arg__1);
555 MemSizeWdgt::contextMenuEvent(arg__1);
521 }
556 }
522 void PythonQtShell_MemSizeWdgt::customEvent(QEvent* arg__1)
557 void PythonQtShell_MemSizeWdgt::customEvent(QEvent* arg__1)
523 {
558 {
524 if (_wrapper) {
559 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
525 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
560 static PyObject* name = PyString_FromString("customEvent");
526 PyErr_Clear();
561 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
527 if (obj && !PythonQtSlotFunction_Check(obj)) {
562 if (obj) {
528 static const char* argumentList[] ={"" , "QEvent*"};
563 static const char* argumentList[] ={"" , "QEvent*"};
529 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
564 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
530 void* args[2] = {NULL, (void*)&arg__1};
565 void* args[2] = {NULL, (void*)&arg__1};
@@ -532,16 +567,18 if (_wrapper) {
532 if (result) { Py_DECREF(result); }
567 if (result) { Py_DECREF(result); }
533 Py_DECREF(obj);
568 Py_DECREF(obj);
534 return;
569 return;
570 } else {
571 PyErr_Clear();
535 }
572 }
536 }
573 }
537 MemSizeWdgt::customEvent(arg__1);
574 MemSizeWdgt::customEvent(arg__1);
538 }
575 }
539 int PythonQtShell_MemSizeWdgt::devType() const
576 int PythonQtShell_MemSizeWdgt::devType() const
540 {
577 {
541 if (_wrapper) {
578 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
542 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
579 static PyObject* name = PyString_FromString("devType");
543 PyErr_Clear();
580 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
544 if (obj && !PythonQtSlotFunction_Check(obj)) {
581 if (obj) {
545 static const char* argumentList[] ={"int"};
582 static const char* argumentList[] ={"int"};
546 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
583 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
547 int returnValue;
584 int returnValue;
@@ -560,16 +597,18 if (_wrapper) {
560 if (result) { Py_DECREF(result); }
597 if (result) { Py_DECREF(result); }
561 Py_DECREF(obj);
598 Py_DECREF(obj);
562 return returnValue;
599 return returnValue;
600 } else {
601 PyErr_Clear();
563 }
602 }
564 }
603 }
565 return MemSizeWdgt::devType();
604 return MemSizeWdgt::devType();
566 }
605 }
567 void PythonQtShell_MemSizeWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
606 void PythonQtShell_MemSizeWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
568 {
607 {
569 if (_wrapper) {
608 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
570 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
609 static PyObject* name = PyString_FromString("dragEnterEvent");
571 PyErr_Clear();
610 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
572 if (obj && !PythonQtSlotFunction_Check(obj)) {
611 if (obj) {
573 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
612 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
574 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
613 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
575 void* args[2] = {NULL, (void*)&arg__1};
614 void* args[2] = {NULL, (void*)&arg__1};
@@ -577,16 +616,18 if (_wrapper) {
577 if (result) { Py_DECREF(result); }
616 if (result) { Py_DECREF(result); }
578 Py_DECREF(obj);
617 Py_DECREF(obj);
579 return;
618 return;
619 } else {
620 PyErr_Clear();
580 }
621 }
581 }
622 }
582 MemSizeWdgt::dragEnterEvent(arg__1);
623 MemSizeWdgt::dragEnterEvent(arg__1);
583 }
624 }
584 void PythonQtShell_MemSizeWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
625 void PythonQtShell_MemSizeWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
585 {
626 {
586 if (_wrapper) {
627 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
587 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
628 static PyObject* name = PyString_FromString("dragLeaveEvent");
588 PyErr_Clear();
629 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
589 if (obj && !PythonQtSlotFunction_Check(obj)) {
630 if (obj) {
590 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
631 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
591 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
632 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
592 void* args[2] = {NULL, (void*)&arg__1};
633 void* args[2] = {NULL, (void*)&arg__1};
@@ -594,16 +635,18 if (_wrapper) {
594 if (result) { Py_DECREF(result); }
635 if (result) { Py_DECREF(result); }
595 Py_DECREF(obj);
636 Py_DECREF(obj);
596 return;
637 return;
638 } else {
639 PyErr_Clear();
597 }
640 }
598 }
641 }
599 MemSizeWdgt::dragLeaveEvent(arg__1);
642 MemSizeWdgt::dragLeaveEvent(arg__1);
600 }
643 }
601 void PythonQtShell_MemSizeWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
644 void PythonQtShell_MemSizeWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
602 {
645 {
603 if (_wrapper) {
646 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
604 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
647 static PyObject* name = PyString_FromString("dragMoveEvent");
605 PyErr_Clear();
648 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
606 if (obj && !PythonQtSlotFunction_Check(obj)) {
649 if (obj) {
607 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
650 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
608 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
651 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
609 void* args[2] = {NULL, (void*)&arg__1};
652 void* args[2] = {NULL, (void*)&arg__1};
@@ -611,16 +654,18 if (_wrapper) {
611 if (result) { Py_DECREF(result); }
654 if (result) { Py_DECREF(result); }
612 Py_DECREF(obj);
655 Py_DECREF(obj);
613 return;
656 return;
657 } else {
658 PyErr_Clear();
614 }
659 }
615 }
660 }
616 MemSizeWdgt::dragMoveEvent(arg__1);
661 MemSizeWdgt::dragMoveEvent(arg__1);
617 }
662 }
618 void PythonQtShell_MemSizeWdgt::dropEvent(QDropEvent* arg__1)
663 void PythonQtShell_MemSizeWdgt::dropEvent(QDropEvent* arg__1)
619 {
664 {
620 if (_wrapper) {
665 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
621 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
666 static PyObject* name = PyString_FromString("dropEvent");
622 PyErr_Clear();
667 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
623 if (obj && !PythonQtSlotFunction_Check(obj)) {
668 if (obj) {
624 static const char* argumentList[] ={"" , "QDropEvent*"};
669 static const char* argumentList[] ={"" , "QDropEvent*"};
625 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
670 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
626 void* args[2] = {NULL, (void*)&arg__1};
671 void* args[2] = {NULL, (void*)&arg__1};
@@ -628,16 +673,18 if (_wrapper) {
628 if (result) { Py_DECREF(result); }
673 if (result) { Py_DECREF(result); }
629 Py_DECREF(obj);
674 Py_DECREF(obj);
630 return;
675 return;
676 } else {
677 PyErr_Clear();
631 }
678 }
632 }
679 }
633 MemSizeWdgt::dropEvent(arg__1);
680 MemSizeWdgt::dropEvent(arg__1);
634 }
681 }
635 void PythonQtShell_MemSizeWdgt::enterEvent(QEvent* arg__1)
682 void PythonQtShell_MemSizeWdgt::enterEvent(QEvent* arg__1)
636 {
683 {
637 if (_wrapper) {
684 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
638 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
685 static PyObject* name = PyString_FromString("enterEvent");
639 PyErr_Clear();
686 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
640 if (obj && !PythonQtSlotFunction_Check(obj)) {
687 if (obj) {
641 static const char* argumentList[] ={"" , "QEvent*"};
688 static const char* argumentList[] ={"" , "QEvent*"};
642 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
689 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
643 void* args[2] = {NULL, (void*)&arg__1};
690 void* args[2] = {NULL, (void*)&arg__1};
@@ -645,16 +692,18 if (_wrapper) {
645 if (result) { Py_DECREF(result); }
692 if (result) { Py_DECREF(result); }
646 Py_DECREF(obj);
693 Py_DECREF(obj);
647 return;
694 return;
695 } else {
696 PyErr_Clear();
648 }
697 }
649 }
698 }
650 MemSizeWdgt::enterEvent(arg__1);
699 MemSizeWdgt::enterEvent(arg__1);
651 }
700 }
652 bool PythonQtShell_MemSizeWdgt::event(QEvent* arg__1)
701 bool PythonQtShell_MemSizeWdgt::event(QEvent* arg__1)
653 {
702 {
654 if (_wrapper) {
703 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
655 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
704 static PyObject* name = PyString_FromString("event");
656 PyErr_Clear();
705 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
657 if (obj && !PythonQtSlotFunction_Check(obj)) {
706 if (obj) {
658 static const char* argumentList[] ={"bool" , "QEvent*"};
707 static const char* argumentList[] ={"bool" , "QEvent*"};
659 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
708 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
660 bool returnValue;
709 bool returnValue;
@@ -673,16 +722,18 if (_wrapper) {
673 if (result) { Py_DECREF(result); }
722 if (result) { Py_DECREF(result); }
674 Py_DECREF(obj);
723 Py_DECREF(obj);
675 return returnValue;
724 return returnValue;
725 } else {
726 PyErr_Clear();
676 }
727 }
677 }
728 }
678 return MemSizeWdgt::event(arg__1);
729 return MemSizeWdgt::event(arg__1);
679 }
730 }
680 bool PythonQtShell_MemSizeWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
731 bool PythonQtShell_MemSizeWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
681 {
732 {
682 if (_wrapper) {
733 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
683 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
734 static PyObject* name = PyString_FromString("eventFilter");
684 PyErr_Clear();
735 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
685 if (obj && !PythonQtSlotFunction_Check(obj)) {
736 if (obj) {
686 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
737 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
687 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
738 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
688 bool returnValue;
739 bool returnValue;
@@ -701,16 +752,18 if (_wrapper) {
701 if (result) { Py_DECREF(result); }
752 if (result) { Py_DECREF(result); }
702 Py_DECREF(obj);
753 Py_DECREF(obj);
703 return returnValue;
754 return returnValue;
755 } else {
756 PyErr_Clear();
704 }
757 }
705 }
758 }
706 return MemSizeWdgt::eventFilter(arg__1, arg__2);
759 return MemSizeWdgt::eventFilter(arg__1, arg__2);
707 }
760 }
708 void PythonQtShell_MemSizeWdgt::focusInEvent(QFocusEvent* arg__1)
761 void PythonQtShell_MemSizeWdgt::focusInEvent(QFocusEvent* arg__1)
709 {
762 {
710 if (_wrapper) {
763 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
711 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
764 static PyObject* name = PyString_FromString("focusInEvent");
712 PyErr_Clear();
765 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
713 if (obj && !PythonQtSlotFunction_Check(obj)) {
766 if (obj) {
714 static const char* argumentList[] ={"" , "QFocusEvent*"};
767 static const char* argumentList[] ={"" , "QFocusEvent*"};
715 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
768 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
716 void* args[2] = {NULL, (void*)&arg__1};
769 void* args[2] = {NULL, (void*)&arg__1};
@@ -718,20 +771,22 if (_wrapper) {
718 if (result) { Py_DECREF(result); }
771 if (result) { Py_DECREF(result); }
719 Py_DECREF(obj);
772 Py_DECREF(obj);
720 return;
773 return;
774 } else {
775 PyErr_Clear();
721 }
776 }
722 }
777 }
723 MemSizeWdgt::focusInEvent(arg__1);
778 MemSizeWdgt::focusInEvent(arg__1);
724 }
779 }
725 bool PythonQtShell_MemSizeWdgt::focusNextPrevChild(bool next)
780 bool PythonQtShell_MemSizeWdgt::focusNextPrevChild(bool next0)
726 {
781 {
727 if (_wrapper) {
782 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
728 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
783 static PyObject* name = PyString_FromString("focusNextPrevChild");
729 PyErr_Clear();
784 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
730 if (obj && !PythonQtSlotFunction_Check(obj)) {
785 if (obj) {
731 static const char* argumentList[] ={"bool" , "bool"};
786 static const char* argumentList[] ={"bool" , "bool"};
732 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
787 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
733 bool returnValue;
788 bool returnValue;
734 void* args[2] = {NULL, (void*)&next};
789 void* args[2] = {NULL, (void*)&next0};
735 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
790 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
736 if (result) {
791 if (result) {
737 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
792 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -746,16 +801,18 if (_wrapper) {
746 if (result) { Py_DECREF(result); }
801 if (result) { Py_DECREF(result); }
747 Py_DECREF(obj);
802 Py_DECREF(obj);
748 return returnValue;
803 return returnValue;
749 }
804 } else {
750 }
805 PyErr_Clear();
751 return MemSizeWdgt::focusNextPrevChild(next);
806 }
807 }
808 return MemSizeWdgt::focusNextPrevChild(next0);
752 }
809 }
753 void PythonQtShell_MemSizeWdgt::focusOutEvent(QFocusEvent* arg__1)
810 void PythonQtShell_MemSizeWdgt::focusOutEvent(QFocusEvent* arg__1)
754 {
811 {
755 if (_wrapper) {
812 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
756 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
813 static PyObject* name = PyString_FromString("focusOutEvent");
757 PyErr_Clear();
814 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
758 if (obj && !PythonQtSlotFunction_Check(obj)) {
815 if (obj) {
759 static const char* argumentList[] ={"" , "QFocusEvent*"};
816 static const char* argumentList[] ={"" , "QFocusEvent*"};
760 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
817 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
761 void* args[2] = {NULL, (void*)&arg__1};
818 void* args[2] = {NULL, (void*)&arg__1};
@@ -763,16 +820,18 if (_wrapper) {
763 if (result) { Py_DECREF(result); }
820 if (result) { Py_DECREF(result); }
764 Py_DECREF(obj);
821 Py_DECREF(obj);
765 return;
822 return;
823 } else {
824 PyErr_Clear();
766 }
825 }
767 }
826 }
768 MemSizeWdgt::focusOutEvent(arg__1);
827 MemSizeWdgt::focusOutEvent(arg__1);
769 }
828 }
770 bool PythonQtShell_MemSizeWdgt::hasHeightForWidth() const
829 bool PythonQtShell_MemSizeWdgt::hasHeightForWidth() const
771 {
830 {
772 if (_wrapper) {
831 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
773 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
832 static PyObject* name = PyString_FromString("hasHeightForWidth");
774 PyErr_Clear();
833 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
775 if (obj && !PythonQtSlotFunction_Check(obj)) {
834 if (obj) {
776 static const char* argumentList[] ={"bool"};
835 static const char* argumentList[] ={"bool"};
777 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
836 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
778 bool returnValue;
837 bool returnValue;
@@ -791,16 +850,18 if (_wrapper) {
791 if (result) { Py_DECREF(result); }
850 if (result) { Py_DECREF(result); }
792 Py_DECREF(obj);
851 Py_DECREF(obj);
793 return returnValue;
852 return returnValue;
853 } else {
854 PyErr_Clear();
794 }
855 }
795 }
856 }
796 return MemSizeWdgt::hasHeightForWidth();
857 return MemSizeWdgt::hasHeightForWidth();
797 }
858 }
798 int PythonQtShell_MemSizeWdgt::heightForWidth(int arg__1) const
859 int PythonQtShell_MemSizeWdgt::heightForWidth(int arg__1) const
799 {
860 {
800 if (_wrapper) {
861 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
801 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
862 static PyObject* name = PyString_FromString("heightForWidth");
802 PyErr_Clear();
863 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
803 if (obj && !PythonQtSlotFunction_Check(obj)) {
864 if (obj) {
804 static const char* argumentList[] ={"int" , "int"};
865 static const char* argumentList[] ={"int" , "int"};
805 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
866 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
806 int returnValue;
867 int returnValue;
@@ -819,16 +880,18 if (_wrapper) {
819 if (result) { Py_DECREF(result); }
880 if (result) { Py_DECREF(result); }
820 Py_DECREF(obj);
881 Py_DECREF(obj);
821 return returnValue;
882 return returnValue;
883 } else {
884 PyErr_Clear();
822 }
885 }
823 }
886 }
824 return MemSizeWdgt::heightForWidth(arg__1);
887 return MemSizeWdgt::heightForWidth(arg__1);
825 }
888 }
826 void PythonQtShell_MemSizeWdgt::hideEvent(QHideEvent* arg__1)
889 void PythonQtShell_MemSizeWdgt::hideEvent(QHideEvent* arg__1)
827 {
890 {
828 if (_wrapper) {
891 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
829 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
892 static PyObject* name = PyString_FromString("hideEvent");
830 PyErr_Clear();
893 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
831 if (obj && !PythonQtSlotFunction_Check(obj)) {
894 if (obj) {
832 static const char* argumentList[] ={"" , "QHideEvent*"};
895 static const char* argumentList[] ={"" , "QHideEvent*"};
833 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
896 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
834 void* args[2] = {NULL, (void*)&arg__1};
897 void* args[2] = {NULL, (void*)&arg__1};
@@ -836,33 +899,37 if (_wrapper) {
836 if (result) { Py_DECREF(result); }
899 if (result) { Py_DECREF(result); }
837 Py_DECREF(obj);
900 Py_DECREF(obj);
838 return;
901 return;
902 } else {
903 PyErr_Clear();
839 }
904 }
840 }
905 }
841 MemSizeWdgt::hideEvent(arg__1);
906 MemSizeWdgt::hideEvent(arg__1);
842 }
907 }
843 void PythonQtShell_MemSizeWdgt::initPainter(QPainter* painter) const
908 void PythonQtShell_MemSizeWdgt::initPainter(QPainter* painter0) const
844 {
909 {
845 if (_wrapper) {
910 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
846 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
911 static PyObject* name = PyString_FromString("initPainter");
847 PyErr_Clear();
912 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
848 if (obj && !PythonQtSlotFunction_Check(obj)) {
913 if (obj) {
849 static const char* argumentList[] ={"" , "QPainter*"};
914 static const char* argumentList[] ={"" , "QPainter*"};
850 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
915 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
851 void* args[2] = {NULL, (void*)&painter};
916 void* args[2] = {NULL, (void*)&painter0};
852 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
917 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
853 if (result) { Py_DECREF(result); }
918 if (result) { Py_DECREF(result); }
854 Py_DECREF(obj);
919 Py_DECREF(obj);
855 return;
920 return;
856 }
921 } else {
857 }
922 PyErr_Clear();
858 MemSizeWdgt::initPainter(painter);
923 }
924 }
925 MemSizeWdgt::initPainter(painter0);
859 }
926 }
860 void PythonQtShell_MemSizeWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
927 void PythonQtShell_MemSizeWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
861 {
928 {
862 if (_wrapper) {
929 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
863 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
930 static PyObject* name = PyString_FromString("inputMethodEvent");
864 PyErr_Clear();
931 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
865 if (obj && !PythonQtSlotFunction_Check(obj)) {
932 if (obj) {
866 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
933 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
867 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
934 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
868 void* args[2] = {NULL, (void*)&arg__1};
935 void* args[2] = {NULL, (void*)&arg__1};
@@ -870,16 +937,18 if (_wrapper) {
870 if (result) { Py_DECREF(result); }
937 if (result) { Py_DECREF(result); }
871 Py_DECREF(obj);
938 Py_DECREF(obj);
872 return;
939 return;
940 } else {
941 PyErr_Clear();
873 }
942 }
874 }
943 }
875 MemSizeWdgt::inputMethodEvent(arg__1);
944 MemSizeWdgt::inputMethodEvent(arg__1);
876 }
945 }
877 QVariant PythonQtShell_MemSizeWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
946 QVariant PythonQtShell_MemSizeWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
878 {
947 {
879 if (_wrapper) {
948 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
880 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
949 static PyObject* name = PyString_FromString("inputMethodQuery");
881 PyErr_Clear();
950 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
882 if (obj && !PythonQtSlotFunction_Check(obj)) {
951 if (obj) {
883 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
952 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
884 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
953 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
885 QVariant returnValue;
954 QVariant returnValue;
@@ -898,16 +967,18 if (_wrapper) {
898 if (result) { Py_DECREF(result); }
967 if (result) { Py_DECREF(result); }
899 Py_DECREF(obj);
968 Py_DECREF(obj);
900 return returnValue;
969 return returnValue;
970 } else {
971 PyErr_Clear();
901 }
972 }
902 }
973 }
903 return MemSizeWdgt::inputMethodQuery(arg__1);
974 return MemSizeWdgt::inputMethodQuery(arg__1);
904 }
975 }
905 void PythonQtShell_MemSizeWdgt::keyPressEvent(QKeyEvent* arg__1)
976 void PythonQtShell_MemSizeWdgt::keyPressEvent(QKeyEvent* arg__1)
906 {
977 {
907 if (_wrapper) {
978 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
908 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
979 static PyObject* name = PyString_FromString("keyPressEvent");
909 PyErr_Clear();
980 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
910 if (obj && !PythonQtSlotFunction_Check(obj)) {
981 if (obj) {
911 static const char* argumentList[] ={"" , "QKeyEvent*"};
982 static const char* argumentList[] ={"" , "QKeyEvent*"};
912 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
983 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
913 void* args[2] = {NULL, (void*)&arg__1};
984 void* args[2] = {NULL, (void*)&arg__1};
@@ -915,16 +986,18 if (_wrapper) {
915 if (result) { Py_DECREF(result); }
986 if (result) { Py_DECREF(result); }
916 Py_DECREF(obj);
987 Py_DECREF(obj);
917 return;
988 return;
989 } else {
990 PyErr_Clear();
918 }
991 }
919 }
992 }
920 MemSizeWdgt::keyPressEvent(arg__1);
993 MemSizeWdgt::keyPressEvent(arg__1);
921 }
994 }
922 void PythonQtShell_MemSizeWdgt::keyReleaseEvent(QKeyEvent* arg__1)
995 void PythonQtShell_MemSizeWdgt::keyReleaseEvent(QKeyEvent* arg__1)
923 {
996 {
924 if (_wrapper) {
997 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
925 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
998 static PyObject* name = PyString_FromString("keyReleaseEvent");
926 PyErr_Clear();
999 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
927 if (obj && !PythonQtSlotFunction_Check(obj)) {
1000 if (obj) {
928 static const char* argumentList[] ={"" , "QKeyEvent*"};
1001 static const char* argumentList[] ={"" , "QKeyEvent*"};
929 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1002 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
930 void* args[2] = {NULL, (void*)&arg__1};
1003 void* args[2] = {NULL, (void*)&arg__1};
@@ -932,16 +1005,18 if (_wrapper) {
932 if (result) { Py_DECREF(result); }
1005 if (result) { Py_DECREF(result); }
933 Py_DECREF(obj);
1006 Py_DECREF(obj);
934 return;
1007 return;
1008 } else {
1009 PyErr_Clear();
935 }
1010 }
936 }
1011 }
937 MemSizeWdgt::keyReleaseEvent(arg__1);
1012 MemSizeWdgt::keyReleaseEvent(arg__1);
938 }
1013 }
939 void PythonQtShell_MemSizeWdgt::leaveEvent(QEvent* arg__1)
1014 void PythonQtShell_MemSizeWdgt::leaveEvent(QEvent* arg__1)
940 {
1015 {
941 if (_wrapper) {
1016 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
942 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
1017 static PyObject* name = PyString_FromString("leaveEvent");
943 PyErr_Clear();
1018 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
944 if (obj && !PythonQtSlotFunction_Check(obj)) {
1019 if (obj) {
945 static const char* argumentList[] ={"" , "QEvent*"};
1020 static const char* argumentList[] ={"" , "QEvent*"};
946 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1021 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
947 void* args[2] = {NULL, (void*)&arg__1};
1022 void* args[2] = {NULL, (void*)&arg__1};
@@ -949,16 +1024,18 if (_wrapper) {
949 if (result) { Py_DECREF(result); }
1024 if (result) { Py_DECREF(result); }
950 Py_DECREF(obj);
1025 Py_DECREF(obj);
951 return;
1026 return;
1027 } else {
1028 PyErr_Clear();
952 }
1029 }
953 }
1030 }
954 MemSizeWdgt::leaveEvent(arg__1);
1031 MemSizeWdgt::leaveEvent(arg__1);
955 }
1032 }
956 int PythonQtShell_MemSizeWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
1033 int PythonQtShell_MemSizeWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
957 {
1034 {
958 if (_wrapper) {
1035 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
959 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
1036 static PyObject* name = PyString_FromString("metric");
960 PyErr_Clear();
1037 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
961 if (obj && !PythonQtSlotFunction_Check(obj)) {
1038 if (obj) {
962 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
1039 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
963 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1040 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
964 int returnValue;
1041 int returnValue;
@@ -977,16 +1054,18 if (_wrapper) {
977 if (result) { Py_DECREF(result); }
1054 if (result) { Py_DECREF(result); }
978 Py_DECREF(obj);
1055 Py_DECREF(obj);
979 return returnValue;
1056 return returnValue;
1057 } else {
1058 PyErr_Clear();
980 }
1059 }
981 }
1060 }
982 return MemSizeWdgt::metric(arg__1);
1061 return MemSizeWdgt::metric(arg__1);
983 }
1062 }
984 QSize PythonQtShell_MemSizeWdgt::minimumSizeHint() const
1063 QSize PythonQtShell_MemSizeWdgt::minimumSizeHint() const
985 {
1064 {
986 if (_wrapper) {
1065 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
987 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
1066 static PyObject* name = PyString_FromString("getMinimumSizeHint");
988 PyErr_Clear();
1067 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
989 if (obj && !PythonQtSlotFunction_Check(obj)) {
1068 if (obj) {
990 static const char* argumentList[] ={"QSize"};
1069 static const char* argumentList[] ={"QSize"};
991 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1070 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
992 QSize returnValue;
1071 QSize returnValue;
@@ -1005,16 +1084,18 if (_wrapper) {
1005 if (result) { Py_DECREF(result); }
1084 if (result) { Py_DECREF(result); }
1006 Py_DECREF(obj);
1085 Py_DECREF(obj);
1007 return returnValue;
1086 return returnValue;
1087 } else {
1088 PyErr_Clear();
1008 }
1089 }
1009 }
1090 }
1010 return MemSizeWdgt::minimumSizeHint();
1091 return MemSizeWdgt::minimumSizeHint();
1011 }
1092 }
1012 void PythonQtShell_MemSizeWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
1093 void PythonQtShell_MemSizeWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
1013 {
1094 {
1014 if (_wrapper) {
1095 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1015 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
1096 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
1016 PyErr_Clear();
1097 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1017 if (obj && !PythonQtSlotFunction_Check(obj)) {
1098 if (obj) {
1018 static const char* argumentList[] ={"" , "QMouseEvent*"};
1099 static const char* argumentList[] ={"" , "QMouseEvent*"};
1019 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1100 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1020 void* args[2] = {NULL, (void*)&arg__1};
1101 void* args[2] = {NULL, (void*)&arg__1};
@@ -1022,16 +1103,18 if (_wrapper) {
1022 if (result) { Py_DECREF(result); }
1103 if (result) { Py_DECREF(result); }
1023 Py_DECREF(obj);
1104 Py_DECREF(obj);
1024 return;
1105 return;
1106 } else {
1107 PyErr_Clear();
1025 }
1108 }
1026 }
1109 }
1027 MemSizeWdgt::mouseDoubleClickEvent(arg__1);
1110 MemSizeWdgt::mouseDoubleClickEvent(arg__1);
1028 }
1111 }
1029 void PythonQtShell_MemSizeWdgt::mouseMoveEvent(QMouseEvent* arg__1)
1112 void PythonQtShell_MemSizeWdgt::mouseMoveEvent(QMouseEvent* arg__1)
1030 {
1113 {
1031 if (_wrapper) {
1114 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1032 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
1115 static PyObject* name = PyString_FromString("mouseMoveEvent");
1033 PyErr_Clear();
1116 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1034 if (obj && !PythonQtSlotFunction_Check(obj)) {
1117 if (obj) {
1035 static const char* argumentList[] ={"" , "QMouseEvent*"};
1118 static const char* argumentList[] ={"" , "QMouseEvent*"};
1036 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1119 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1037 void* args[2] = {NULL, (void*)&arg__1};
1120 void* args[2] = {NULL, (void*)&arg__1};
@@ -1039,16 +1122,18 if (_wrapper) {
1039 if (result) { Py_DECREF(result); }
1122 if (result) { Py_DECREF(result); }
1040 Py_DECREF(obj);
1123 Py_DECREF(obj);
1041 return;
1124 return;
1125 } else {
1126 PyErr_Clear();
1042 }
1127 }
1043 }
1128 }
1044 MemSizeWdgt::mouseMoveEvent(arg__1);
1129 MemSizeWdgt::mouseMoveEvent(arg__1);
1045 }
1130 }
1046 void PythonQtShell_MemSizeWdgt::mousePressEvent(QMouseEvent* arg__1)
1131 void PythonQtShell_MemSizeWdgt::mousePressEvent(QMouseEvent* arg__1)
1047 {
1132 {
1048 if (_wrapper) {
1133 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1049 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
1134 static PyObject* name = PyString_FromString("mousePressEvent");
1050 PyErr_Clear();
1135 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1051 if (obj && !PythonQtSlotFunction_Check(obj)) {
1136 if (obj) {
1052 static const char* argumentList[] ={"" , "QMouseEvent*"};
1137 static const char* argumentList[] ={"" , "QMouseEvent*"};
1053 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1138 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1054 void* args[2] = {NULL, (void*)&arg__1};
1139 void* args[2] = {NULL, (void*)&arg__1};
@@ -1056,16 +1141,18 if (_wrapper) {
1056 if (result) { Py_DECREF(result); }
1141 if (result) { Py_DECREF(result); }
1057 Py_DECREF(obj);
1142 Py_DECREF(obj);
1058 return;
1143 return;
1144 } else {
1145 PyErr_Clear();
1059 }
1146 }
1060 }
1147 }
1061 MemSizeWdgt::mousePressEvent(arg__1);
1148 MemSizeWdgt::mousePressEvent(arg__1);
1062 }
1149 }
1063 void PythonQtShell_MemSizeWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
1150 void PythonQtShell_MemSizeWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
1064 {
1151 {
1065 if (_wrapper) {
1152 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1066 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
1153 static PyObject* name = PyString_FromString("mouseReleaseEvent");
1067 PyErr_Clear();
1154 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1068 if (obj && !PythonQtSlotFunction_Check(obj)) {
1155 if (obj) {
1069 static const char* argumentList[] ={"" , "QMouseEvent*"};
1156 static const char* argumentList[] ={"" , "QMouseEvent*"};
1070 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1157 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1071 void* args[2] = {NULL, (void*)&arg__1};
1158 void* args[2] = {NULL, (void*)&arg__1};
@@ -1073,16 +1160,18 if (_wrapper) {
1073 if (result) { Py_DECREF(result); }
1160 if (result) { Py_DECREF(result); }
1074 Py_DECREF(obj);
1161 Py_DECREF(obj);
1075 return;
1162 return;
1163 } else {
1164 PyErr_Clear();
1076 }
1165 }
1077 }
1166 }
1078 MemSizeWdgt::mouseReleaseEvent(arg__1);
1167 MemSizeWdgt::mouseReleaseEvent(arg__1);
1079 }
1168 }
1080 void PythonQtShell_MemSizeWdgt::moveEvent(QMoveEvent* arg__1)
1169 void PythonQtShell_MemSizeWdgt::moveEvent(QMoveEvent* arg__1)
1081 {
1170 {
1082 if (_wrapper) {
1171 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1083 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
1172 static PyObject* name = PyString_FromString("moveEvent");
1084 PyErr_Clear();
1173 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1085 if (obj && !PythonQtSlotFunction_Check(obj)) {
1174 if (obj) {
1086 static const char* argumentList[] ={"" , "QMoveEvent*"};
1175 static const char* argumentList[] ={"" , "QMoveEvent*"};
1087 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1176 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1088 void* args[2] = {NULL, (void*)&arg__1};
1177 void* args[2] = {NULL, (void*)&arg__1};
@@ -1090,20 +1179,22 if (_wrapper) {
1090 if (result) { Py_DECREF(result); }
1179 if (result) { Py_DECREF(result); }
1091 Py_DECREF(obj);
1180 Py_DECREF(obj);
1092 return;
1181 return;
1182 } else {
1183 PyErr_Clear();
1093 }
1184 }
1094 }
1185 }
1095 MemSizeWdgt::moveEvent(arg__1);
1186 MemSizeWdgt::moveEvent(arg__1);
1096 }
1187 }
1097 bool PythonQtShell_MemSizeWdgt::nativeEvent(const QByteArray& eventType, void* message, long* result)
1188 bool PythonQtShell_MemSizeWdgt::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
1098 {
1189 {
1099 if (_wrapper) {
1190 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1100 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
1191 static PyObject* name = PyString_FromString("nativeEvent");
1101 PyErr_Clear();
1192 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1102 if (obj && !PythonQtSlotFunction_Check(obj)) {
1193 if (obj) {
1103 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
1194 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
1104 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
1195 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
1105 bool returnValue;
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 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1198 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1108 if (result) {
1199 if (result) {
1109 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1200 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -1118,16 +1209,18 if (_wrapper) {
1118 if (result) { Py_DECREF(result); }
1209 if (result) { Py_DECREF(result); }
1119 Py_DECREF(obj);
1210 Py_DECREF(obj);
1120 return returnValue;
1211 return returnValue;
1121 }
1212 } else {
1122 }
1213 PyErr_Clear();
1123 return MemSizeWdgt::nativeEvent(eventType, message, result);
1214 }
1215 }
1216 return MemSizeWdgt::nativeEvent(eventType0, message1, result2);
1124 }
1217 }
1125 QPaintEngine* PythonQtShell_MemSizeWdgt::paintEngine() const
1218 QPaintEngine* PythonQtShell_MemSizeWdgt::paintEngine() const
1126 {
1219 {
1127 if (_wrapper) {
1220 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1128 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
1221 static PyObject* name = PyString_FromString("paintEngine");
1129 PyErr_Clear();
1222 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1130 if (obj && !PythonQtSlotFunction_Check(obj)) {
1223 if (obj) {
1131 static const char* argumentList[] ={"QPaintEngine*"};
1224 static const char* argumentList[] ={"QPaintEngine*"};
1132 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1225 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1133 QPaintEngine* returnValue;
1226 QPaintEngine* returnValue;
@@ -1146,16 +1239,18 if (_wrapper) {
1146 if (result) { Py_DECREF(result); }
1239 if (result) { Py_DECREF(result); }
1147 Py_DECREF(obj);
1240 Py_DECREF(obj);
1148 return returnValue;
1241 return returnValue;
1242 } else {
1243 PyErr_Clear();
1149 }
1244 }
1150 }
1245 }
1151 return MemSizeWdgt::paintEngine();
1246 return MemSizeWdgt::paintEngine();
1152 }
1247 }
1153 void PythonQtShell_MemSizeWdgt::paintEvent(QPaintEvent* arg__1)
1248 void PythonQtShell_MemSizeWdgt::paintEvent(QPaintEvent* arg__1)
1154 {
1249 {
1155 if (_wrapper) {
1250 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1156 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
1251 static PyObject* name = PyString_FromString("paintEvent");
1157 PyErr_Clear();
1252 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1158 if (obj && !PythonQtSlotFunction_Check(obj)) {
1253 if (obj) {
1159 static const char* argumentList[] ={"" , "QPaintEvent*"};
1254 static const char* argumentList[] ={"" , "QPaintEvent*"};
1160 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1255 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1161 void* args[2] = {NULL, (void*)&arg__1};
1256 void* args[2] = {NULL, (void*)&arg__1};
@@ -1163,20 +1258,22 if (_wrapper) {
1163 if (result) { Py_DECREF(result); }
1258 if (result) { Py_DECREF(result); }
1164 Py_DECREF(obj);
1259 Py_DECREF(obj);
1165 return;
1260 return;
1261 } else {
1262 PyErr_Clear();
1166 }
1263 }
1167 }
1264 }
1168 MemSizeWdgt::paintEvent(arg__1);
1265 MemSizeWdgt::paintEvent(arg__1);
1169 }
1266 }
1170 QPaintDevice* PythonQtShell_MemSizeWdgt::redirected(QPoint* offset) const
1267 QPaintDevice* PythonQtShell_MemSizeWdgt::redirected(QPoint* offset0) const
1171 {
1268 {
1172 if (_wrapper) {
1269 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1173 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
1270 static PyObject* name = PyString_FromString("redirected");
1174 PyErr_Clear();
1271 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1175 if (obj && !PythonQtSlotFunction_Check(obj)) {
1272 if (obj) {
1176 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
1273 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
1177 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1274 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1178 QPaintDevice* returnValue;
1275 QPaintDevice* returnValue;
1179 void* args[2] = {NULL, (void*)&offset};
1276 void* args[2] = {NULL, (void*)&offset0};
1180 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1277 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1181 if (result) {
1278 if (result) {
1182 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1279 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -1191,16 +1288,18 if (_wrapper) {
1191 if (result) { Py_DECREF(result); }
1288 if (result) { Py_DECREF(result); }
1192 Py_DECREF(obj);
1289 Py_DECREF(obj);
1193 return returnValue;
1290 return returnValue;
1194 }
1291 } else {
1195 }
1292 PyErr_Clear();
1196 return MemSizeWdgt::redirected(offset);
1293 }
1294 }
1295 return MemSizeWdgt::redirected(offset0);
1197 }
1296 }
1198 void PythonQtShell_MemSizeWdgt::resizeEvent(QResizeEvent* arg__1)
1297 void PythonQtShell_MemSizeWdgt::resizeEvent(QResizeEvent* arg__1)
1199 {
1298 {
1200 if (_wrapper) {
1299 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1201 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
1300 static PyObject* name = PyString_FromString("resizeEvent");
1202 PyErr_Clear();
1301 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1203 if (obj && !PythonQtSlotFunction_Check(obj)) {
1302 if (obj) {
1204 static const char* argumentList[] ={"" , "QResizeEvent*"};
1303 static const char* argumentList[] ={"" , "QResizeEvent*"};
1205 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1304 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1206 void* args[2] = {NULL, (void*)&arg__1};
1305 void* args[2] = {NULL, (void*)&arg__1};
@@ -1208,16 +1307,18 if (_wrapper) {
1208 if (result) { Py_DECREF(result); }
1307 if (result) { Py_DECREF(result); }
1209 Py_DECREF(obj);
1308 Py_DECREF(obj);
1210 return;
1309 return;
1310 } else {
1311 PyErr_Clear();
1211 }
1312 }
1212 }
1313 }
1213 MemSizeWdgt::resizeEvent(arg__1);
1314 MemSizeWdgt::resizeEvent(arg__1);
1214 }
1315 }
1215 QPainter* PythonQtShell_MemSizeWdgt::sharedPainter() const
1316 QPainter* PythonQtShell_MemSizeWdgt::sharedPainter() const
1216 {
1317 {
1217 if (_wrapper) {
1318 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1218 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
1319 static PyObject* name = PyString_FromString("sharedPainter");
1219 PyErr_Clear();
1320 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1220 if (obj && !PythonQtSlotFunction_Check(obj)) {
1321 if (obj) {
1221 static const char* argumentList[] ={"QPainter*"};
1322 static const char* argumentList[] ={"QPainter*"};
1222 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1323 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1223 QPainter* returnValue;
1324 QPainter* returnValue;
@@ -1236,16 +1337,18 if (_wrapper) {
1236 if (result) { Py_DECREF(result); }
1337 if (result) { Py_DECREF(result); }
1237 Py_DECREF(obj);
1338 Py_DECREF(obj);
1238 return returnValue;
1339 return returnValue;
1340 } else {
1341 PyErr_Clear();
1239 }
1342 }
1240 }
1343 }
1241 return MemSizeWdgt::sharedPainter();
1344 return MemSizeWdgt::sharedPainter();
1242 }
1345 }
1243 void PythonQtShell_MemSizeWdgt::showEvent(QShowEvent* arg__1)
1346 void PythonQtShell_MemSizeWdgt::showEvent(QShowEvent* arg__1)
1244 {
1347 {
1245 if (_wrapper) {
1348 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1246 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
1349 static PyObject* name = PyString_FromString("showEvent");
1247 PyErr_Clear();
1350 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1248 if (obj && !PythonQtSlotFunction_Check(obj)) {
1351 if (obj) {
1249 static const char* argumentList[] ={"" , "QShowEvent*"};
1352 static const char* argumentList[] ={"" , "QShowEvent*"};
1250 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1353 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1251 void* args[2] = {NULL, (void*)&arg__1};
1354 void* args[2] = {NULL, (void*)&arg__1};
@@ -1253,16 +1356,18 if (_wrapper) {
1253 if (result) { Py_DECREF(result); }
1356 if (result) { Py_DECREF(result); }
1254 Py_DECREF(obj);
1357 Py_DECREF(obj);
1255 return;
1358 return;
1359 } else {
1360 PyErr_Clear();
1256 }
1361 }
1257 }
1362 }
1258 MemSizeWdgt::showEvent(arg__1);
1363 MemSizeWdgt::showEvent(arg__1);
1259 }
1364 }
1260 QSize PythonQtShell_MemSizeWdgt::sizeHint() const
1365 QSize PythonQtShell_MemSizeWdgt::sizeHint() const
1261 {
1366 {
1262 if (_wrapper) {
1367 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1263 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
1368 static PyObject* name = PyString_FromString("getSizeHint");
1264 PyErr_Clear();
1369 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1265 if (obj && !PythonQtSlotFunction_Check(obj)) {
1370 if (obj) {
1266 static const char* argumentList[] ={"QSize"};
1371 static const char* argumentList[] ={"QSize"};
1267 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1372 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1268 QSize returnValue;
1373 QSize returnValue;
@@ -1281,16 +1386,18 if (_wrapper) {
1281 if (result) { Py_DECREF(result); }
1386 if (result) { Py_DECREF(result); }
1282 Py_DECREF(obj);
1387 Py_DECREF(obj);
1283 return returnValue;
1388 return returnValue;
1389 } else {
1390 PyErr_Clear();
1284 }
1391 }
1285 }
1392 }
1286 return MemSizeWdgt::sizeHint();
1393 return MemSizeWdgt::sizeHint();
1287 }
1394 }
1288 void PythonQtShell_MemSizeWdgt::tabletEvent(QTabletEvent* arg__1)
1395 void PythonQtShell_MemSizeWdgt::tabletEvent(QTabletEvent* arg__1)
1289 {
1396 {
1290 if (_wrapper) {
1397 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1291 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
1398 static PyObject* name = PyString_FromString("tabletEvent");
1292 PyErr_Clear();
1399 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1293 if (obj && !PythonQtSlotFunction_Check(obj)) {
1400 if (obj) {
1294 static const char* argumentList[] ={"" , "QTabletEvent*"};
1401 static const char* argumentList[] ={"" , "QTabletEvent*"};
1295 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1402 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1296 void* args[2] = {NULL, (void*)&arg__1};
1403 void* args[2] = {NULL, (void*)&arg__1};
@@ -1298,16 +1405,18 if (_wrapper) {
1298 if (result) { Py_DECREF(result); }
1405 if (result) { Py_DECREF(result); }
1299 Py_DECREF(obj);
1406 Py_DECREF(obj);
1300 return;
1407 return;
1408 } else {
1409 PyErr_Clear();
1301 }
1410 }
1302 }
1411 }
1303 MemSizeWdgt::tabletEvent(arg__1);
1412 MemSizeWdgt::tabletEvent(arg__1);
1304 }
1413 }
1305 void PythonQtShell_MemSizeWdgt::timerEvent(QTimerEvent* arg__1)
1414 void PythonQtShell_MemSizeWdgt::timerEvent(QTimerEvent* arg__1)
1306 {
1415 {
1307 if (_wrapper) {
1416 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1308 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
1417 static PyObject* name = PyString_FromString("timerEvent");
1309 PyErr_Clear();
1418 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1310 if (obj && !PythonQtSlotFunction_Check(obj)) {
1419 if (obj) {
1311 static const char* argumentList[] ={"" , "QTimerEvent*"};
1420 static const char* argumentList[] ={"" , "QTimerEvent*"};
1312 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1421 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1313 void* args[2] = {NULL, (void*)&arg__1};
1422 void* args[2] = {NULL, (void*)&arg__1};
@@ -1315,16 +1424,18 if (_wrapper) {
1315 if (result) { Py_DECREF(result); }
1424 if (result) { Py_DECREF(result); }
1316 Py_DECREF(obj);
1425 Py_DECREF(obj);
1317 return;
1426 return;
1427 } else {
1428 PyErr_Clear();
1318 }
1429 }
1319 }
1430 }
1320 MemSizeWdgt::timerEvent(arg__1);
1431 MemSizeWdgt::timerEvent(arg__1);
1321 }
1432 }
1322 void PythonQtShell_MemSizeWdgt::wheelEvent(QWheelEvent* arg__1)
1433 void PythonQtShell_MemSizeWdgt::wheelEvent(QWheelEvent* arg__1)
1323 {
1434 {
1324 if (_wrapper) {
1435 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1325 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
1436 static PyObject* name = PyString_FromString("wheelEvent");
1326 PyErr_Clear();
1437 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1327 if (obj && !PythonQtSlotFunction_Check(obj)) {
1438 if (obj) {
1328 static const char* argumentList[] ={"" , "QWheelEvent*"};
1439 static const char* argumentList[] ={"" , "QWheelEvent*"};
1329 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1440 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1330 void* args[2] = {NULL, (void*)&arg__1};
1441 void* args[2] = {NULL, (void*)&arg__1};
@@ -1332,6 +1443,8 if (_wrapper) {
1332 if (result) { Py_DECREF(result); }
1443 if (result) { Py_DECREF(result); }
1333 Py_DECREF(obj);
1444 Py_DECREF(obj);
1334 return;
1445 return;
1446 } else {
1447 PyErr_Clear();
1335 }
1448 }
1336 }
1449 }
1337 MemSizeWdgt::wheelEvent(arg__1);
1450 MemSizeWdgt::wheelEvent(arg__1);
@@ -1372,10 +1485,10 PythonQtShell_QHexEdit::~PythonQtShell_Q
1372 }
1485 }
1373 void PythonQtShell_QHexEdit::actionEvent(QActionEvent* arg__1)
1486 void PythonQtShell_QHexEdit::actionEvent(QActionEvent* arg__1)
1374 {
1487 {
1375 if (_wrapper) {
1488 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1376 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
1489 static PyObject* name = PyString_FromString("actionEvent");
1377 PyErr_Clear();
1490 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1378 if (obj && !PythonQtSlotFunction_Check(obj)) {
1491 if (obj) {
1379 static const char* argumentList[] ={"" , "QActionEvent*"};
1492 static const char* argumentList[] ={"" , "QActionEvent*"};
1380 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1493 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1381 void* args[2] = {NULL, (void*)&arg__1};
1494 void* args[2] = {NULL, (void*)&arg__1};
@@ -1383,16 +1496,18 if (_wrapper) {
1383 if (result) { Py_DECREF(result); }
1496 if (result) { Py_DECREF(result); }
1384 Py_DECREF(obj);
1497 Py_DECREF(obj);
1385 return;
1498 return;
1499 } else {
1500 PyErr_Clear();
1386 }
1501 }
1387 }
1502 }
1388 QHexEdit::actionEvent(arg__1);
1503 QHexEdit::actionEvent(arg__1);
1389 }
1504 }
1390 void PythonQtShell_QHexEdit::changeEvent(QEvent* arg__1)
1505 void PythonQtShell_QHexEdit::changeEvent(QEvent* arg__1)
1391 {
1506 {
1392 if (_wrapper) {
1507 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1393 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
1508 static PyObject* name = PyString_FromString("changeEvent");
1394 PyErr_Clear();
1509 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1395 if (obj && !PythonQtSlotFunction_Check(obj)) {
1510 if (obj) {
1396 static const char* argumentList[] ={"" , "QEvent*"};
1511 static const char* argumentList[] ={"" , "QEvent*"};
1397 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1512 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1398 void* args[2] = {NULL, (void*)&arg__1};
1513 void* args[2] = {NULL, (void*)&arg__1};
@@ -1400,16 +1515,18 if (_wrapper) {
1400 if (result) { Py_DECREF(result); }
1515 if (result) { Py_DECREF(result); }
1401 Py_DECREF(obj);
1516 Py_DECREF(obj);
1402 return;
1517 return;
1518 } else {
1519 PyErr_Clear();
1403 }
1520 }
1404 }
1521 }
1405 QHexEdit::changeEvent(arg__1);
1522 QHexEdit::changeEvent(arg__1);
1406 }
1523 }
1407 void PythonQtShell_QHexEdit::childEvent(QChildEvent* arg__1)
1524 void PythonQtShell_QHexEdit::childEvent(QChildEvent* arg__1)
1408 {
1525 {
1409 if (_wrapper) {
1526 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1410 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
1527 static PyObject* name = PyString_FromString("childEvent");
1411 PyErr_Clear();
1528 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1412 if (obj && !PythonQtSlotFunction_Check(obj)) {
1529 if (obj) {
1413 static const char* argumentList[] ={"" , "QChildEvent*"};
1530 static const char* argumentList[] ={"" , "QChildEvent*"};
1414 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1531 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1415 void* args[2] = {NULL, (void*)&arg__1};
1532 void* args[2] = {NULL, (void*)&arg__1};
@@ -1417,16 +1534,18 if (_wrapper) {
1417 if (result) { Py_DECREF(result); }
1534 if (result) { Py_DECREF(result); }
1418 Py_DECREF(obj);
1535 Py_DECREF(obj);
1419 return;
1536 return;
1537 } else {
1538 PyErr_Clear();
1420 }
1539 }
1421 }
1540 }
1422 QHexEdit::childEvent(arg__1);
1541 QHexEdit::childEvent(arg__1);
1423 }
1542 }
1424 void PythonQtShell_QHexEdit::closeEvent(QCloseEvent* arg__1)
1543 void PythonQtShell_QHexEdit::closeEvent(QCloseEvent* arg__1)
1425 {
1544 {
1426 if (_wrapper) {
1545 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1427 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
1546 static PyObject* name = PyString_FromString("closeEvent");
1428 PyErr_Clear();
1547 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1429 if (obj && !PythonQtSlotFunction_Check(obj)) {
1548 if (obj) {
1430 static const char* argumentList[] ={"" , "QCloseEvent*"};
1549 static const char* argumentList[] ={"" , "QCloseEvent*"};
1431 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1550 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1432 void* args[2] = {NULL, (void*)&arg__1};
1551 void* args[2] = {NULL, (void*)&arg__1};
@@ -1434,16 +1553,18 if (_wrapper) {
1434 if (result) { Py_DECREF(result); }
1553 if (result) { Py_DECREF(result); }
1435 Py_DECREF(obj);
1554 Py_DECREF(obj);
1436 return;
1555 return;
1556 } else {
1557 PyErr_Clear();
1437 }
1558 }
1438 }
1559 }
1439 QHexEdit::closeEvent(arg__1);
1560 QHexEdit::closeEvent(arg__1);
1440 }
1561 }
1441 void PythonQtShell_QHexEdit::contextMenuEvent(QContextMenuEvent* arg__1)
1562 void PythonQtShell_QHexEdit::contextMenuEvent(QContextMenuEvent* arg__1)
1442 {
1563 {
1443 if (_wrapper) {
1564 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1444 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
1565 static PyObject* name = PyString_FromString("contextMenuEvent");
1445 PyErr_Clear();
1566 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1446 if (obj && !PythonQtSlotFunction_Check(obj)) {
1567 if (obj) {
1447 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
1568 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
1448 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1569 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1449 void* args[2] = {NULL, (void*)&arg__1};
1570 void* args[2] = {NULL, (void*)&arg__1};
@@ -1451,16 +1572,18 if (_wrapper) {
1451 if (result) { Py_DECREF(result); }
1572 if (result) { Py_DECREF(result); }
1452 Py_DECREF(obj);
1573 Py_DECREF(obj);
1453 return;
1574 return;
1575 } else {
1576 PyErr_Clear();
1454 }
1577 }
1455 }
1578 }
1456 QHexEdit::contextMenuEvent(arg__1);
1579 QHexEdit::contextMenuEvent(arg__1);
1457 }
1580 }
1458 void PythonQtShell_QHexEdit::customEvent(QEvent* arg__1)
1581 void PythonQtShell_QHexEdit::customEvent(QEvent* arg__1)
1459 {
1582 {
1460 if (_wrapper) {
1583 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1461 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
1584 static PyObject* name = PyString_FromString("customEvent");
1462 PyErr_Clear();
1585 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1463 if (obj && !PythonQtSlotFunction_Check(obj)) {
1586 if (obj) {
1464 static const char* argumentList[] ={"" , "QEvent*"};
1587 static const char* argumentList[] ={"" , "QEvent*"};
1465 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1588 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1466 void* args[2] = {NULL, (void*)&arg__1};
1589 void* args[2] = {NULL, (void*)&arg__1};
@@ -1468,16 +1591,18 if (_wrapper) {
1468 if (result) { Py_DECREF(result); }
1591 if (result) { Py_DECREF(result); }
1469 Py_DECREF(obj);
1592 Py_DECREF(obj);
1470 return;
1593 return;
1594 } else {
1595 PyErr_Clear();
1471 }
1596 }
1472 }
1597 }
1473 QHexEdit::customEvent(arg__1);
1598 QHexEdit::customEvent(arg__1);
1474 }
1599 }
1475 int PythonQtShell_QHexEdit::devType() const
1600 int PythonQtShell_QHexEdit::devType() const
1476 {
1601 {
1477 if (_wrapper) {
1602 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1478 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
1603 static PyObject* name = PyString_FromString("devType");
1479 PyErr_Clear();
1604 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1480 if (obj && !PythonQtSlotFunction_Check(obj)) {
1605 if (obj) {
1481 static const char* argumentList[] ={"int"};
1606 static const char* argumentList[] ={"int"};
1482 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1607 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1483 int returnValue;
1608 int returnValue;
@@ -1496,16 +1621,18 if (_wrapper) {
1496 if (result) { Py_DECREF(result); }
1621 if (result) { Py_DECREF(result); }
1497 Py_DECREF(obj);
1622 Py_DECREF(obj);
1498 return returnValue;
1623 return returnValue;
1624 } else {
1625 PyErr_Clear();
1499 }
1626 }
1500 }
1627 }
1501 return QHexEdit::devType();
1628 return QHexEdit::devType();
1502 }
1629 }
1503 void PythonQtShell_QHexEdit::dragEnterEvent(QDragEnterEvent* arg__1)
1630 void PythonQtShell_QHexEdit::dragEnterEvent(QDragEnterEvent* arg__1)
1504 {
1631 {
1505 if (_wrapper) {
1632 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1506 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
1633 static PyObject* name = PyString_FromString("dragEnterEvent");
1507 PyErr_Clear();
1634 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1508 if (obj && !PythonQtSlotFunction_Check(obj)) {
1635 if (obj) {
1509 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
1636 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
1510 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1637 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1511 void* args[2] = {NULL, (void*)&arg__1};
1638 void* args[2] = {NULL, (void*)&arg__1};
@@ -1513,16 +1640,18 if (_wrapper) {
1513 if (result) { Py_DECREF(result); }
1640 if (result) { Py_DECREF(result); }
1514 Py_DECREF(obj);
1641 Py_DECREF(obj);
1515 return;
1642 return;
1643 } else {
1644 PyErr_Clear();
1516 }
1645 }
1517 }
1646 }
1518 QHexEdit::dragEnterEvent(arg__1);
1647 QHexEdit::dragEnterEvent(arg__1);
1519 }
1648 }
1520 void PythonQtShell_QHexEdit::dragLeaveEvent(QDragLeaveEvent* arg__1)
1649 void PythonQtShell_QHexEdit::dragLeaveEvent(QDragLeaveEvent* arg__1)
1521 {
1650 {
1522 if (_wrapper) {
1651 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1523 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
1652 static PyObject* name = PyString_FromString("dragLeaveEvent");
1524 PyErr_Clear();
1653 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1525 if (obj && !PythonQtSlotFunction_Check(obj)) {
1654 if (obj) {
1526 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
1655 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
1527 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1656 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1528 void* args[2] = {NULL, (void*)&arg__1};
1657 void* args[2] = {NULL, (void*)&arg__1};
@@ -1530,16 +1659,18 if (_wrapper) {
1530 if (result) { Py_DECREF(result); }
1659 if (result) { Py_DECREF(result); }
1531 Py_DECREF(obj);
1660 Py_DECREF(obj);
1532 return;
1661 return;
1662 } else {
1663 PyErr_Clear();
1533 }
1664 }
1534 }
1665 }
1535 QHexEdit::dragLeaveEvent(arg__1);
1666 QHexEdit::dragLeaveEvent(arg__1);
1536 }
1667 }
1537 void PythonQtShell_QHexEdit::dragMoveEvent(QDragMoveEvent* arg__1)
1668 void PythonQtShell_QHexEdit::dragMoveEvent(QDragMoveEvent* arg__1)
1538 {
1669 {
1539 if (_wrapper) {
1670 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1540 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
1671 static PyObject* name = PyString_FromString("dragMoveEvent");
1541 PyErr_Clear();
1672 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1542 if (obj && !PythonQtSlotFunction_Check(obj)) {
1673 if (obj) {
1543 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
1674 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
1544 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1675 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1545 void* args[2] = {NULL, (void*)&arg__1};
1676 void* args[2] = {NULL, (void*)&arg__1};
@@ -1547,16 +1678,18 if (_wrapper) {
1547 if (result) { Py_DECREF(result); }
1678 if (result) { Py_DECREF(result); }
1548 Py_DECREF(obj);
1679 Py_DECREF(obj);
1549 return;
1680 return;
1681 } else {
1682 PyErr_Clear();
1550 }
1683 }
1551 }
1684 }
1552 QHexEdit::dragMoveEvent(arg__1);
1685 QHexEdit::dragMoveEvent(arg__1);
1553 }
1686 }
1554 void PythonQtShell_QHexEdit::dropEvent(QDropEvent* arg__1)
1687 void PythonQtShell_QHexEdit::dropEvent(QDropEvent* arg__1)
1555 {
1688 {
1556 if (_wrapper) {
1689 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1557 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
1690 static PyObject* name = PyString_FromString("dropEvent");
1558 PyErr_Clear();
1691 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1559 if (obj && !PythonQtSlotFunction_Check(obj)) {
1692 if (obj) {
1560 static const char* argumentList[] ={"" , "QDropEvent*"};
1693 static const char* argumentList[] ={"" , "QDropEvent*"};
1561 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1694 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1562 void* args[2] = {NULL, (void*)&arg__1};
1695 void* args[2] = {NULL, (void*)&arg__1};
@@ -1564,16 +1697,18 if (_wrapper) {
1564 if (result) { Py_DECREF(result); }
1697 if (result) { Py_DECREF(result); }
1565 Py_DECREF(obj);
1698 Py_DECREF(obj);
1566 return;
1699 return;
1700 } else {
1701 PyErr_Clear();
1567 }
1702 }
1568 }
1703 }
1569 QHexEdit::dropEvent(arg__1);
1704 QHexEdit::dropEvent(arg__1);
1570 }
1705 }
1571 void PythonQtShell_QHexEdit::enterEvent(QEvent* arg__1)
1706 void PythonQtShell_QHexEdit::enterEvent(QEvent* arg__1)
1572 {
1707 {
1573 if (_wrapper) {
1708 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1574 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
1709 static PyObject* name = PyString_FromString("enterEvent");
1575 PyErr_Clear();
1710 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1576 if (obj && !PythonQtSlotFunction_Check(obj)) {
1711 if (obj) {
1577 static const char* argumentList[] ={"" , "QEvent*"};
1712 static const char* argumentList[] ={"" , "QEvent*"};
1578 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1713 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1579 void* args[2] = {NULL, (void*)&arg__1};
1714 void* args[2] = {NULL, (void*)&arg__1};
@@ -1581,16 +1716,18 if (_wrapper) {
1581 if (result) { Py_DECREF(result); }
1716 if (result) { Py_DECREF(result); }
1582 Py_DECREF(obj);
1717 Py_DECREF(obj);
1583 return;
1718 return;
1719 } else {
1720 PyErr_Clear();
1584 }
1721 }
1585 }
1722 }
1586 QHexEdit::enterEvent(arg__1);
1723 QHexEdit::enterEvent(arg__1);
1587 }
1724 }
1588 bool PythonQtShell_QHexEdit::event(QEvent* arg__1)
1725 bool PythonQtShell_QHexEdit::event(QEvent* arg__1)
1589 {
1726 {
1590 if (_wrapper) {
1727 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1591 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
1728 static PyObject* name = PyString_FromString("event");
1592 PyErr_Clear();
1729 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1593 if (obj && !PythonQtSlotFunction_Check(obj)) {
1730 if (obj) {
1594 static const char* argumentList[] ={"bool" , "QEvent*"};
1731 static const char* argumentList[] ={"bool" , "QEvent*"};
1595 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1732 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1596 bool returnValue;
1733 bool returnValue;
@@ -1609,16 +1746,18 if (_wrapper) {
1609 if (result) { Py_DECREF(result); }
1746 if (result) { Py_DECREF(result); }
1610 Py_DECREF(obj);
1747 Py_DECREF(obj);
1611 return returnValue;
1748 return returnValue;
1749 } else {
1750 PyErr_Clear();
1612 }
1751 }
1613 }
1752 }
1614 return QHexEdit::event(arg__1);
1753 return QHexEdit::event(arg__1);
1615 }
1754 }
1616 bool PythonQtShell_QHexEdit::eventFilter(QObject* arg__1, QEvent* arg__2)
1755 bool PythonQtShell_QHexEdit::eventFilter(QObject* arg__1, QEvent* arg__2)
1617 {
1756 {
1618 if (_wrapper) {
1757 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1619 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
1758 static PyObject* name = PyString_FromString("eventFilter");
1620 PyErr_Clear();
1759 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1621 if (obj && !PythonQtSlotFunction_Check(obj)) {
1760 if (obj) {
1622 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
1761 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
1623 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
1762 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
1624 bool returnValue;
1763 bool returnValue;
@@ -1637,16 +1776,18 if (_wrapper) {
1637 if (result) { Py_DECREF(result); }
1776 if (result) { Py_DECREF(result); }
1638 Py_DECREF(obj);
1777 Py_DECREF(obj);
1639 return returnValue;
1778 return returnValue;
1779 } else {
1780 PyErr_Clear();
1640 }
1781 }
1641 }
1782 }
1642 return QHexEdit::eventFilter(arg__1, arg__2);
1783 return QHexEdit::eventFilter(arg__1, arg__2);
1643 }
1784 }
1644 void PythonQtShell_QHexEdit::focusInEvent(QFocusEvent* arg__1)
1785 void PythonQtShell_QHexEdit::focusInEvent(QFocusEvent* arg__1)
1645 {
1786 {
1646 if (_wrapper) {
1787 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1647 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
1788 static PyObject* name = PyString_FromString("focusInEvent");
1648 PyErr_Clear();
1789 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1649 if (obj && !PythonQtSlotFunction_Check(obj)) {
1790 if (obj) {
1650 static const char* argumentList[] ={"" , "QFocusEvent*"};
1791 static const char* argumentList[] ={"" , "QFocusEvent*"};
1651 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1792 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1652 void* args[2] = {NULL, (void*)&arg__1};
1793 void* args[2] = {NULL, (void*)&arg__1};
@@ -1654,20 +1795,22 if (_wrapper) {
1654 if (result) { Py_DECREF(result); }
1795 if (result) { Py_DECREF(result); }
1655 Py_DECREF(obj);
1796 Py_DECREF(obj);
1656 return;
1797 return;
1798 } else {
1799 PyErr_Clear();
1657 }
1800 }
1658 }
1801 }
1659 QHexEdit::focusInEvent(arg__1);
1802 QHexEdit::focusInEvent(arg__1);
1660 }
1803 }
1661 bool PythonQtShell_QHexEdit::focusNextPrevChild(bool next)
1804 bool PythonQtShell_QHexEdit::focusNextPrevChild(bool next0)
1662 {
1805 {
1663 if (_wrapper) {
1806 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1664 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
1807 static PyObject* name = PyString_FromString("focusNextPrevChild");
1665 PyErr_Clear();
1808 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1666 if (obj && !PythonQtSlotFunction_Check(obj)) {
1809 if (obj) {
1667 static const char* argumentList[] ={"bool" , "bool"};
1810 static const char* argumentList[] ={"bool" , "bool"};
1668 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1811 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1669 bool returnValue;
1812 bool returnValue;
1670 void* args[2] = {NULL, (void*)&next};
1813 void* args[2] = {NULL, (void*)&next0};
1671 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1814 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1672 if (result) {
1815 if (result) {
1673 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1816 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -1682,16 +1825,18 if (_wrapper) {
1682 if (result) { Py_DECREF(result); }
1825 if (result) { Py_DECREF(result); }
1683 Py_DECREF(obj);
1826 Py_DECREF(obj);
1684 return returnValue;
1827 return returnValue;
1685 }
1828 } else {
1686 }
1829 PyErr_Clear();
1687 return QHexEdit::focusNextPrevChild(next);
1830 }
1831 }
1832 return QHexEdit::focusNextPrevChild(next0);
1688 }
1833 }
1689 void PythonQtShell_QHexEdit::focusOutEvent(QFocusEvent* arg__1)
1834 void PythonQtShell_QHexEdit::focusOutEvent(QFocusEvent* arg__1)
1690 {
1835 {
1691 if (_wrapper) {
1836 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1692 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
1837 static PyObject* name = PyString_FromString("focusOutEvent");
1693 PyErr_Clear();
1838 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1694 if (obj && !PythonQtSlotFunction_Check(obj)) {
1839 if (obj) {
1695 static const char* argumentList[] ={"" , "QFocusEvent*"};
1840 static const char* argumentList[] ={"" , "QFocusEvent*"};
1696 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1841 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1697 void* args[2] = {NULL, (void*)&arg__1};
1842 void* args[2] = {NULL, (void*)&arg__1};
@@ -1699,16 +1844,18 if (_wrapper) {
1699 if (result) { Py_DECREF(result); }
1844 if (result) { Py_DECREF(result); }
1700 Py_DECREF(obj);
1845 Py_DECREF(obj);
1701 return;
1846 return;
1847 } else {
1848 PyErr_Clear();
1702 }
1849 }
1703 }
1850 }
1704 QHexEdit::focusOutEvent(arg__1);
1851 QHexEdit::focusOutEvent(arg__1);
1705 }
1852 }
1706 bool PythonQtShell_QHexEdit::hasHeightForWidth() const
1853 bool PythonQtShell_QHexEdit::hasHeightForWidth() const
1707 {
1854 {
1708 if (_wrapper) {
1855 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1709 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
1856 static PyObject* name = PyString_FromString("hasHeightForWidth");
1710 PyErr_Clear();
1857 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1711 if (obj && !PythonQtSlotFunction_Check(obj)) {
1858 if (obj) {
1712 static const char* argumentList[] ={"bool"};
1859 static const char* argumentList[] ={"bool"};
1713 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1860 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1714 bool returnValue;
1861 bool returnValue;
@@ -1727,16 +1874,18 if (_wrapper) {
1727 if (result) { Py_DECREF(result); }
1874 if (result) { Py_DECREF(result); }
1728 Py_DECREF(obj);
1875 Py_DECREF(obj);
1729 return returnValue;
1876 return returnValue;
1877 } else {
1878 PyErr_Clear();
1730 }
1879 }
1731 }
1880 }
1732 return QHexEdit::hasHeightForWidth();
1881 return QHexEdit::hasHeightForWidth();
1733 }
1882 }
1734 int PythonQtShell_QHexEdit::heightForWidth(int arg__1) const
1883 int PythonQtShell_QHexEdit::heightForWidth(int arg__1) const
1735 {
1884 {
1736 if (_wrapper) {
1885 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1737 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
1886 static PyObject* name = PyString_FromString("heightForWidth");
1738 PyErr_Clear();
1887 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1739 if (obj && !PythonQtSlotFunction_Check(obj)) {
1888 if (obj) {
1740 static const char* argumentList[] ={"int" , "int"};
1889 static const char* argumentList[] ={"int" , "int"};
1741 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1890 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1742 int returnValue;
1891 int returnValue;
@@ -1755,16 +1904,18 if (_wrapper) {
1755 if (result) { Py_DECREF(result); }
1904 if (result) { Py_DECREF(result); }
1756 Py_DECREF(obj);
1905 Py_DECREF(obj);
1757 return returnValue;
1906 return returnValue;
1907 } else {
1908 PyErr_Clear();
1758 }
1909 }
1759 }
1910 }
1760 return QHexEdit::heightForWidth(arg__1);
1911 return QHexEdit::heightForWidth(arg__1);
1761 }
1912 }
1762 void PythonQtShell_QHexEdit::hideEvent(QHideEvent* arg__1)
1913 void PythonQtShell_QHexEdit::hideEvent(QHideEvent* arg__1)
1763 {
1914 {
1764 if (_wrapper) {
1915 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1765 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
1916 static PyObject* name = PyString_FromString("hideEvent");
1766 PyErr_Clear();
1917 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1767 if (obj && !PythonQtSlotFunction_Check(obj)) {
1918 if (obj) {
1768 static const char* argumentList[] ={"" , "QHideEvent*"};
1919 static const char* argumentList[] ={"" , "QHideEvent*"};
1769 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1920 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1770 void* args[2] = {NULL, (void*)&arg__1};
1921 void* args[2] = {NULL, (void*)&arg__1};
@@ -1772,33 +1923,37 if (_wrapper) {
1772 if (result) { Py_DECREF(result); }
1923 if (result) { Py_DECREF(result); }
1773 Py_DECREF(obj);
1924 Py_DECREF(obj);
1774 return;
1925 return;
1926 } else {
1927 PyErr_Clear();
1775 }
1928 }
1776 }
1929 }
1777 QHexEdit::hideEvent(arg__1);
1930 QHexEdit::hideEvent(arg__1);
1778 }
1931 }
1779 void PythonQtShell_QHexEdit::initPainter(QPainter* painter) const
1932 void PythonQtShell_QHexEdit::initPainter(QPainter* painter0) const
1780 {
1933 {
1781 if (_wrapper) {
1934 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1782 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
1935 static PyObject* name = PyString_FromString("initPainter");
1783 PyErr_Clear();
1936 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1784 if (obj && !PythonQtSlotFunction_Check(obj)) {
1937 if (obj) {
1785 static const char* argumentList[] ={"" , "QPainter*"};
1938 static const char* argumentList[] ={"" , "QPainter*"};
1786 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1939 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1787 void* args[2] = {NULL, (void*)&painter};
1940 void* args[2] = {NULL, (void*)&painter0};
1788 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1941 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1789 if (result) { Py_DECREF(result); }
1942 if (result) { Py_DECREF(result); }
1790 Py_DECREF(obj);
1943 Py_DECREF(obj);
1791 return;
1944 return;
1792 }
1945 } else {
1793 }
1946 PyErr_Clear();
1794 QHexEdit::initPainter(painter);
1947 }
1948 }
1949 QHexEdit::initPainter(painter0);
1795 }
1950 }
1796 void PythonQtShell_QHexEdit::inputMethodEvent(QInputMethodEvent* arg__1)
1951 void PythonQtShell_QHexEdit::inputMethodEvent(QInputMethodEvent* arg__1)
1797 {
1952 {
1798 if (_wrapper) {
1953 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1799 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
1954 static PyObject* name = PyString_FromString("inputMethodEvent");
1800 PyErr_Clear();
1955 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1801 if (obj && !PythonQtSlotFunction_Check(obj)) {
1956 if (obj) {
1802 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
1957 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
1803 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1958 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1804 void* args[2] = {NULL, (void*)&arg__1};
1959 void* args[2] = {NULL, (void*)&arg__1};
@@ -1806,16 +1961,18 if (_wrapper) {
1806 if (result) { Py_DECREF(result); }
1961 if (result) { Py_DECREF(result); }
1807 Py_DECREF(obj);
1962 Py_DECREF(obj);
1808 return;
1963 return;
1964 } else {
1965 PyErr_Clear();
1809 }
1966 }
1810 }
1967 }
1811 QHexEdit::inputMethodEvent(arg__1);
1968 QHexEdit::inputMethodEvent(arg__1);
1812 }
1969 }
1813 QVariant PythonQtShell_QHexEdit::inputMethodQuery(Qt::InputMethodQuery arg__1) const
1970 QVariant PythonQtShell_QHexEdit::inputMethodQuery(Qt::InputMethodQuery arg__1) const
1814 {
1971 {
1815 if (_wrapper) {
1972 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1816 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
1973 static PyObject* name = PyString_FromString("inputMethodQuery");
1817 PyErr_Clear();
1974 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1818 if (obj && !PythonQtSlotFunction_Check(obj)) {
1975 if (obj) {
1819 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
1976 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
1820 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1977 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1821 QVariant returnValue;
1978 QVariant returnValue;
@@ -1834,16 +1991,18 if (_wrapper) {
1834 if (result) { Py_DECREF(result); }
1991 if (result) { Py_DECREF(result); }
1835 Py_DECREF(obj);
1992 Py_DECREF(obj);
1836 return returnValue;
1993 return returnValue;
1994 } else {
1995 PyErr_Clear();
1837 }
1996 }
1838 }
1997 }
1839 return QHexEdit::inputMethodQuery(arg__1);
1998 return QHexEdit::inputMethodQuery(arg__1);
1840 }
1999 }
1841 void PythonQtShell_QHexEdit::keyPressEvent(QKeyEvent* arg__1)
2000 void PythonQtShell_QHexEdit::keyPressEvent(QKeyEvent* arg__1)
1842 {
2001 {
1843 if (_wrapper) {
2002 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1844 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
2003 static PyObject* name = PyString_FromString("keyPressEvent");
1845 PyErr_Clear();
2004 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1846 if (obj && !PythonQtSlotFunction_Check(obj)) {
2005 if (obj) {
1847 static const char* argumentList[] ={"" , "QKeyEvent*"};
2006 static const char* argumentList[] ={"" , "QKeyEvent*"};
1848 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2007 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1849 void* args[2] = {NULL, (void*)&arg__1};
2008 void* args[2] = {NULL, (void*)&arg__1};
@@ -1851,16 +2010,18 if (_wrapper) {
1851 if (result) { Py_DECREF(result); }
2010 if (result) { Py_DECREF(result); }
1852 Py_DECREF(obj);
2011 Py_DECREF(obj);
1853 return;
2012 return;
2013 } else {
2014 PyErr_Clear();
1854 }
2015 }
1855 }
2016 }
1856 QHexEdit::keyPressEvent(arg__1);
2017 QHexEdit::keyPressEvent(arg__1);
1857 }
2018 }
1858 void PythonQtShell_QHexEdit::keyReleaseEvent(QKeyEvent* arg__1)
2019 void PythonQtShell_QHexEdit::keyReleaseEvent(QKeyEvent* arg__1)
1859 {
2020 {
1860 if (_wrapper) {
2021 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1861 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
2022 static PyObject* name = PyString_FromString("keyReleaseEvent");
1862 PyErr_Clear();
2023 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1863 if (obj && !PythonQtSlotFunction_Check(obj)) {
2024 if (obj) {
1864 static const char* argumentList[] ={"" , "QKeyEvent*"};
2025 static const char* argumentList[] ={"" , "QKeyEvent*"};
1865 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2026 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1866 void* args[2] = {NULL, (void*)&arg__1};
2027 void* args[2] = {NULL, (void*)&arg__1};
@@ -1868,16 +2029,18 if (_wrapper) {
1868 if (result) { Py_DECREF(result); }
2029 if (result) { Py_DECREF(result); }
1869 Py_DECREF(obj);
2030 Py_DECREF(obj);
1870 return;
2031 return;
2032 } else {
2033 PyErr_Clear();
1871 }
2034 }
1872 }
2035 }
1873 QHexEdit::keyReleaseEvent(arg__1);
2036 QHexEdit::keyReleaseEvent(arg__1);
1874 }
2037 }
1875 void PythonQtShell_QHexEdit::leaveEvent(QEvent* arg__1)
2038 void PythonQtShell_QHexEdit::leaveEvent(QEvent* arg__1)
1876 {
2039 {
1877 if (_wrapper) {
2040 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1878 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
2041 static PyObject* name = PyString_FromString("leaveEvent");
1879 PyErr_Clear();
2042 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1880 if (obj && !PythonQtSlotFunction_Check(obj)) {
2043 if (obj) {
1881 static const char* argumentList[] ={"" , "QEvent*"};
2044 static const char* argumentList[] ={"" , "QEvent*"};
1882 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2045 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1883 void* args[2] = {NULL, (void*)&arg__1};
2046 void* args[2] = {NULL, (void*)&arg__1};
@@ -1885,16 +2048,18 if (_wrapper) {
1885 if (result) { Py_DECREF(result); }
2048 if (result) { Py_DECREF(result); }
1886 Py_DECREF(obj);
2049 Py_DECREF(obj);
1887 return;
2050 return;
2051 } else {
2052 PyErr_Clear();
1888 }
2053 }
1889 }
2054 }
1890 QHexEdit::leaveEvent(arg__1);
2055 QHexEdit::leaveEvent(arg__1);
1891 }
2056 }
1892 int PythonQtShell_QHexEdit::metric(QPaintDevice::PaintDeviceMetric arg__1) const
2057 int PythonQtShell_QHexEdit::metric(QPaintDevice::PaintDeviceMetric arg__1) const
1893 {
2058 {
1894 if (_wrapper) {
2059 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1895 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
2060 static PyObject* name = PyString_FromString("metric");
1896 PyErr_Clear();
2061 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1897 if (obj && !PythonQtSlotFunction_Check(obj)) {
2062 if (obj) {
1898 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
2063 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
1899 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2064 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1900 int returnValue;
2065 int returnValue;
@@ -1913,16 +2078,18 if (_wrapper) {
1913 if (result) { Py_DECREF(result); }
2078 if (result) { Py_DECREF(result); }
1914 Py_DECREF(obj);
2079 Py_DECREF(obj);
1915 return returnValue;
2080 return returnValue;
2081 } else {
2082 PyErr_Clear();
1916 }
2083 }
1917 }
2084 }
1918 return QHexEdit::metric(arg__1);
2085 return QHexEdit::metric(arg__1);
1919 }
2086 }
1920 void PythonQtShell_QHexEdit::mouseDoubleClickEvent(QMouseEvent* arg__1)
2087 void PythonQtShell_QHexEdit::mouseDoubleClickEvent(QMouseEvent* arg__1)
1921 {
2088 {
1922 if (_wrapper) {
2089 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1923 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
2090 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
1924 PyErr_Clear();
2091 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1925 if (obj && !PythonQtSlotFunction_Check(obj)) {
2092 if (obj) {
1926 static const char* argumentList[] ={"" , "QMouseEvent*"};
2093 static const char* argumentList[] ={"" , "QMouseEvent*"};
1927 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2094 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1928 void* args[2] = {NULL, (void*)&arg__1};
2095 void* args[2] = {NULL, (void*)&arg__1};
@@ -1930,16 +2097,18 if (_wrapper) {
1930 if (result) { Py_DECREF(result); }
2097 if (result) { Py_DECREF(result); }
1931 Py_DECREF(obj);
2098 Py_DECREF(obj);
1932 return;
2099 return;
2100 } else {
2101 PyErr_Clear();
1933 }
2102 }
1934 }
2103 }
1935 QHexEdit::mouseDoubleClickEvent(arg__1);
2104 QHexEdit::mouseDoubleClickEvent(arg__1);
1936 }
2105 }
1937 void PythonQtShell_QHexEdit::mouseMoveEvent(QMouseEvent* arg__1)
2106 void PythonQtShell_QHexEdit::mouseMoveEvent(QMouseEvent* arg__1)
1938 {
2107 {
1939 if (_wrapper) {
2108 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1940 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
2109 static PyObject* name = PyString_FromString("mouseMoveEvent");
1941 PyErr_Clear();
2110 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1942 if (obj && !PythonQtSlotFunction_Check(obj)) {
2111 if (obj) {
1943 static const char* argumentList[] ={"" , "QMouseEvent*"};
2112 static const char* argumentList[] ={"" , "QMouseEvent*"};
1944 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2113 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1945 void* args[2] = {NULL, (void*)&arg__1};
2114 void* args[2] = {NULL, (void*)&arg__1};
@@ -1947,16 +2116,18 if (_wrapper) {
1947 if (result) { Py_DECREF(result); }
2116 if (result) { Py_DECREF(result); }
1948 Py_DECREF(obj);
2117 Py_DECREF(obj);
1949 return;
2118 return;
2119 } else {
2120 PyErr_Clear();
1950 }
2121 }
1951 }
2122 }
1952 QHexEdit::mouseMoveEvent(arg__1);
2123 QHexEdit::mouseMoveEvent(arg__1);
1953 }
2124 }
1954 void PythonQtShell_QHexEdit::mousePressEvent(QMouseEvent* arg__1)
2125 void PythonQtShell_QHexEdit::mousePressEvent(QMouseEvent* arg__1)
1955 {
2126 {
1956 if (_wrapper) {
2127 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1957 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
2128 static PyObject* name = PyString_FromString("mousePressEvent");
1958 PyErr_Clear();
2129 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1959 if (obj && !PythonQtSlotFunction_Check(obj)) {
2130 if (obj) {
1960 static const char* argumentList[] ={"" , "QMouseEvent*"};
2131 static const char* argumentList[] ={"" , "QMouseEvent*"};
1961 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2132 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1962 void* args[2] = {NULL, (void*)&arg__1};
2133 void* args[2] = {NULL, (void*)&arg__1};
@@ -1964,16 +2135,18 if (_wrapper) {
1964 if (result) { Py_DECREF(result); }
2135 if (result) { Py_DECREF(result); }
1965 Py_DECREF(obj);
2136 Py_DECREF(obj);
1966 return;
2137 return;
2138 } else {
2139 PyErr_Clear();
1967 }
2140 }
1968 }
2141 }
1969 QHexEdit::mousePressEvent(arg__1);
2142 QHexEdit::mousePressEvent(arg__1);
1970 }
2143 }
1971 void PythonQtShell_QHexEdit::mouseReleaseEvent(QMouseEvent* arg__1)
2144 void PythonQtShell_QHexEdit::mouseReleaseEvent(QMouseEvent* arg__1)
1972 {
2145 {
1973 if (_wrapper) {
2146 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1974 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
2147 static PyObject* name = PyString_FromString("mouseReleaseEvent");
1975 PyErr_Clear();
2148 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1976 if (obj && !PythonQtSlotFunction_Check(obj)) {
2149 if (obj) {
1977 static const char* argumentList[] ={"" , "QMouseEvent*"};
2150 static const char* argumentList[] ={"" , "QMouseEvent*"};
1978 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2151 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1979 void* args[2] = {NULL, (void*)&arg__1};
2152 void* args[2] = {NULL, (void*)&arg__1};
@@ -1981,16 +2154,18 if (_wrapper) {
1981 if (result) { Py_DECREF(result); }
2154 if (result) { Py_DECREF(result); }
1982 Py_DECREF(obj);
2155 Py_DECREF(obj);
1983 return;
2156 return;
2157 } else {
2158 PyErr_Clear();
1984 }
2159 }
1985 }
2160 }
1986 QHexEdit::mouseReleaseEvent(arg__1);
2161 QHexEdit::mouseReleaseEvent(arg__1);
1987 }
2162 }
1988 void PythonQtShell_QHexEdit::moveEvent(QMoveEvent* arg__1)
2163 void PythonQtShell_QHexEdit::moveEvent(QMoveEvent* arg__1)
1989 {
2164 {
1990 if (_wrapper) {
2165 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1991 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
2166 static PyObject* name = PyString_FromString("moveEvent");
1992 PyErr_Clear();
2167 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1993 if (obj && !PythonQtSlotFunction_Check(obj)) {
2168 if (obj) {
1994 static const char* argumentList[] ={"" , "QMoveEvent*"};
2169 static const char* argumentList[] ={"" , "QMoveEvent*"};
1995 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2170 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1996 void* args[2] = {NULL, (void*)&arg__1};
2171 void* args[2] = {NULL, (void*)&arg__1};
@@ -1998,20 +2173,22 if (_wrapper) {
1998 if (result) { Py_DECREF(result); }
2173 if (result) { Py_DECREF(result); }
1999 Py_DECREF(obj);
2174 Py_DECREF(obj);
2000 return;
2175 return;
2176 } else {
2177 PyErr_Clear();
2001 }
2178 }
2002 }
2179 }
2003 QHexEdit::moveEvent(arg__1);
2180 QHexEdit::moveEvent(arg__1);
2004 }
2181 }
2005 bool PythonQtShell_QHexEdit::nativeEvent(const QByteArray& eventType, void* message, long* result)
2182 bool PythonQtShell_QHexEdit::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
2006 {
2183 {
2007 if (_wrapper) {
2184 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2008 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
2185 static PyObject* name = PyString_FromString("nativeEvent");
2009 PyErr_Clear();
2186 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2010 if (obj && !PythonQtSlotFunction_Check(obj)) {
2187 if (obj) {
2011 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
2188 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
2012 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
2189 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
2013 bool returnValue;
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 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2192 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2016 if (result) {
2193 if (result) {
2017 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2194 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -2026,16 +2203,18 if (_wrapper) {
2026 if (result) { Py_DECREF(result); }
2203 if (result) { Py_DECREF(result); }
2027 Py_DECREF(obj);
2204 Py_DECREF(obj);
2028 return returnValue;
2205 return returnValue;
2029 }
2206 } else {
2030 }
2207 PyErr_Clear();
2031 return QHexEdit::nativeEvent(eventType, message, result);
2208 }
2209 }
2210 return QHexEdit::nativeEvent(eventType0, message1, result2);
2032 }
2211 }
2033 QPaintEngine* PythonQtShell_QHexEdit::paintEngine() const
2212 QPaintEngine* PythonQtShell_QHexEdit::paintEngine() const
2034 {
2213 {
2035 if (_wrapper) {
2214 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2036 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
2215 static PyObject* name = PyString_FromString("paintEngine");
2037 PyErr_Clear();
2216 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2038 if (obj && !PythonQtSlotFunction_Check(obj)) {
2217 if (obj) {
2039 static const char* argumentList[] ={"QPaintEngine*"};
2218 static const char* argumentList[] ={"QPaintEngine*"};
2040 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2219 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2041 QPaintEngine* returnValue;
2220 QPaintEngine* returnValue;
@@ -2054,16 +2233,18 if (_wrapper) {
2054 if (result) { Py_DECREF(result); }
2233 if (result) { Py_DECREF(result); }
2055 Py_DECREF(obj);
2234 Py_DECREF(obj);
2056 return returnValue;
2235 return returnValue;
2236 } else {
2237 PyErr_Clear();
2057 }
2238 }
2058 }
2239 }
2059 return QHexEdit::paintEngine();
2240 return QHexEdit::paintEngine();
2060 }
2241 }
2061 void PythonQtShell_QHexEdit::paintEvent(QPaintEvent* arg__1)
2242 void PythonQtShell_QHexEdit::paintEvent(QPaintEvent* arg__1)
2062 {
2243 {
2063 if (_wrapper) {
2244 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2064 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
2245 static PyObject* name = PyString_FromString("paintEvent");
2065 PyErr_Clear();
2246 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2066 if (obj && !PythonQtSlotFunction_Check(obj)) {
2247 if (obj) {
2067 static const char* argumentList[] ={"" , "QPaintEvent*"};
2248 static const char* argumentList[] ={"" , "QPaintEvent*"};
2068 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2249 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2069 void* args[2] = {NULL, (void*)&arg__1};
2250 void* args[2] = {NULL, (void*)&arg__1};
@@ -2071,20 +2252,22 if (_wrapper) {
2071 if (result) { Py_DECREF(result); }
2252 if (result) { Py_DECREF(result); }
2072 Py_DECREF(obj);
2253 Py_DECREF(obj);
2073 return;
2254 return;
2255 } else {
2256 PyErr_Clear();
2074 }
2257 }
2075 }
2258 }
2076 QHexEdit::paintEvent(arg__1);
2259 QHexEdit::paintEvent(arg__1);
2077 }
2260 }
2078 QPaintDevice* PythonQtShell_QHexEdit::redirected(QPoint* offset) const
2261 QPaintDevice* PythonQtShell_QHexEdit::redirected(QPoint* offset0) const
2079 {
2262 {
2080 if (_wrapper) {
2263 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2081 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
2264 static PyObject* name = PyString_FromString("redirected");
2082 PyErr_Clear();
2265 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2083 if (obj && !PythonQtSlotFunction_Check(obj)) {
2266 if (obj) {
2084 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
2267 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
2085 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2268 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2086 QPaintDevice* returnValue;
2269 QPaintDevice* returnValue;
2087 void* args[2] = {NULL, (void*)&offset};
2270 void* args[2] = {NULL, (void*)&offset0};
2088 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2271 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2089 if (result) {
2272 if (result) {
2090 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2273 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -2099,16 +2282,18 if (_wrapper) {
2099 if (result) { Py_DECREF(result); }
2282 if (result) { Py_DECREF(result); }
2100 Py_DECREF(obj);
2283 Py_DECREF(obj);
2101 return returnValue;
2284 return returnValue;
2102 }
2285 } else {
2103 }
2286 PyErr_Clear();
2104 return QHexEdit::redirected(offset);
2287 }
2288 }
2289 return QHexEdit::redirected(offset0);
2105 }
2290 }
2106 void PythonQtShell_QHexEdit::resizeEvent(QResizeEvent* arg__1)
2291 void PythonQtShell_QHexEdit::resizeEvent(QResizeEvent* arg__1)
2107 {
2292 {
2108 if (_wrapper) {
2293 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2109 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
2294 static PyObject* name = PyString_FromString("resizeEvent");
2110 PyErr_Clear();
2295 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2111 if (obj && !PythonQtSlotFunction_Check(obj)) {
2296 if (obj) {
2112 static const char* argumentList[] ={"" , "QResizeEvent*"};
2297 static const char* argumentList[] ={"" , "QResizeEvent*"};
2113 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2298 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2114 void* args[2] = {NULL, (void*)&arg__1};
2299 void* args[2] = {NULL, (void*)&arg__1};
@@ -2116,50 +2301,56 if (_wrapper) {
2116 if (result) { Py_DECREF(result); }
2301 if (result) { Py_DECREF(result); }
2117 Py_DECREF(obj);
2302 Py_DECREF(obj);
2118 return;
2303 return;
2304 } else {
2305 PyErr_Clear();
2119 }
2306 }
2120 }
2307 }
2121 QHexEdit::resizeEvent(arg__1);
2308 QHexEdit::resizeEvent(arg__1);
2122 }
2309 }
2123 void PythonQtShell_QHexEdit::scrollContentsBy(int dx, int dy)
2310 void PythonQtShell_QHexEdit::scrollContentsBy(int dx0, int dy1)
2124 {
2311 {
2125 if (_wrapper) {
2312 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2126 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "scrollContentsBy");
2313 static PyObject* name = PyString_FromString("scrollContentsBy");
2127 PyErr_Clear();
2314 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2128 if (obj && !PythonQtSlotFunction_Check(obj)) {
2315 if (obj) {
2129 static const char* argumentList[] ={"" , "int" , "int"};
2316 static const char* argumentList[] ={"" , "int" , "int"};
2130 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2317 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2131 void* args[3] = {NULL, (void*)&dx, (void*)&dy};
2318 void* args[3] = {NULL, (void*)&dx0, (void*)&dy1};
2132 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2319 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2133 if (result) { Py_DECREF(result); }
2320 if (result) { Py_DECREF(result); }
2134 Py_DECREF(obj);
2321 Py_DECREF(obj);
2135 return;
2322 return;
2136 }
2323 } else {
2137 }
2324 PyErr_Clear();
2138 QHexEdit::scrollContentsBy(dx, dy);
2325 }
2139 }
2326 }
2140 void PythonQtShell_QHexEdit::setupViewport(QWidget* viewport)
2327 QHexEdit::scrollContentsBy(dx0, dy1);
2141 {
2328 }
2142 if (_wrapper) {
2329 void PythonQtShell_QHexEdit::setupViewport(QWidget* viewport0)
2143 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setupViewport");
2330 {
2144 PyErr_Clear();
2331 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2145 if (obj && !PythonQtSlotFunction_Check(obj)) {
2332 static PyObject* name = PyString_FromString("setupViewport");
2333 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2334 if (obj) {
2146 static const char* argumentList[] ={"" , "QWidget*"};
2335 static const char* argumentList[] ={"" , "QWidget*"};
2147 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2336 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2148 void* args[2] = {NULL, (void*)&viewport};
2337 void* args[2] = {NULL, (void*)&viewport0};
2149 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2338 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2150 if (result) { Py_DECREF(result); }
2339 if (result) { Py_DECREF(result); }
2151 Py_DECREF(obj);
2340 Py_DECREF(obj);
2152 return;
2341 return;
2153 }
2342 } else {
2154 }
2343 PyErr_Clear();
2155 QHexEdit::setupViewport(viewport);
2344 }
2345 }
2346 QHexEdit::setupViewport(viewport0);
2156 }
2347 }
2157 QPainter* PythonQtShell_QHexEdit::sharedPainter() const
2348 QPainter* PythonQtShell_QHexEdit::sharedPainter() const
2158 {
2349 {
2159 if (_wrapper) {
2350 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2160 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
2351 static PyObject* name = PyString_FromString("sharedPainter");
2161 PyErr_Clear();
2352 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2162 if (obj && !PythonQtSlotFunction_Check(obj)) {
2353 if (obj) {
2163 static const char* argumentList[] ={"QPainter*"};
2354 static const char* argumentList[] ={"QPainter*"};
2164 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2355 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2165 QPainter* returnValue;
2356 QPainter* returnValue;
@@ -2178,16 +2369,18 if (_wrapper) {
2178 if (result) { Py_DECREF(result); }
2369 if (result) { Py_DECREF(result); }
2179 Py_DECREF(obj);
2370 Py_DECREF(obj);
2180 return returnValue;
2371 return returnValue;
2372 } else {
2373 PyErr_Clear();
2181 }
2374 }
2182 }
2375 }
2183 return QHexEdit::sharedPainter();
2376 return QHexEdit::sharedPainter();
2184 }
2377 }
2185 void PythonQtShell_QHexEdit::showEvent(QShowEvent* arg__1)
2378 void PythonQtShell_QHexEdit::showEvent(QShowEvent* arg__1)
2186 {
2379 {
2187 if (_wrapper) {
2380 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2188 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
2381 static PyObject* name = PyString_FromString("showEvent");
2189 PyErr_Clear();
2382 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2190 if (obj && !PythonQtSlotFunction_Check(obj)) {
2383 if (obj) {
2191 static const char* argumentList[] ={"" , "QShowEvent*"};
2384 static const char* argumentList[] ={"" , "QShowEvent*"};
2192 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2385 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2193 void* args[2] = {NULL, (void*)&arg__1};
2386 void* args[2] = {NULL, (void*)&arg__1};
@@ -2195,16 +2388,18 if (_wrapper) {
2195 if (result) { Py_DECREF(result); }
2388 if (result) { Py_DECREF(result); }
2196 Py_DECREF(obj);
2389 Py_DECREF(obj);
2197 return;
2390 return;
2391 } else {
2392 PyErr_Clear();
2198 }
2393 }
2199 }
2394 }
2200 QHexEdit::showEvent(arg__1);
2395 QHexEdit::showEvent(arg__1);
2201 }
2396 }
2202 void PythonQtShell_QHexEdit::tabletEvent(QTabletEvent* arg__1)
2397 void PythonQtShell_QHexEdit::tabletEvent(QTabletEvent* arg__1)
2203 {
2398 {
2204 if (_wrapper) {
2399 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2205 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
2400 static PyObject* name = PyString_FromString("tabletEvent");
2206 PyErr_Clear();
2401 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2207 if (obj && !PythonQtSlotFunction_Check(obj)) {
2402 if (obj) {
2208 static const char* argumentList[] ={"" , "QTabletEvent*"};
2403 static const char* argumentList[] ={"" , "QTabletEvent*"};
2209 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2404 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2210 void* args[2] = {NULL, (void*)&arg__1};
2405 void* args[2] = {NULL, (void*)&arg__1};
@@ -2212,16 +2407,18 if (_wrapper) {
2212 if (result) { Py_DECREF(result); }
2407 if (result) { Py_DECREF(result); }
2213 Py_DECREF(obj);
2408 Py_DECREF(obj);
2214 return;
2409 return;
2410 } else {
2411 PyErr_Clear();
2215 }
2412 }
2216 }
2413 }
2217 QHexEdit::tabletEvent(arg__1);
2414 QHexEdit::tabletEvent(arg__1);
2218 }
2415 }
2219 void PythonQtShell_QHexEdit::timerEvent(QTimerEvent* arg__1)
2416 void PythonQtShell_QHexEdit::timerEvent(QTimerEvent* arg__1)
2220 {
2417 {
2221 if (_wrapper) {
2418 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2222 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
2419 static PyObject* name = PyString_FromString("timerEvent");
2223 PyErr_Clear();
2420 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2224 if (obj && !PythonQtSlotFunction_Check(obj)) {
2421 if (obj) {
2225 static const char* argumentList[] ={"" , "QTimerEvent*"};
2422 static const char* argumentList[] ={"" , "QTimerEvent*"};
2226 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2423 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2227 void* args[2] = {NULL, (void*)&arg__1};
2424 void* args[2] = {NULL, (void*)&arg__1};
@@ -2229,16 +2426,18 if (_wrapper) {
2229 if (result) { Py_DECREF(result); }
2426 if (result) { Py_DECREF(result); }
2230 Py_DECREF(obj);
2427 Py_DECREF(obj);
2231 return;
2428 return;
2429 } else {
2430 PyErr_Clear();
2232 }
2431 }
2233 }
2432 }
2234 QHexEdit::timerEvent(arg__1);
2433 QHexEdit::timerEvent(arg__1);
2235 }
2434 }
2236 bool PythonQtShell_QHexEdit::viewportEvent(QEvent* arg__1)
2435 bool PythonQtShell_QHexEdit::viewportEvent(QEvent* arg__1)
2237 {
2436 {
2238 if (_wrapper) {
2437 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2239 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportEvent");
2438 static PyObject* name = PyString_FromString("viewportEvent");
2240 PyErr_Clear();
2439 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2241 if (obj && !PythonQtSlotFunction_Check(obj)) {
2440 if (obj) {
2242 static const char* argumentList[] ={"bool" , "QEvent*"};
2441 static const char* argumentList[] ={"bool" , "QEvent*"};
2243 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2442 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2244 bool returnValue;
2443 bool returnValue;
@@ -2257,16 +2456,18 if (_wrapper) {
2257 if (result) { Py_DECREF(result); }
2456 if (result) { Py_DECREF(result); }
2258 Py_DECREF(obj);
2457 Py_DECREF(obj);
2259 return returnValue;
2458 return returnValue;
2459 } else {
2460 PyErr_Clear();
2260 }
2461 }
2261 }
2462 }
2262 return QHexEdit::viewportEvent(arg__1);
2463 return QHexEdit::viewportEvent(arg__1);
2263 }
2464 }
2264 QSize PythonQtShell_QHexEdit::viewportSizeHint() const
2465 QSize PythonQtShell_QHexEdit::viewportSizeHint() const
2265 {
2466 {
2266 if (_wrapper) {
2467 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2267 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportSizeHint");
2468 static PyObject* name = PyString_FromString("viewportSizeHint");
2268 PyErr_Clear();
2469 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2269 if (obj && !PythonQtSlotFunction_Check(obj)) {
2470 if (obj) {
2270 static const char* argumentList[] ={"QSize"};
2471 static const char* argumentList[] ={"QSize"};
2271 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2472 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2272 QSize returnValue;
2473 QSize returnValue;
@@ -2285,16 +2486,18 if (_wrapper) {
2285 if (result) { Py_DECREF(result); }
2486 if (result) { Py_DECREF(result); }
2286 Py_DECREF(obj);
2487 Py_DECREF(obj);
2287 return returnValue;
2488 return returnValue;
2489 } else {
2490 PyErr_Clear();
2288 }
2491 }
2289 }
2492 }
2290 return QHexEdit::viewportSizeHint();
2493 return QHexEdit::viewportSizeHint();
2291 }
2494 }
2292 void PythonQtShell_QHexEdit::wheelEvent(QWheelEvent* arg__1)
2495 void PythonQtShell_QHexEdit::wheelEvent(QWheelEvent* arg__1)
2293 {
2496 {
2294 if (_wrapper) {
2497 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2295 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
2498 static PyObject* name = PyString_FromString("wheelEvent");
2296 PyErr_Clear();
2499 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2297 if (obj && !PythonQtSlotFunction_Check(obj)) {
2500 if (obj) {
2298 static const char* argumentList[] ={"" , "QWheelEvent*"};
2501 static const char* argumentList[] ={"" , "QWheelEvent*"};
2299 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2502 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2300 void* args[2] = {NULL, (void*)&arg__1};
2503 void* args[2] = {NULL, (void*)&arg__1};
@@ -2302,6 +2505,8 if (_wrapper) {
2302 if (result) { Py_DECREF(result); }
2505 if (result) { Py_DECREF(result); }
2303 Py_DECREF(obj);
2506 Py_DECREF(obj);
2304 return;
2507 return;
2508 } else {
2509 PyErr_Clear();
2305 }
2510 }
2306 }
2511 }
2307 QHexEdit::wheelEvent(arg__1);
2512 QHexEdit::wheelEvent(arg__1);
@@ -2473,10 +2678,10 PythonQtShell_QHexSpinBox::~PythonQtShel
2473 }
2678 }
2474 void PythonQtShell_QHexSpinBox::actionEvent(QActionEvent* arg__1)
2679 void PythonQtShell_QHexSpinBox::actionEvent(QActionEvent* arg__1)
2475 {
2680 {
2476 if (_wrapper) {
2681 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2477 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
2682 static PyObject* name = PyString_FromString("actionEvent");
2478 PyErr_Clear();
2683 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2479 if (obj && !PythonQtSlotFunction_Check(obj)) {
2684 if (obj) {
2480 static const char* argumentList[] ={"" , "QActionEvent*"};
2685 static const char* argumentList[] ={"" , "QActionEvent*"};
2481 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2686 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2482 void* args[2] = {NULL, (void*)&arg__1};
2687 void* args[2] = {NULL, (void*)&arg__1};
@@ -2484,33 +2689,37 if (_wrapper) {
2484 if (result) { Py_DECREF(result); }
2689 if (result) { Py_DECREF(result); }
2485 Py_DECREF(obj);
2690 Py_DECREF(obj);
2486 return;
2691 return;
2692 } else {
2693 PyErr_Clear();
2487 }
2694 }
2488 }
2695 }
2489 QHexSpinBox::actionEvent(arg__1);
2696 QHexSpinBox::actionEvent(arg__1);
2490 }
2697 }
2491 void PythonQtShell_QHexSpinBox::changeEvent(QEvent* event)
2698 void PythonQtShell_QHexSpinBox::changeEvent(QEvent* event0)
2492 {
2699 {
2493 if (_wrapper) {
2700 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2494 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
2701 static PyObject* name = PyString_FromString("changeEvent");
2495 PyErr_Clear();
2702 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2496 if (obj && !PythonQtSlotFunction_Check(obj)) {
2703 if (obj) {
2497 static const char* argumentList[] ={"" , "QEvent*"};
2704 static const char* argumentList[] ={"" , "QEvent*"};
2498 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2705 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2499 void* args[2] = {NULL, (void*)&event};
2706 void* args[2] = {NULL, (void*)&event0};
2500 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2707 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2501 if (result) { Py_DECREF(result); }
2708 if (result) { Py_DECREF(result); }
2502 Py_DECREF(obj);
2709 Py_DECREF(obj);
2503 return;
2710 return;
2504 }
2711 } else {
2505 }
2712 PyErr_Clear();
2506 QHexSpinBox::changeEvent(event);
2713 }
2714 }
2715 QHexSpinBox::changeEvent(event0);
2507 }
2716 }
2508 void PythonQtShell_QHexSpinBox::childEvent(QChildEvent* arg__1)
2717 void PythonQtShell_QHexSpinBox::childEvent(QChildEvent* arg__1)
2509 {
2718 {
2510 if (_wrapper) {
2719 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2511 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
2720 static PyObject* name = PyString_FromString("childEvent");
2512 PyErr_Clear();
2721 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2513 if (obj && !PythonQtSlotFunction_Check(obj)) {
2722 if (obj) {
2514 static const char* argumentList[] ={"" , "QChildEvent*"};
2723 static const char* argumentList[] ={"" , "QChildEvent*"};
2515 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2724 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2516 void* args[2] = {NULL, (void*)&arg__1};
2725 void* args[2] = {NULL, (void*)&arg__1};
@@ -2518,16 +2727,18 if (_wrapper) {
2518 if (result) { Py_DECREF(result); }
2727 if (result) { Py_DECREF(result); }
2519 Py_DECREF(obj);
2728 Py_DECREF(obj);
2520 return;
2729 return;
2730 } else {
2731 PyErr_Clear();
2521 }
2732 }
2522 }
2733 }
2523 QHexSpinBox::childEvent(arg__1);
2734 QHexSpinBox::childEvent(arg__1);
2524 }
2735 }
2525 void PythonQtShell_QHexSpinBox::clear()
2736 void PythonQtShell_QHexSpinBox::clear()
2526 {
2737 {
2527 if (_wrapper) {
2738 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2528 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "clear");
2739 static PyObject* name = PyString_FromString("clear");
2529 PyErr_Clear();
2740 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2530 if (obj && !PythonQtSlotFunction_Check(obj)) {
2741 if (obj) {
2531 static const char* argumentList[] ={""};
2742 static const char* argumentList[] ={""};
2532 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2743 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2533 void* args[1] = {NULL};
2744 void* args[1] = {NULL};
@@ -2535,50 +2746,56 if (_wrapper) {
2535 if (result) { Py_DECREF(result); }
2746 if (result) { Py_DECREF(result); }
2536 Py_DECREF(obj);
2747 Py_DECREF(obj);
2537 return;
2748 return;
2749 } else {
2750 PyErr_Clear();
2538 }
2751 }
2539 }
2752 }
2540 QHexSpinBox::clear();
2753 QHexSpinBox::clear();
2541 }
2754 }
2542 void PythonQtShell_QHexSpinBox::closeEvent(QCloseEvent* event)
2755 void PythonQtShell_QHexSpinBox::closeEvent(QCloseEvent* event0)
2543 {
2756 {
2544 if (_wrapper) {
2757 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2545 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
2758 static PyObject* name = PyString_FromString("closeEvent");
2546 PyErr_Clear();
2759 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2547 if (obj && !PythonQtSlotFunction_Check(obj)) {
2760 if (obj) {
2548 static const char* argumentList[] ={"" , "QCloseEvent*"};
2761 static const char* argumentList[] ={"" , "QCloseEvent*"};
2549 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2762 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2550 void* args[2] = {NULL, (void*)&event};
2763 void* args[2] = {NULL, (void*)&event0};
2551 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2764 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2552 if (result) { Py_DECREF(result); }
2765 if (result) { Py_DECREF(result); }
2553 Py_DECREF(obj);
2766 Py_DECREF(obj);
2554 return;
2767 return;
2555 }
2768 } else {
2556 }
2769 PyErr_Clear();
2557 QHexSpinBox::closeEvent(event);
2770 }
2558 }
2771 }
2559 void PythonQtShell_QHexSpinBox::contextMenuEvent(QContextMenuEvent* event)
2772 QHexSpinBox::closeEvent(event0);
2560 {
2773 }
2561 if (_wrapper) {
2774 void PythonQtShell_QHexSpinBox::contextMenuEvent(QContextMenuEvent* event0)
2562 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
2775 {
2563 PyErr_Clear();
2776 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2564 if (obj && !PythonQtSlotFunction_Check(obj)) {
2777 static PyObject* name = PyString_FromString("contextMenuEvent");
2778 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2779 if (obj) {
2565 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
2780 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
2566 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2781 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2567 void* args[2] = {NULL, (void*)&event};
2782 void* args[2] = {NULL, (void*)&event0};
2568 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2783 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2569 if (result) { Py_DECREF(result); }
2784 if (result) { Py_DECREF(result); }
2570 Py_DECREF(obj);
2785 Py_DECREF(obj);
2571 return;
2786 return;
2572 }
2787 } else {
2573 }
2788 PyErr_Clear();
2574 QHexSpinBox::contextMenuEvent(event);
2789 }
2790 }
2791 QHexSpinBox::contextMenuEvent(event0);
2575 }
2792 }
2576 void PythonQtShell_QHexSpinBox::customEvent(QEvent* arg__1)
2793 void PythonQtShell_QHexSpinBox::customEvent(QEvent* arg__1)
2577 {
2794 {
2578 if (_wrapper) {
2795 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2579 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
2796 static PyObject* name = PyString_FromString("customEvent");
2580 PyErr_Clear();
2797 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2581 if (obj && !PythonQtSlotFunction_Check(obj)) {
2798 if (obj) {
2582 static const char* argumentList[] ={"" , "QEvent*"};
2799 static const char* argumentList[] ={"" , "QEvent*"};
2583 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2800 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2584 void* args[2] = {NULL, (void*)&arg__1};
2801 void* args[2] = {NULL, (void*)&arg__1};
@@ -2586,16 +2803,18 if (_wrapper) {
2586 if (result) { Py_DECREF(result); }
2803 if (result) { Py_DECREF(result); }
2587 Py_DECREF(obj);
2804 Py_DECREF(obj);
2588 return;
2805 return;
2806 } else {
2807 PyErr_Clear();
2589 }
2808 }
2590 }
2809 }
2591 QHexSpinBox::customEvent(arg__1);
2810 QHexSpinBox::customEvent(arg__1);
2592 }
2811 }
2593 int PythonQtShell_QHexSpinBox::devType() const
2812 int PythonQtShell_QHexSpinBox::devType() const
2594 {
2813 {
2595 if (_wrapper) {
2814 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2596 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
2815 static PyObject* name = PyString_FromString("devType");
2597 PyErr_Clear();
2816 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2598 if (obj && !PythonQtSlotFunction_Check(obj)) {
2817 if (obj) {
2599 static const char* argumentList[] ={"int"};
2818 static const char* argumentList[] ={"int"};
2600 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2819 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2601 int returnValue;
2820 int returnValue;
@@ -2614,16 +2833,18 if (_wrapper) {
2614 if (result) { Py_DECREF(result); }
2833 if (result) { Py_DECREF(result); }
2615 Py_DECREF(obj);
2834 Py_DECREF(obj);
2616 return returnValue;
2835 return returnValue;
2836 } else {
2837 PyErr_Clear();
2617 }
2838 }
2618 }
2839 }
2619 return QHexSpinBox::devType();
2840 return QHexSpinBox::devType();
2620 }
2841 }
2621 void PythonQtShell_QHexSpinBox::dragEnterEvent(QDragEnterEvent* arg__1)
2842 void PythonQtShell_QHexSpinBox::dragEnterEvent(QDragEnterEvent* arg__1)
2622 {
2843 {
2623 if (_wrapper) {
2844 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2624 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
2845 static PyObject* name = PyString_FromString("dragEnterEvent");
2625 PyErr_Clear();
2846 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2626 if (obj && !PythonQtSlotFunction_Check(obj)) {
2847 if (obj) {
2627 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
2848 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
2628 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2849 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2629 void* args[2] = {NULL, (void*)&arg__1};
2850 void* args[2] = {NULL, (void*)&arg__1};
@@ -2631,16 +2852,18 if (_wrapper) {
2631 if (result) { Py_DECREF(result); }
2852 if (result) { Py_DECREF(result); }
2632 Py_DECREF(obj);
2853 Py_DECREF(obj);
2633 return;
2854 return;
2855 } else {
2856 PyErr_Clear();
2634 }
2857 }
2635 }
2858 }
2636 QHexSpinBox::dragEnterEvent(arg__1);
2859 QHexSpinBox::dragEnterEvent(arg__1);
2637 }
2860 }
2638 void PythonQtShell_QHexSpinBox::dragLeaveEvent(QDragLeaveEvent* arg__1)
2861 void PythonQtShell_QHexSpinBox::dragLeaveEvent(QDragLeaveEvent* arg__1)
2639 {
2862 {
2640 if (_wrapper) {
2863 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2641 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
2864 static PyObject* name = PyString_FromString("dragLeaveEvent");
2642 PyErr_Clear();
2865 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2643 if (obj && !PythonQtSlotFunction_Check(obj)) {
2866 if (obj) {
2644 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
2867 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
2645 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2868 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2646 void* args[2] = {NULL, (void*)&arg__1};
2869 void* args[2] = {NULL, (void*)&arg__1};
@@ -2648,16 +2871,18 if (_wrapper) {
2648 if (result) { Py_DECREF(result); }
2871 if (result) { Py_DECREF(result); }
2649 Py_DECREF(obj);
2872 Py_DECREF(obj);
2650 return;
2873 return;
2874 } else {
2875 PyErr_Clear();
2651 }
2876 }
2652 }
2877 }
2653 QHexSpinBox::dragLeaveEvent(arg__1);
2878 QHexSpinBox::dragLeaveEvent(arg__1);
2654 }
2879 }
2655 void PythonQtShell_QHexSpinBox::dragMoveEvent(QDragMoveEvent* arg__1)
2880 void PythonQtShell_QHexSpinBox::dragMoveEvent(QDragMoveEvent* arg__1)
2656 {
2881 {
2657 if (_wrapper) {
2882 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2658 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
2883 static PyObject* name = PyString_FromString("dragMoveEvent");
2659 PyErr_Clear();
2884 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2660 if (obj && !PythonQtSlotFunction_Check(obj)) {
2885 if (obj) {
2661 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
2886 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
2662 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2887 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2663 void* args[2] = {NULL, (void*)&arg__1};
2888 void* args[2] = {NULL, (void*)&arg__1};
@@ -2665,16 +2890,18 if (_wrapper) {
2665 if (result) { Py_DECREF(result); }
2890 if (result) { Py_DECREF(result); }
2666 Py_DECREF(obj);
2891 Py_DECREF(obj);
2667 return;
2892 return;
2893 } else {
2894 PyErr_Clear();
2668 }
2895 }
2669 }
2896 }
2670 QHexSpinBox::dragMoveEvent(arg__1);
2897 QHexSpinBox::dragMoveEvent(arg__1);
2671 }
2898 }
2672 void PythonQtShell_QHexSpinBox::dropEvent(QDropEvent* arg__1)
2899 void PythonQtShell_QHexSpinBox::dropEvent(QDropEvent* arg__1)
2673 {
2900 {
2674 if (_wrapper) {
2901 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2675 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
2902 static PyObject* name = PyString_FromString("dropEvent");
2676 PyErr_Clear();
2903 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2677 if (obj && !PythonQtSlotFunction_Check(obj)) {
2904 if (obj) {
2678 static const char* argumentList[] ={"" , "QDropEvent*"};
2905 static const char* argumentList[] ={"" , "QDropEvent*"};
2679 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2906 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2680 void* args[2] = {NULL, (void*)&arg__1};
2907 void* args[2] = {NULL, (void*)&arg__1};
@@ -2682,16 +2909,18 if (_wrapper) {
2682 if (result) { Py_DECREF(result); }
2909 if (result) { Py_DECREF(result); }
2683 Py_DECREF(obj);
2910 Py_DECREF(obj);
2684 return;
2911 return;
2912 } else {
2913 PyErr_Clear();
2685 }
2914 }
2686 }
2915 }
2687 QHexSpinBox::dropEvent(arg__1);
2916 QHexSpinBox::dropEvent(arg__1);
2688 }
2917 }
2689 void PythonQtShell_QHexSpinBox::enterEvent(QEvent* arg__1)
2918 void PythonQtShell_QHexSpinBox::enterEvent(QEvent* arg__1)
2690 {
2919 {
2691 if (_wrapper) {
2920 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2692 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
2921 static PyObject* name = PyString_FromString("enterEvent");
2693 PyErr_Clear();
2922 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2694 if (obj && !PythonQtSlotFunction_Check(obj)) {
2923 if (obj) {
2695 static const char* argumentList[] ={"" , "QEvent*"};
2924 static const char* argumentList[] ={"" , "QEvent*"};
2696 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2925 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2697 void* args[2] = {NULL, (void*)&arg__1};
2926 void* args[2] = {NULL, (void*)&arg__1};
@@ -2699,20 +2928,22 if (_wrapper) {
2699 if (result) { Py_DECREF(result); }
2928 if (result) { Py_DECREF(result); }
2700 Py_DECREF(obj);
2929 Py_DECREF(obj);
2701 return;
2930 return;
2931 } else {
2932 PyErr_Clear();
2702 }
2933 }
2703 }
2934 }
2704 QHexSpinBox::enterEvent(arg__1);
2935 QHexSpinBox::enterEvent(arg__1);
2705 }
2936 }
2706 bool PythonQtShell_QHexSpinBox::event(QEvent* event)
2937 bool PythonQtShell_QHexSpinBox::event(QEvent* event0)
2707 {
2938 {
2708 if (_wrapper) {
2939 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2709 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
2940 static PyObject* name = PyString_FromString("event");
2710 PyErr_Clear();
2941 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2711 if (obj && !PythonQtSlotFunction_Check(obj)) {
2942 if (obj) {
2712 static const char* argumentList[] ={"bool" , "QEvent*"};
2943 static const char* argumentList[] ={"bool" , "QEvent*"};
2713 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2944 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2714 bool returnValue;
2945 bool returnValue;
2715 void* args[2] = {NULL, (void*)&event};
2946 void* args[2] = {NULL, (void*)&event0};
2716 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2947 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2717 if (result) {
2948 if (result) {
2718 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2949 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -2727,16 +2958,18 if (_wrapper) {
2727 if (result) { Py_DECREF(result); }
2958 if (result) { Py_DECREF(result); }
2728 Py_DECREF(obj);
2959 Py_DECREF(obj);
2729 return returnValue;
2960 return returnValue;
2730 }
2961 } else {
2731 }
2962 PyErr_Clear();
2732 return QHexSpinBox::event(event);
2963 }
2964 }
2965 return QHexSpinBox::event(event0);
2733 }
2966 }
2734 bool PythonQtShell_QHexSpinBox::eventFilter(QObject* arg__1, QEvent* arg__2)
2967 bool PythonQtShell_QHexSpinBox::eventFilter(QObject* arg__1, QEvent* arg__2)
2735 {
2968 {
2736 if (_wrapper) {
2969 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2737 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
2970 static PyObject* name = PyString_FromString("eventFilter");
2738 PyErr_Clear();
2971 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2739 if (obj && !PythonQtSlotFunction_Check(obj)) {
2972 if (obj) {
2740 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
2973 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
2741 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2974 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2742 bool returnValue;
2975 bool returnValue;
@@ -2755,54 +2988,60 if (_wrapper) {
2755 if (result) { Py_DECREF(result); }
2988 if (result) { Py_DECREF(result); }
2756 Py_DECREF(obj);
2989 Py_DECREF(obj);
2757 return returnValue;
2990 return returnValue;
2991 } else {
2992 PyErr_Clear();
2758 }
2993 }
2759 }
2994 }
2760 return QHexSpinBox::eventFilter(arg__1, arg__2);
2995 return QHexSpinBox::eventFilter(arg__1, arg__2);
2761 }
2996 }
2762 void PythonQtShell_QHexSpinBox::fixup(QString& str) const
2997 void PythonQtShell_QHexSpinBox::fixup(QString& str0) const
2763 {
2998 {
2764 if (_wrapper) {
2999 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2765 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "fixup");
3000 static PyObject* name = PyString_FromString("fixup");
2766 PyErr_Clear();
3001 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2767 if (obj && !PythonQtSlotFunction_Check(obj)) {
3002 if (obj) {
2768 static const char* argumentList[] ={"" , "QString&"};
3003 static const char* argumentList[] ={"" , "QString&"};
2769 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3004 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2770 void* args[2] = {NULL, (void*)&str};
3005 void* args[2] = {NULL, (void*)&str0};
2771 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3006 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2772 if (result) { Py_DECREF(result); }
3007 if (result) { Py_DECREF(result); }
2773 Py_DECREF(obj);
3008 Py_DECREF(obj);
2774 return;
3009 return;
2775 }
3010 } else {
2776 }
3011 PyErr_Clear();
2777 QHexSpinBox::fixup(str);
3012 }
2778 }
3013 }
2779 void PythonQtShell_QHexSpinBox::focusInEvent(QFocusEvent* event)
3014 QHexSpinBox::fixup(str0);
2780 {
3015 }
2781 if (_wrapper) {
3016 void PythonQtShell_QHexSpinBox::focusInEvent(QFocusEvent* event0)
2782 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
3017 {
2783 PyErr_Clear();
3018 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2784 if (obj && !PythonQtSlotFunction_Check(obj)) {
3019 static PyObject* name = PyString_FromString("focusInEvent");
3020 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3021 if (obj) {
2785 static const char* argumentList[] ={"" , "QFocusEvent*"};
3022 static const char* argumentList[] ={"" , "QFocusEvent*"};
2786 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3023 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2787 void* args[2] = {NULL, (void*)&event};
3024 void* args[2] = {NULL, (void*)&event0};
2788 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3025 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2789 if (result) { Py_DECREF(result); }
3026 if (result) { Py_DECREF(result); }
2790 Py_DECREF(obj);
3027 Py_DECREF(obj);
2791 return;
3028 return;
2792 }
3029 } else {
2793 }
3030 PyErr_Clear();
2794 QHexSpinBox::focusInEvent(event);
3031 }
2795 }
3032 }
2796 bool PythonQtShell_QHexSpinBox::focusNextPrevChild(bool next)
3033 QHexSpinBox::focusInEvent(event0);
2797 {
3034 }
2798 if (_wrapper) {
3035 bool PythonQtShell_QHexSpinBox::focusNextPrevChild(bool next0)
2799 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
3036 {
2800 PyErr_Clear();
3037 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2801 if (obj && !PythonQtSlotFunction_Check(obj)) {
3038 static PyObject* name = PyString_FromString("focusNextPrevChild");
3039 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3040 if (obj) {
2802 static const char* argumentList[] ={"bool" , "bool"};
3041 static const char* argumentList[] ={"bool" , "bool"};
2803 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3042 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2804 bool returnValue;
3043 bool returnValue;
2805 void* args[2] = {NULL, (void*)&next};
3044 void* args[2] = {NULL, (void*)&next0};
2806 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3045 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2807 if (result) {
3046 if (result) {
2808 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3047 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -2817,33 +3056,37 if (_wrapper) {
2817 if (result) { Py_DECREF(result); }
3056 if (result) { Py_DECREF(result); }
2818 Py_DECREF(obj);
3057 Py_DECREF(obj);
2819 return returnValue;
3058 return returnValue;
2820 }
3059 } else {
2821 }
3060 PyErr_Clear();
2822 return QHexSpinBox::focusNextPrevChild(next);
3061 }
2823 }
3062 }
2824 void PythonQtShell_QHexSpinBox::focusOutEvent(QFocusEvent* event)
3063 return QHexSpinBox::focusNextPrevChild(next0);
2825 {
3064 }
2826 if (_wrapper) {
3065 void PythonQtShell_QHexSpinBox::focusOutEvent(QFocusEvent* event0)
2827 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
3066 {
2828 PyErr_Clear();
3067 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2829 if (obj && !PythonQtSlotFunction_Check(obj)) {
3068 static PyObject* name = PyString_FromString("focusOutEvent");
3069 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3070 if (obj) {
2830 static const char* argumentList[] ={"" , "QFocusEvent*"};
3071 static const char* argumentList[] ={"" , "QFocusEvent*"};
2831 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3072 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2832 void* args[2] = {NULL, (void*)&event};
3073 void* args[2] = {NULL, (void*)&event0};
2833 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3074 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2834 if (result) { Py_DECREF(result); }
3075 if (result) { Py_DECREF(result); }
2835 Py_DECREF(obj);
3076 Py_DECREF(obj);
2836 return;
3077 return;
2837 }
3078 } else {
2838 }
3079 PyErr_Clear();
2839 QHexSpinBox::focusOutEvent(event);
3080 }
3081 }
3082 QHexSpinBox::focusOutEvent(event0);
2840 }
3083 }
2841 bool PythonQtShell_QHexSpinBox::hasHeightForWidth() const
3084 bool PythonQtShell_QHexSpinBox::hasHeightForWidth() const
2842 {
3085 {
2843 if (_wrapper) {
3086 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2844 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
3087 static PyObject* name = PyString_FromString("hasHeightForWidth");
2845 PyErr_Clear();
3088 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2846 if (obj && !PythonQtSlotFunction_Check(obj)) {
3089 if (obj) {
2847 static const char* argumentList[] ={"bool"};
3090 static const char* argumentList[] ={"bool"};
2848 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3091 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2849 bool returnValue;
3092 bool returnValue;
@@ -2862,16 +3105,18 if (_wrapper) {
2862 if (result) { Py_DECREF(result); }
3105 if (result) { Py_DECREF(result); }
2863 Py_DECREF(obj);
3106 Py_DECREF(obj);
2864 return returnValue;
3107 return returnValue;
3108 } else {
3109 PyErr_Clear();
2865 }
3110 }
2866 }
3111 }
2867 return QHexSpinBox::hasHeightForWidth();
3112 return QHexSpinBox::hasHeightForWidth();
2868 }
3113 }
2869 int PythonQtShell_QHexSpinBox::heightForWidth(int arg__1) const
3114 int PythonQtShell_QHexSpinBox::heightForWidth(int arg__1) const
2870 {
3115 {
2871 if (_wrapper) {
3116 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2872 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
3117 static PyObject* name = PyString_FromString("heightForWidth");
2873 PyErr_Clear();
3118 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2874 if (obj && !PythonQtSlotFunction_Check(obj)) {
3119 if (obj) {
2875 static const char* argumentList[] ={"int" , "int"};
3120 static const char* argumentList[] ={"int" , "int"};
2876 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3121 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2877 int returnValue;
3122 int returnValue;
@@ -2890,50 +3135,56 if (_wrapper) {
2890 if (result) { Py_DECREF(result); }
3135 if (result) { Py_DECREF(result); }
2891 Py_DECREF(obj);
3136 Py_DECREF(obj);
2892 return returnValue;
3137 return returnValue;
3138 } else {
3139 PyErr_Clear();
2893 }
3140 }
2894 }
3141 }
2895 return QHexSpinBox::heightForWidth(arg__1);
3142 return QHexSpinBox::heightForWidth(arg__1);
2896 }
3143 }
2897 void PythonQtShell_QHexSpinBox::hideEvent(QHideEvent* event)
3144 void PythonQtShell_QHexSpinBox::hideEvent(QHideEvent* event0)
2898 {
3145 {
2899 if (_wrapper) {
3146 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2900 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
3147 static PyObject* name = PyString_FromString("hideEvent");
2901 PyErr_Clear();
3148 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2902 if (obj && !PythonQtSlotFunction_Check(obj)) {
3149 if (obj) {
2903 static const char* argumentList[] ={"" , "QHideEvent*"};
3150 static const char* argumentList[] ={"" , "QHideEvent*"};
2904 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3151 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2905 void* args[2] = {NULL, (void*)&event};
3152 void* args[2] = {NULL, (void*)&event0};
2906 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3153 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2907 if (result) { Py_DECREF(result); }
3154 if (result) { Py_DECREF(result); }
2908 Py_DECREF(obj);
3155 Py_DECREF(obj);
2909 return;
3156 return;
2910 }
3157 } else {
2911 }
3158 PyErr_Clear();
2912 QHexSpinBox::hideEvent(event);
3159 }
2913 }
3160 }
2914 void PythonQtShell_QHexSpinBox::initPainter(QPainter* painter) const
3161 QHexSpinBox::hideEvent(event0);
2915 {
3162 }
2916 if (_wrapper) {
3163 void PythonQtShell_QHexSpinBox::initPainter(QPainter* painter0) const
2917 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
3164 {
2918 PyErr_Clear();
3165 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2919 if (obj && !PythonQtSlotFunction_Check(obj)) {
3166 static PyObject* name = PyString_FromString("initPainter");
3167 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3168 if (obj) {
2920 static const char* argumentList[] ={"" , "QPainter*"};
3169 static const char* argumentList[] ={"" , "QPainter*"};
2921 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3170 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2922 void* args[2] = {NULL, (void*)&painter};
3171 void* args[2] = {NULL, (void*)&painter0};
2923 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3172 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2924 if (result) { Py_DECREF(result); }
3173 if (result) { Py_DECREF(result); }
2925 Py_DECREF(obj);
3174 Py_DECREF(obj);
2926 return;
3175 return;
2927 }
3176 } else {
2928 }
3177 PyErr_Clear();
2929 QHexSpinBox::initPainter(painter);
3178 }
3179 }
3180 QHexSpinBox::initPainter(painter0);
2930 }
3181 }
2931 void PythonQtShell_QHexSpinBox::inputMethodEvent(QInputMethodEvent* arg__1)
3182 void PythonQtShell_QHexSpinBox::inputMethodEvent(QInputMethodEvent* arg__1)
2932 {
3183 {
2933 if (_wrapper) {
3184 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2934 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
3185 static PyObject* name = PyString_FromString("inputMethodEvent");
2935 PyErr_Clear();
3186 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2936 if (obj && !PythonQtSlotFunction_Check(obj)) {
3187 if (obj) {
2937 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
3188 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
2938 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3189 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2939 void* args[2] = {NULL, (void*)&arg__1};
3190 void* args[2] = {NULL, (void*)&arg__1};
@@ -2941,16 +3192,18 if (_wrapper) {
2941 if (result) { Py_DECREF(result); }
3192 if (result) { Py_DECREF(result); }
2942 Py_DECREF(obj);
3193 Py_DECREF(obj);
2943 return;
3194 return;
3195 } else {
3196 PyErr_Clear();
2944 }
3197 }
2945 }
3198 }
2946 QHexSpinBox::inputMethodEvent(arg__1);
3199 QHexSpinBox::inputMethodEvent(arg__1);
2947 }
3200 }
2948 QVariant PythonQtShell_QHexSpinBox::inputMethodQuery(Qt::InputMethodQuery arg__1) const
3201 QVariant PythonQtShell_QHexSpinBox::inputMethodQuery(Qt::InputMethodQuery arg__1) const
2949 {
3202 {
2950 if (_wrapper) {
3203 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2951 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
3204 static PyObject* name = PyString_FromString("inputMethodQuery");
2952 PyErr_Clear();
3205 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2953 if (obj && !PythonQtSlotFunction_Check(obj)) {
3206 if (obj) {
2954 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
3207 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
2955 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3208 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2956 QVariant returnValue;
3209 QVariant returnValue;
@@ -2969,50 +3222,56 if (_wrapper) {
2969 if (result) { Py_DECREF(result); }
3222 if (result) { Py_DECREF(result); }
2970 Py_DECREF(obj);
3223 Py_DECREF(obj);
2971 return returnValue;
3224 return returnValue;
3225 } else {
3226 PyErr_Clear();
2972 }
3227 }
2973 }
3228 }
2974 return QHexSpinBox::inputMethodQuery(arg__1);
3229 return QHexSpinBox::inputMethodQuery(arg__1);
2975 }
3230 }
2976 void PythonQtShell_QHexSpinBox::keyPressEvent(QKeyEvent* event)
3231 void PythonQtShell_QHexSpinBox::keyPressEvent(QKeyEvent* event0)
2977 {
3232 {
2978 if (_wrapper) {
3233 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2979 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
3234 static PyObject* name = PyString_FromString("keyPressEvent");
2980 PyErr_Clear();
3235 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2981 if (obj && !PythonQtSlotFunction_Check(obj)) {
3236 if (obj) {
2982 static const char* argumentList[] ={"" , "QKeyEvent*"};
3237 static const char* argumentList[] ={"" , "QKeyEvent*"};
2983 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3238 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2984 void* args[2] = {NULL, (void*)&event};
3239 void* args[2] = {NULL, (void*)&event0};
2985 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3240 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2986 if (result) { Py_DECREF(result); }
3241 if (result) { Py_DECREF(result); }
2987 Py_DECREF(obj);
3242 Py_DECREF(obj);
2988 return;
3243 return;
2989 }
3244 } else {
2990 }
3245 PyErr_Clear();
2991 QHexSpinBox::keyPressEvent(event);
3246 }
2992 }
3247 }
2993 void PythonQtShell_QHexSpinBox::keyReleaseEvent(QKeyEvent* event)
3248 QHexSpinBox::keyPressEvent(event0);
2994 {
3249 }
2995 if (_wrapper) {
3250 void PythonQtShell_QHexSpinBox::keyReleaseEvent(QKeyEvent* event0)
2996 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
3251 {
2997 PyErr_Clear();
3252 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2998 if (obj && !PythonQtSlotFunction_Check(obj)) {
3253 static PyObject* name = PyString_FromString("keyReleaseEvent");
3254 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3255 if (obj) {
2999 static const char* argumentList[] ={"" , "QKeyEvent*"};
3256 static const char* argumentList[] ={"" , "QKeyEvent*"};
3000 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3257 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3001 void* args[2] = {NULL, (void*)&event};
3258 void* args[2] = {NULL, (void*)&event0};
3002 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3259 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3003 if (result) { Py_DECREF(result); }
3260 if (result) { Py_DECREF(result); }
3004 Py_DECREF(obj);
3261 Py_DECREF(obj);
3005 return;
3262 return;
3006 }
3263 } else {
3007 }
3264 PyErr_Clear();
3008 QHexSpinBox::keyReleaseEvent(event);
3265 }
3266 }
3267 QHexSpinBox::keyReleaseEvent(event0);
3009 }
3268 }
3010 void PythonQtShell_QHexSpinBox::leaveEvent(QEvent* arg__1)
3269 void PythonQtShell_QHexSpinBox::leaveEvent(QEvent* arg__1)
3011 {
3270 {
3012 if (_wrapper) {
3271 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3013 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
3272 static PyObject* name = PyString_FromString("leaveEvent");
3014 PyErr_Clear();
3273 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3015 if (obj && !PythonQtSlotFunction_Check(obj)) {
3274 if (obj) {
3016 static const char* argumentList[] ={"" , "QEvent*"};
3275 static const char* argumentList[] ={"" , "QEvent*"};
3017 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3276 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3018 void* args[2] = {NULL, (void*)&arg__1};
3277 void* args[2] = {NULL, (void*)&arg__1};
@@ -3020,16 +3279,18 if (_wrapper) {
3020 if (result) { Py_DECREF(result); }
3279 if (result) { Py_DECREF(result); }
3021 Py_DECREF(obj);
3280 Py_DECREF(obj);
3022 return;
3281 return;
3282 } else {
3283 PyErr_Clear();
3023 }
3284 }
3024 }
3285 }
3025 QHexSpinBox::leaveEvent(arg__1);
3286 QHexSpinBox::leaveEvent(arg__1);
3026 }
3287 }
3027 int PythonQtShell_QHexSpinBox::metric(QPaintDevice::PaintDeviceMetric arg__1) const
3288 int PythonQtShell_QHexSpinBox::metric(QPaintDevice::PaintDeviceMetric arg__1) const
3028 {
3289 {
3029 if (_wrapper) {
3290 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3030 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
3291 static PyObject* name = PyString_FromString("metric");
3031 PyErr_Clear();
3292 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3032 if (obj && !PythonQtSlotFunction_Check(obj)) {
3293 if (obj) {
3033 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
3294 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
3034 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3295 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3035 int returnValue;
3296 int returnValue;
@@ -3048,16 +3309,18 if (_wrapper) {
3048 if (result) { Py_DECREF(result); }
3309 if (result) { Py_DECREF(result); }
3049 Py_DECREF(obj);
3310 Py_DECREF(obj);
3050 return returnValue;
3311 return returnValue;
3312 } else {
3313 PyErr_Clear();
3051 }
3314 }
3052 }
3315 }
3053 return QHexSpinBox::metric(arg__1);
3316 return QHexSpinBox::metric(arg__1);
3054 }
3317 }
3055 void PythonQtShell_QHexSpinBox::mouseDoubleClickEvent(QMouseEvent* arg__1)
3318 void PythonQtShell_QHexSpinBox::mouseDoubleClickEvent(QMouseEvent* arg__1)
3056 {
3319 {
3057 if (_wrapper) {
3320 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3058 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
3321 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
3059 PyErr_Clear();
3322 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3060 if (obj && !PythonQtSlotFunction_Check(obj)) {
3323 if (obj) {
3061 static const char* argumentList[] ={"" , "QMouseEvent*"};
3324 static const char* argumentList[] ={"" , "QMouseEvent*"};
3062 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3325 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3063 void* args[2] = {NULL, (void*)&arg__1};
3326 void* args[2] = {NULL, (void*)&arg__1};
@@ -3065,67 +3328,75 if (_wrapper) {
3065 if (result) { Py_DECREF(result); }
3328 if (result) { Py_DECREF(result); }
3066 Py_DECREF(obj);
3329 Py_DECREF(obj);
3067 return;
3330 return;
3331 } else {
3332 PyErr_Clear();
3068 }
3333 }
3069 }
3334 }
3070 QHexSpinBox::mouseDoubleClickEvent(arg__1);
3335 QHexSpinBox::mouseDoubleClickEvent(arg__1);
3071 }
3336 }
3072 void PythonQtShell_QHexSpinBox::mouseMoveEvent(QMouseEvent* event)
3337 void PythonQtShell_QHexSpinBox::mouseMoveEvent(QMouseEvent* event0)
3073 {
3338 {
3074 if (_wrapper) {
3339 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3075 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
3340 static PyObject* name = PyString_FromString("mouseMoveEvent");
3076 PyErr_Clear();
3341 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3077 if (obj && !PythonQtSlotFunction_Check(obj)) {
3342 if (obj) {
3078 static const char* argumentList[] ={"" , "QMouseEvent*"};
3343 static const char* argumentList[] ={"" , "QMouseEvent*"};
3079 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3344 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3080 void* args[2] = {NULL, (void*)&event};
3345 void* args[2] = {NULL, (void*)&event0};
3081 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3346 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3082 if (result) { Py_DECREF(result); }
3347 if (result) { Py_DECREF(result); }
3083 Py_DECREF(obj);
3348 Py_DECREF(obj);
3084 return;
3349 return;
3085 }
3350 } else {
3086 }
3351 PyErr_Clear();
3087 QHexSpinBox::mouseMoveEvent(event);
3352 }
3088 }
3353 }
3089 void PythonQtShell_QHexSpinBox::mousePressEvent(QMouseEvent* event)
3354 QHexSpinBox::mouseMoveEvent(event0);
3090 {
3355 }
3091 if (_wrapper) {
3356 void PythonQtShell_QHexSpinBox::mousePressEvent(QMouseEvent* event0)
3092 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
3357 {
3093 PyErr_Clear();
3358 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3094 if (obj && !PythonQtSlotFunction_Check(obj)) {
3359 static PyObject* name = PyString_FromString("mousePressEvent");
3360 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3361 if (obj) {
3095 static const char* argumentList[] ={"" , "QMouseEvent*"};
3362 static const char* argumentList[] ={"" , "QMouseEvent*"};
3096 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3363 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3097 void* args[2] = {NULL, (void*)&event};
3364 void* args[2] = {NULL, (void*)&event0};
3098 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3365 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3099 if (result) { Py_DECREF(result); }
3366 if (result) { Py_DECREF(result); }
3100 Py_DECREF(obj);
3367 Py_DECREF(obj);
3101 return;
3368 return;
3102 }
3369 } else {
3103 }
3370 PyErr_Clear();
3104 QHexSpinBox::mousePressEvent(event);
3371 }
3105 }
3372 }
3106 void PythonQtShell_QHexSpinBox::mouseReleaseEvent(QMouseEvent* event)
3373 QHexSpinBox::mousePressEvent(event0);
3107 {
3374 }
3108 if (_wrapper) {
3375 void PythonQtShell_QHexSpinBox::mouseReleaseEvent(QMouseEvent* event0)
3109 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
3376 {
3110 PyErr_Clear();
3377 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3111 if (obj && !PythonQtSlotFunction_Check(obj)) {
3378 static PyObject* name = PyString_FromString("mouseReleaseEvent");
3379 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3380 if (obj) {
3112 static const char* argumentList[] ={"" , "QMouseEvent*"};
3381 static const char* argumentList[] ={"" , "QMouseEvent*"};
3113 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3382 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3114 void* args[2] = {NULL, (void*)&event};
3383 void* args[2] = {NULL, (void*)&event0};
3115 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3384 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3116 if (result) { Py_DECREF(result); }
3385 if (result) { Py_DECREF(result); }
3117 Py_DECREF(obj);
3386 Py_DECREF(obj);
3118 return;
3387 return;
3119 }
3388 } else {
3120 }
3389 PyErr_Clear();
3121 QHexSpinBox::mouseReleaseEvent(event);
3390 }
3391 }
3392 QHexSpinBox::mouseReleaseEvent(event0);
3122 }
3393 }
3123 void PythonQtShell_QHexSpinBox::moveEvent(QMoveEvent* arg__1)
3394 void PythonQtShell_QHexSpinBox::moveEvent(QMoveEvent* arg__1)
3124 {
3395 {
3125 if (_wrapper) {
3396 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3126 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
3397 static PyObject* name = PyString_FromString("moveEvent");
3127 PyErr_Clear();
3398 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3128 if (obj && !PythonQtSlotFunction_Check(obj)) {
3399 if (obj) {
3129 static const char* argumentList[] ={"" , "QMoveEvent*"};
3400 static const char* argumentList[] ={"" , "QMoveEvent*"};
3130 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3401 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3131 void* args[2] = {NULL, (void*)&arg__1};
3402 void* args[2] = {NULL, (void*)&arg__1};
@@ -3133,20 +3404,22 if (_wrapper) {
3133 if (result) { Py_DECREF(result); }
3404 if (result) { Py_DECREF(result); }
3134 Py_DECREF(obj);
3405 Py_DECREF(obj);
3135 return;
3406 return;
3407 } else {
3408 PyErr_Clear();
3136 }
3409 }
3137 }
3410 }
3138 QHexSpinBox::moveEvent(arg__1);
3411 QHexSpinBox::moveEvent(arg__1);
3139 }
3412 }
3140 bool PythonQtShell_QHexSpinBox::nativeEvent(const QByteArray& eventType, void* message, long* result)
3413 bool PythonQtShell_QHexSpinBox::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
3141 {
3414 {
3142 if (_wrapper) {
3415 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3143 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
3416 static PyObject* name = PyString_FromString("nativeEvent");
3144 PyErr_Clear();
3417 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3145 if (obj && !PythonQtSlotFunction_Check(obj)) {
3418 if (obj) {
3146 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
3419 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
3147 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
3420 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
3148 bool returnValue;
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 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3423 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3151 if (result) {
3424 if (result) {
3152 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3425 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -3161,16 +3434,18 if (_wrapper) {
3161 if (result) { Py_DECREF(result); }
3434 if (result) { Py_DECREF(result); }
3162 Py_DECREF(obj);
3435 Py_DECREF(obj);
3163 return returnValue;
3436 return returnValue;
3164 }
3437 } else {
3165 }
3438 PyErr_Clear();
3166 return QHexSpinBox::nativeEvent(eventType, message, result);
3439 }
3440 }
3441 return QHexSpinBox::nativeEvent(eventType0, message1, result2);
3167 }
3442 }
3168 QPaintEngine* PythonQtShell_QHexSpinBox::paintEngine() const
3443 QPaintEngine* PythonQtShell_QHexSpinBox::paintEngine() const
3169 {
3444 {
3170 if (_wrapper) {
3445 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3171 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
3446 static PyObject* name = PyString_FromString("paintEngine");
3172 PyErr_Clear();
3447 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3173 if (obj && !PythonQtSlotFunction_Check(obj)) {
3448 if (obj) {
3174 static const char* argumentList[] ={"QPaintEngine*"};
3449 static const char* argumentList[] ={"QPaintEngine*"};
3175 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3450 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3176 QPaintEngine* returnValue;
3451 QPaintEngine* returnValue;
@@ -3189,37 +3464,41 if (_wrapper) {
3189 if (result) { Py_DECREF(result); }
3464 if (result) { Py_DECREF(result); }
3190 Py_DECREF(obj);
3465 Py_DECREF(obj);
3191 return returnValue;
3466 return returnValue;
3467 } else {
3468 PyErr_Clear();
3192 }
3469 }
3193 }
3470 }
3194 return QHexSpinBox::paintEngine();
3471 return QHexSpinBox::paintEngine();
3195 }
3472 }
3196 void PythonQtShell_QHexSpinBox::paintEvent(QPaintEvent* event)
3473 void PythonQtShell_QHexSpinBox::paintEvent(QPaintEvent* event0)
3197 {
3474 {
3198 if (_wrapper) {
3475 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3199 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
3476 static PyObject* name = PyString_FromString("paintEvent");
3200 PyErr_Clear();
3477 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3201 if (obj && !PythonQtSlotFunction_Check(obj)) {
3478 if (obj) {
3202 static const char* argumentList[] ={"" , "QPaintEvent*"};
3479 static const char* argumentList[] ={"" , "QPaintEvent*"};
3203 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3480 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3204 void* args[2] = {NULL, (void*)&event};
3481 void* args[2] = {NULL, (void*)&event0};
3205 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3482 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3206 if (result) { Py_DECREF(result); }
3483 if (result) { Py_DECREF(result); }
3207 Py_DECREF(obj);
3484 Py_DECREF(obj);
3208 return;
3485 return;
3209 }
3486 } else {
3210 }
3487 PyErr_Clear();
3211 QHexSpinBox::paintEvent(event);
3488 }
3212 }
3489 }
3213 QPaintDevice* PythonQtShell_QHexSpinBox::redirected(QPoint* offset) const
3490 QHexSpinBox::paintEvent(event0);
3214 {
3491 }
3215 if (_wrapper) {
3492 QPaintDevice* PythonQtShell_QHexSpinBox::redirected(QPoint* offset0) const
3216 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
3493 {
3217 PyErr_Clear();
3494 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3218 if (obj && !PythonQtSlotFunction_Check(obj)) {
3495 static PyObject* name = PyString_FromString("redirected");
3496 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3497 if (obj) {
3219 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
3498 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
3220 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3499 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3221 QPaintDevice* returnValue;
3500 QPaintDevice* returnValue;
3222 void* args[2] = {NULL, (void*)&offset};
3501 void* args[2] = {NULL, (void*)&offset0};
3223 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3502 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3224 if (result) {
3503 if (result) {
3225 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3504 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -3234,33 +3513,37 if (_wrapper) {
3234 if (result) { Py_DECREF(result); }
3513 if (result) { Py_DECREF(result); }
3235 Py_DECREF(obj);
3514 Py_DECREF(obj);
3236 return returnValue;
3515 return returnValue;
3237 }
3516 } else {
3238 }
3517 PyErr_Clear();
3239 return QHexSpinBox::redirected(offset);
3518 }
3240 }
3519 }
3241 void PythonQtShell_QHexSpinBox::resizeEvent(QResizeEvent* event)
3520 return QHexSpinBox::redirected(offset0);
3242 {
3521 }
3243 if (_wrapper) {
3522 void PythonQtShell_QHexSpinBox::resizeEvent(QResizeEvent* event0)
3244 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
3523 {
3245 PyErr_Clear();
3524 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3246 if (obj && !PythonQtSlotFunction_Check(obj)) {
3525 static PyObject* name = PyString_FromString("resizeEvent");
3526 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3527 if (obj) {
3247 static const char* argumentList[] ={"" , "QResizeEvent*"};
3528 static const char* argumentList[] ={"" , "QResizeEvent*"};
3248 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3529 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3249 void* args[2] = {NULL, (void*)&event};
3530 void* args[2] = {NULL, (void*)&event0};
3250 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3531 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3251 if (result) { Py_DECREF(result); }
3532 if (result) { Py_DECREF(result); }
3252 Py_DECREF(obj);
3533 Py_DECREF(obj);
3253 return;
3534 return;
3254 }
3535 } else {
3255 }
3536 PyErr_Clear();
3256 QHexSpinBox::resizeEvent(event);
3537 }
3538 }
3539 QHexSpinBox::resizeEvent(event0);
3257 }
3540 }
3258 QPainter* PythonQtShell_QHexSpinBox::sharedPainter() const
3541 QPainter* PythonQtShell_QHexSpinBox::sharedPainter() const
3259 {
3542 {
3260 if (_wrapper) {
3543 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3261 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
3544 static PyObject* name = PyString_FromString("sharedPainter");
3262 PyErr_Clear();
3545 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3263 if (obj && !PythonQtSlotFunction_Check(obj)) {
3546 if (obj) {
3264 static const char* argumentList[] ={"QPainter*"};
3547 static const char* argumentList[] ={"QPainter*"};
3265 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3548 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3266 QPainter* returnValue;
3549 QPainter* returnValue;
@@ -3279,50 +3562,56 if (_wrapper) {
3279 if (result) { Py_DECREF(result); }
3562 if (result) { Py_DECREF(result); }
3280 Py_DECREF(obj);
3563 Py_DECREF(obj);
3281 return returnValue;
3564 return returnValue;
3565 } else {
3566 PyErr_Clear();
3282 }
3567 }
3283 }
3568 }
3284 return QHexSpinBox::sharedPainter();
3569 return QHexSpinBox::sharedPainter();
3285 }
3570 }
3286 void PythonQtShell_QHexSpinBox::showEvent(QShowEvent* event)
3571 void PythonQtShell_QHexSpinBox::showEvent(QShowEvent* event0)
3287 {
3572 {
3288 if (_wrapper) {
3573 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3289 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
3574 static PyObject* name = PyString_FromString("showEvent");
3290 PyErr_Clear();
3575 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3291 if (obj && !PythonQtSlotFunction_Check(obj)) {
3576 if (obj) {
3292 static const char* argumentList[] ={"" , "QShowEvent*"};
3577 static const char* argumentList[] ={"" , "QShowEvent*"};
3293 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3578 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3294 void* args[2] = {NULL, (void*)&event};
3579 void* args[2] = {NULL, (void*)&event0};
3295 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3580 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3296 if (result) { Py_DECREF(result); }
3581 if (result) { Py_DECREF(result); }
3297 Py_DECREF(obj);
3582 Py_DECREF(obj);
3298 return;
3583 return;
3299 }
3584 } else {
3300 }
3585 PyErr_Clear();
3301 QHexSpinBox::showEvent(event);
3586 }
3302 }
3587 }
3303 void PythonQtShell_QHexSpinBox::stepBy(int steps)
3588 QHexSpinBox::showEvent(event0);
3304 {
3589 }
3305 if (_wrapper) {
3590 void PythonQtShell_QHexSpinBox::stepBy(int steps0)
3306 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepBy");
3591 {
3307 PyErr_Clear();
3592 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3308 if (obj && !PythonQtSlotFunction_Check(obj)) {
3593 static PyObject* name = PyString_FromString("stepBy");
3594 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3595 if (obj) {
3309 static const char* argumentList[] ={"" , "int"};
3596 static const char* argumentList[] ={"" , "int"};
3310 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3597 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3311 void* args[2] = {NULL, (void*)&steps};
3598 void* args[2] = {NULL, (void*)&steps0};
3312 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3599 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3313 if (result) { Py_DECREF(result); }
3600 if (result) { Py_DECREF(result); }
3314 Py_DECREF(obj);
3601 Py_DECREF(obj);
3315 return;
3602 return;
3316 }
3603 } else {
3317 }
3604 PyErr_Clear();
3318 QHexSpinBox::stepBy(steps);
3605 }
3606 }
3607 QHexSpinBox::stepBy(steps0);
3319 }
3608 }
3320 QAbstractSpinBox::StepEnabled PythonQtShell_QHexSpinBox::stepEnabled() const
3609 QAbstractSpinBox::StepEnabled PythonQtShell_QHexSpinBox::stepEnabled() const
3321 {
3610 {
3322 if (_wrapper) {
3611 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3323 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepEnabled");
3612 static PyObject* name = PyString_FromString("stepEnabled");
3324 PyErr_Clear();
3613 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3325 if (obj && !PythonQtSlotFunction_Check(obj)) {
3614 if (obj) {
3326 static const char* argumentList[] ={"QAbstractSpinBox::StepEnabled"};
3615 static const char* argumentList[] ={"QAbstractSpinBox::StepEnabled"};
3327 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3616 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3328 QAbstractSpinBox::StepEnabled returnValue;
3617 QAbstractSpinBox::StepEnabled returnValue;
@@ -3341,16 +3630,18 if (_wrapper) {
3341 if (result) { Py_DECREF(result); }
3630 if (result) { Py_DECREF(result); }
3342 Py_DECREF(obj);
3631 Py_DECREF(obj);
3343 return returnValue;
3632 return returnValue;
3633 } else {
3634 PyErr_Clear();
3344 }
3635 }
3345 }
3636 }
3346 return QHexSpinBox::stepEnabled();
3637 return QHexSpinBox::stepEnabled();
3347 }
3638 }
3348 void PythonQtShell_QHexSpinBox::tabletEvent(QTabletEvent* arg__1)
3639 void PythonQtShell_QHexSpinBox::tabletEvent(QTabletEvent* arg__1)
3349 {
3640 {
3350 if (_wrapper) {
3641 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3351 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
3642 static PyObject* name = PyString_FromString("tabletEvent");
3352 PyErr_Clear();
3643 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3353 if (obj && !PythonQtSlotFunction_Check(obj)) {
3644 if (obj) {
3354 static const char* argumentList[] ={"" , "QTabletEvent*"};
3645 static const char* argumentList[] ={"" , "QTabletEvent*"};
3355 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3646 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3356 void* args[2] = {NULL, (void*)&arg__1};
3647 void* args[2] = {NULL, (void*)&arg__1};
@@ -3358,20 +3649,22 if (_wrapper) {
3358 if (result) { Py_DECREF(result); }
3649 if (result) { Py_DECREF(result); }
3359 Py_DECREF(obj);
3650 Py_DECREF(obj);
3360 return;
3651 return;
3652 } else {
3653 PyErr_Clear();
3361 }
3654 }
3362 }
3655 }
3363 QHexSpinBox::tabletEvent(arg__1);
3656 QHexSpinBox::tabletEvent(arg__1);
3364 }
3657 }
3365 QString PythonQtShell_QHexSpinBox::textFromValue(int value) const
3658 QString PythonQtShell_QHexSpinBox::textFromValue(int value0) const
3366 {
3659 {
3367 if (_wrapper) {
3660 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3368 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "textFromValue");
3661 static PyObject* name = PyString_FromString("textFromValue");
3369 PyErr_Clear();
3662 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3370 if (obj && !PythonQtSlotFunction_Check(obj)) {
3663 if (obj) {
3371 static const char* argumentList[] ={"QString" , "int"};
3664 static const char* argumentList[] ={"QString" , "int"};
3372 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3665 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3373 QString returnValue;
3666 QString returnValue;
3374 void* args[2] = {NULL, (void*)&value};
3667 void* args[2] = {NULL, (void*)&value0};
3375 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3668 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3376 if (result) {
3669 if (result) {
3377 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3670 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -3386,37 +3679,41 if (_wrapper) {
3386 if (result) { Py_DECREF(result); }
3679 if (result) { Py_DECREF(result); }
3387 Py_DECREF(obj);
3680 Py_DECREF(obj);
3388 return returnValue;
3681 return returnValue;
3389 }
3682 } else {
3390 }
3683 PyErr_Clear();
3391 return QHexSpinBox::textFromValue(value);
3684 }
3392 }
3685 }
3393 void PythonQtShell_QHexSpinBox::timerEvent(QTimerEvent* event)
3686 return QHexSpinBox::textFromValue(value0);
3394 {
3687 }
3395 if (_wrapper) {
3688 void PythonQtShell_QHexSpinBox::timerEvent(QTimerEvent* event0)
3396 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
3689 {
3397 PyErr_Clear();
3690 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3398 if (obj && !PythonQtSlotFunction_Check(obj)) {
3691 static PyObject* name = PyString_FromString("timerEvent");
3692 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3693 if (obj) {
3399 static const char* argumentList[] ={"" , "QTimerEvent*"};
3694 static const char* argumentList[] ={"" , "QTimerEvent*"};
3400 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3695 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3401 void* args[2] = {NULL, (void*)&event};
3696 void* args[2] = {NULL, (void*)&event0};
3402 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3697 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3403 if (result) { Py_DECREF(result); }
3698 if (result) { Py_DECREF(result); }
3404 Py_DECREF(obj);
3699 Py_DECREF(obj);
3405 return;
3700 return;
3406 }
3701 } else {
3407 }
3702 PyErr_Clear();
3408 QHexSpinBox::timerEvent(event);
3703 }
3409 }
3704 }
3410 QValidator::State PythonQtShell_QHexSpinBox::validate(QString& input, int& pos) const
3705 QHexSpinBox::timerEvent(event0);
3411 {
3706 }
3412 if (_wrapper) {
3707 QValidator::State PythonQtShell_QHexSpinBox::validate(QString& input0, int& pos1) const
3413 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "validate");
3708 {
3414 PyErr_Clear();
3709 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3415 if (obj && !PythonQtSlotFunction_Check(obj)) {
3710 static PyObject* name = PyString_FromString("validate");
3711 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3712 if (obj) {
3416 static const char* argumentList[] ={"QValidator::State" , "QString&" , "int&"};
3713 static const char* argumentList[] ={"QValidator::State" , "QString&" , "int&"};
3417 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3714 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3418 QValidator::State returnValue;
3715 QValidator::State returnValue;
3419 void* args[3] = {NULL, (void*)&input, (void*)&pos};
3716 void* args[3] = {NULL, (void*)&input0, (void*)&pos1};
3420 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3717 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3421 if (result) {
3718 if (result) {
3422 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3719 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -3431,20 +3728,22 if (_wrapper) {
3431 if (result) { Py_DECREF(result); }
3728 if (result) { Py_DECREF(result); }
3432 Py_DECREF(obj);
3729 Py_DECREF(obj);
3433 return returnValue;
3730 return returnValue;
3434 }
3731 } else {
3435 }
3732 PyErr_Clear();
3436 return QHexSpinBox::validate(input, pos);
3733 }
3437 }
3734 }
3438 int PythonQtShell_QHexSpinBox::valueFromText(const QString& text) const
3735 return QHexSpinBox::validate(input0, pos1);
3439 {
3736 }
3440 if (_wrapper) {
3737 int PythonQtShell_QHexSpinBox::valueFromText(const QString& text0) const
3441 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "valueFromText");
3738 {
3442 PyErr_Clear();
3739 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3443 if (obj && !PythonQtSlotFunction_Check(obj)) {
3740 static PyObject* name = PyString_FromString("valueFromText");
3741 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3742 if (obj) {
3444 static const char* argumentList[] ={"int" , "const QString&"};
3743 static const char* argumentList[] ={"int" , "const QString&"};
3445 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3744 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3446 int returnValue;
3745 int returnValue;
3447 void* args[2] = {NULL, (void*)&text};
3746 void* args[2] = {NULL, (void*)&text0};
3448 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3747 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3449 if (result) {
3748 if (result) {
3450 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3749 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -3459,26 +3758,30 if (_wrapper) {
3459 if (result) { Py_DECREF(result); }
3758 if (result) { Py_DECREF(result); }
3460 Py_DECREF(obj);
3759 Py_DECREF(obj);
3461 return returnValue;
3760 return returnValue;
3462 }
3761 } else {
3463 }
3762 PyErr_Clear();
3464 return QHexSpinBox::valueFromText(text);
3763 }
3465 }
3764 }
3466 void PythonQtShell_QHexSpinBox::wheelEvent(QWheelEvent* event)
3765 return QHexSpinBox::valueFromText(text0);
3467 {
3766 }
3468 if (_wrapper) {
3767 void PythonQtShell_QHexSpinBox::wheelEvent(QWheelEvent* event0)
3469 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
3768 {
3470 PyErr_Clear();
3769 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3471 if (obj && !PythonQtSlotFunction_Check(obj)) {
3770 static PyObject* name = PyString_FromString("wheelEvent");
3771 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3772 if (obj) {
3472 static const char* argumentList[] ={"" , "QWheelEvent*"};
3773 static const char* argumentList[] ={"" , "QWheelEvent*"};
3473 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3774 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3474 void* args[2] = {NULL, (void*)&event};
3775 void* args[2] = {NULL, (void*)&event0};
3475 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3776 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3476 if (result) { Py_DECREF(result); }
3777 if (result) { Py_DECREF(result); }
3477 Py_DECREF(obj);
3778 Py_DECREF(obj);
3478 return;
3779 return;
3479 }
3780 } else {
3480 }
3781 PyErr_Clear();
3481 QHexSpinBox::wheelEvent(event);
3782 }
3783 }
3784 QHexSpinBox::wheelEvent(event0);
3482 }
3785 }
3483 QHexSpinBox* PythonQtWrapper_QHexSpinBox::new_QHexSpinBox(QWidget* parent)
3786 QHexSpinBox* PythonQtWrapper_QHexSpinBox::new_QHexSpinBox(QWidget* parent)
3484 {
3787 {
@@ -3512,10 +3815,10 PythonQtShell_SocExplorerPlot::~PythonQt
3512 }
3815 }
3513 void PythonQtShell_SocExplorerPlot::actionEvent(QActionEvent* arg__1)
3816 void PythonQtShell_SocExplorerPlot::actionEvent(QActionEvent* arg__1)
3514 {
3817 {
3515 if (_wrapper) {
3818 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3516 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
3819 static PyObject* name = PyString_FromString("actionEvent");
3517 PyErr_Clear();
3820 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3518 if (obj && !PythonQtSlotFunction_Check(obj)) {
3821 if (obj) {
3519 static const char* argumentList[] ={"" , "QActionEvent*"};
3822 static const char* argumentList[] ={"" , "QActionEvent*"};
3520 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3823 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3521 void* args[2] = {NULL, (void*)&arg__1};
3824 void* args[2] = {NULL, (void*)&arg__1};
@@ -3523,16 +3826,18 if (_wrapper) {
3523 if (result) { Py_DECREF(result); }
3826 if (result) { Py_DECREF(result); }
3524 Py_DECREF(obj);
3827 Py_DECREF(obj);
3525 return;
3828 return;
3829 } else {
3830 PyErr_Clear();
3526 }
3831 }
3527 }
3832 }
3528 SocExplorerPlot::actionEvent(arg__1);
3833 SocExplorerPlot::actionEvent(arg__1);
3529 }
3834 }
3530 void PythonQtShell_SocExplorerPlot::changeEvent(QEvent* arg__1)
3835 void PythonQtShell_SocExplorerPlot::changeEvent(QEvent* arg__1)
3531 {
3836 {
3532 if (_wrapper) {
3837 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3533 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
3838 static PyObject* name = PyString_FromString("changeEvent");
3534 PyErr_Clear();
3839 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3535 if (obj && !PythonQtSlotFunction_Check(obj)) {
3840 if (obj) {
3536 static const char* argumentList[] ={"" , "QEvent*"};
3841 static const char* argumentList[] ={"" , "QEvent*"};
3537 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3842 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3538 void* args[2] = {NULL, (void*)&arg__1};
3843 void* args[2] = {NULL, (void*)&arg__1};
@@ -3540,16 +3845,18 if (_wrapper) {
3540 if (result) { Py_DECREF(result); }
3845 if (result) { Py_DECREF(result); }
3541 Py_DECREF(obj);
3846 Py_DECREF(obj);
3542 return;
3847 return;
3848 } else {
3849 PyErr_Clear();
3543 }
3850 }
3544 }
3851 }
3545 SocExplorerPlot::changeEvent(arg__1);
3852 SocExplorerPlot::changeEvent(arg__1);
3546 }
3853 }
3547 void PythonQtShell_SocExplorerPlot::childEvent(QChildEvent* arg__1)
3854 void PythonQtShell_SocExplorerPlot::childEvent(QChildEvent* arg__1)
3548 {
3855 {
3549 if (_wrapper) {
3856 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3550 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
3857 static PyObject* name = PyString_FromString("childEvent");
3551 PyErr_Clear();
3858 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3552 if (obj && !PythonQtSlotFunction_Check(obj)) {
3859 if (obj) {
3553 static const char* argumentList[] ={"" , "QChildEvent*"};
3860 static const char* argumentList[] ={"" , "QChildEvent*"};
3554 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3861 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3555 void* args[2] = {NULL, (void*)&arg__1};
3862 void* args[2] = {NULL, (void*)&arg__1};
@@ -3557,16 +3864,18 if (_wrapper) {
3557 if (result) { Py_DECREF(result); }
3864 if (result) { Py_DECREF(result); }
3558 Py_DECREF(obj);
3865 Py_DECREF(obj);
3559 return;
3866 return;
3867 } else {
3868 PyErr_Clear();
3560 }
3869 }
3561 }
3870 }
3562 SocExplorerPlot::childEvent(arg__1);
3871 SocExplorerPlot::childEvent(arg__1);
3563 }
3872 }
3564 void PythonQtShell_SocExplorerPlot::closeEvent(QCloseEvent* arg__1)
3873 void PythonQtShell_SocExplorerPlot::closeEvent(QCloseEvent* arg__1)
3565 {
3874 {
3566 if (_wrapper) {
3875 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3567 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
3876 static PyObject* name = PyString_FromString("closeEvent");
3568 PyErr_Clear();
3877 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3569 if (obj && !PythonQtSlotFunction_Check(obj)) {
3878 if (obj) {
3570 static const char* argumentList[] ={"" , "QCloseEvent*"};
3879 static const char* argumentList[] ={"" , "QCloseEvent*"};
3571 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3880 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3572 void* args[2] = {NULL, (void*)&arg__1};
3881 void* args[2] = {NULL, (void*)&arg__1};
@@ -3574,16 +3883,18 if (_wrapper) {
3574 if (result) { Py_DECREF(result); }
3883 if (result) { Py_DECREF(result); }
3575 Py_DECREF(obj);
3884 Py_DECREF(obj);
3576 return;
3885 return;
3886 } else {
3887 PyErr_Clear();
3577 }
3888 }
3578 }
3889 }
3579 SocExplorerPlot::closeEvent(arg__1);
3890 SocExplorerPlot::closeEvent(arg__1);
3580 }
3891 }
3581 void PythonQtShell_SocExplorerPlot::contextMenuEvent(QContextMenuEvent* arg__1)
3892 void PythonQtShell_SocExplorerPlot::contextMenuEvent(QContextMenuEvent* arg__1)
3582 {
3893 {
3583 if (_wrapper) {
3894 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3584 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
3895 static PyObject* name = PyString_FromString("contextMenuEvent");
3585 PyErr_Clear();
3896 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3586 if (obj && !PythonQtSlotFunction_Check(obj)) {
3897 if (obj) {
3587 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
3898 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
3588 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3899 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3589 void* args[2] = {NULL, (void*)&arg__1};
3900 void* args[2] = {NULL, (void*)&arg__1};
@@ -3591,16 +3902,18 if (_wrapper) {
3591 if (result) { Py_DECREF(result); }
3902 if (result) { Py_DECREF(result); }
3592 Py_DECREF(obj);
3903 Py_DECREF(obj);
3593 return;
3904 return;
3905 } else {
3906 PyErr_Clear();
3594 }
3907 }
3595 }
3908 }
3596 SocExplorerPlot::contextMenuEvent(arg__1);
3909 SocExplorerPlot::contextMenuEvent(arg__1);
3597 }
3910 }
3598 void PythonQtShell_SocExplorerPlot::customEvent(QEvent* arg__1)
3911 void PythonQtShell_SocExplorerPlot::customEvent(QEvent* arg__1)
3599 {
3912 {
3600 if (_wrapper) {
3913 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3601 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
3914 static PyObject* name = PyString_FromString("customEvent");
3602 PyErr_Clear();
3915 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3603 if (obj && !PythonQtSlotFunction_Check(obj)) {
3916 if (obj) {
3604 static const char* argumentList[] ={"" , "QEvent*"};
3917 static const char* argumentList[] ={"" , "QEvent*"};
3605 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3918 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3606 void* args[2] = {NULL, (void*)&arg__1};
3919 void* args[2] = {NULL, (void*)&arg__1};
@@ -3608,16 +3921,18 if (_wrapper) {
3608 if (result) { Py_DECREF(result); }
3921 if (result) { Py_DECREF(result); }
3609 Py_DECREF(obj);
3922 Py_DECREF(obj);
3610 return;
3923 return;
3924 } else {
3925 PyErr_Clear();
3611 }
3926 }
3612 }
3927 }
3613 SocExplorerPlot::customEvent(arg__1);
3928 SocExplorerPlot::customEvent(arg__1);
3614 }
3929 }
3615 int PythonQtShell_SocExplorerPlot::devType() const
3930 int PythonQtShell_SocExplorerPlot::devType() const
3616 {
3931 {
3617 if (_wrapper) {
3932 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3618 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
3933 static PyObject* name = PyString_FromString("devType");
3619 PyErr_Clear();
3934 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3620 if (obj && !PythonQtSlotFunction_Check(obj)) {
3935 if (obj) {
3621 static const char* argumentList[] ={"int"};
3936 static const char* argumentList[] ={"int"};
3622 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3937 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3623 int returnValue;
3938 int returnValue;
@@ -3636,16 +3951,18 if (_wrapper) {
3636 if (result) { Py_DECREF(result); }
3951 if (result) { Py_DECREF(result); }
3637 Py_DECREF(obj);
3952 Py_DECREF(obj);
3638 return returnValue;
3953 return returnValue;
3954 } else {
3955 PyErr_Clear();
3639 }
3956 }
3640 }
3957 }
3641 return SocExplorerPlot::devType();
3958 return SocExplorerPlot::devType();
3642 }
3959 }
3643 void PythonQtShell_SocExplorerPlot::dragEnterEvent(QDragEnterEvent* arg__1)
3960 void PythonQtShell_SocExplorerPlot::dragEnterEvent(QDragEnterEvent* arg__1)
3644 {
3961 {
3645 if (_wrapper) {
3962 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3646 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
3963 static PyObject* name = PyString_FromString("dragEnterEvent");
3647 PyErr_Clear();
3964 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3648 if (obj && !PythonQtSlotFunction_Check(obj)) {
3965 if (obj) {
3649 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
3966 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
3650 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3967 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3651 void* args[2] = {NULL, (void*)&arg__1};
3968 void* args[2] = {NULL, (void*)&arg__1};
@@ -3653,16 +3970,18 if (_wrapper) {
3653 if (result) { Py_DECREF(result); }
3970 if (result) { Py_DECREF(result); }
3654 Py_DECREF(obj);
3971 Py_DECREF(obj);
3655 return;
3972 return;
3973 } else {
3974 PyErr_Clear();
3656 }
3975 }
3657 }
3976 }
3658 SocExplorerPlot::dragEnterEvent(arg__1);
3977 SocExplorerPlot::dragEnterEvent(arg__1);
3659 }
3978 }
3660 void PythonQtShell_SocExplorerPlot::dragLeaveEvent(QDragLeaveEvent* arg__1)
3979 void PythonQtShell_SocExplorerPlot::dragLeaveEvent(QDragLeaveEvent* arg__1)
3661 {
3980 {
3662 if (_wrapper) {
3981 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3663 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
3982 static PyObject* name = PyString_FromString("dragLeaveEvent");
3664 PyErr_Clear();
3983 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3665 if (obj && !PythonQtSlotFunction_Check(obj)) {
3984 if (obj) {
3666 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
3985 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
3667 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3986 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3668 void* args[2] = {NULL, (void*)&arg__1};
3987 void* args[2] = {NULL, (void*)&arg__1};
@@ -3670,16 +3989,18 if (_wrapper) {
3670 if (result) { Py_DECREF(result); }
3989 if (result) { Py_DECREF(result); }
3671 Py_DECREF(obj);
3990 Py_DECREF(obj);
3672 return;
3991 return;
3992 } else {
3993 PyErr_Clear();
3673 }
3994 }
3674 }
3995 }
3675 SocExplorerPlot::dragLeaveEvent(arg__1);
3996 SocExplorerPlot::dragLeaveEvent(arg__1);
3676 }
3997 }
3677 void PythonQtShell_SocExplorerPlot::dragMoveEvent(QDragMoveEvent* arg__1)
3998 void PythonQtShell_SocExplorerPlot::dragMoveEvent(QDragMoveEvent* arg__1)
3678 {
3999 {
3679 if (_wrapper) {
4000 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3680 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
4001 static PyObject* name = PyString_FromString("dragMoveEvent");
3681 PyErr_Clear();
4002 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3682 if (obj && !PythonQtSlotFunction_Check(obj)) {
4003 if (obj) {
3683 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
4004 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
3684 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4005 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3685 void* args[2] = {NULL, (void*)&arg__1};
4006 void* args[2] = {NULL, (void*)&arg__1};
@@ -3687,16 +4008,18 if (_wrapper) {
3687 if (result) { Py_DECREF(result); }
4008 if (result) { Py_DECREF(result); }
3688 Py_DECREF(obj);
4009 Py_DECREF(obj);
3689 return;
4010 return;
4011 } else {
4012 PyErr_Clear();
3690 }
4013 }
3691 }
4014 }
3692 SocExplorerPlot::dragMoveEvent(arg__1);
4015 SocExplorerPlot::dragMoveEvent(arg__1);
3693 }
4016 }
3694 void PythonQtShell_SocExplorerPlot::dropEvent(QDropEvent* arg__1)
4017 void PythonQtShell_SocExplorerPlot::dropEvent(QDropEvent* arg__1)
3695 {
4018 {
3696 if (_wrapper) {
4019 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3697 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
4020 static PyObject* name = PyString_FromString("dropEvent");
3698 PyErr_Clear();
4021 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3699 if (obj && !PythonQtSlotFunction_Check(obj)) {
4022 if (obj) {
3700 static const char* argumentList[] ={"" , "QDropEvent*"};
4023 static const char* argumentList[] ={"" , "QDropEvent*"};
3701 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4024 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3702 void* args[2] = {NULL, (void*)&arg__1};
4025 void* args[2] = {NULL, (void*)&arg__1};
@@ -3704,16 +4027,18 if (_wrapper) {
3704 if (result) { Py_DECREF(result); }
4027 if (result) { Py_DECREF(result); }
3705 Py_DECREF(obj);
4028 Py_DECREF(obj);
3706 return;
4029 return;
4030 } else {
4031 PyErr_Clear();
3707 }
4032 }
3708 }
4033 }
3709 SocExplorerPlot::dropEvent(arg__1);
4034 SocExplorerPlot::dropEvent(arg__1);
3710 }
4035 }
3711 void PythonQtShell_SocExplorerPlot::enterEvent(QEvent* arg__1)
4036 void PythonQtShell_SocExplorerPlot::enterEvent(QEvent* arg__1)
3712 {
4037 {
3713 if (_wrapper) {
4038 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3714 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
4039 static PyObject* name = PyString_FromString("enterEvent");
3715 PyErr_Clear();
4040 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3716 if (obj && !PythonQtSlotFunction_Check(obj)) {
4041 if (obj) {
3717 static const char* argumentList[] ={"" , "QEvent*"};
4042 static const char* argumentList[] ={"" , "QEvent*"};
3718 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4043 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3719 void* args[2] = {NULL, (void*)&arg__1};
4044 void* args[2] = {NULL, (void*)&arg__1};
@@ -3721,16 +4046,18 if (_wrapper) {
3721 if (result) { Py_DECREF(result); }
4046 if (result) { Py_DECREF(result); }
3722 Py_DECREF(obj);
4047 Py_DECREF(obj);
3723 return;
4048 return;
4049 } else {
4050 PyErr_Clear();
3724 }
4051 }
3725 }
4052 }
3726 SocExplorerPlot::enterEvent(arg__1);
4053 SocExplorerPlot::enterEvent(arg__1);
3727 }
4054 }
3728 bool PythonQtShell_SocExplorerPlot::event(QEvent* arg__1)
4055 bool PythonQtShell_SocExplorerPlot::event(QEvent* arg__1)
3729 {
4056 {
3730 if (_wrapper) {
4057 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3731 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
4058 static PyObject* name = PyString_FromString("event");
3732 PyErr_Clear();
4059 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3733 if (obj && !PythonQtSlotFunction_Check(obj)) {
4060 if (obj) {
3734 static const char* argumentList[] ={"bool" , "QEvent*"};
4061 static const char* argumentList[] ={"bool" , "QEvent*"};
3735 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4062 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3736 bool returnValue;
4063 bool returnValue;
@@ -3749,16 +4076,18 if (_wrapper) {
3749 if (result) { Py_DECREF(result); }
4076 if (result) { Py_DECREF(result); }
3750 Py_DECREF(obj);
4077 Py_DECREF(obj);
3751 return returnValue;
4078 return returnValue;
4079 } else {
4080 PyErr_Clear();
3752 }
4081 }
3753 }
4082 }
3754 return SocExplorerPlot::event(arg__1);
4083 return SocExplorerPlot::event(arg__1);
3755 }
4084 }
3756 bool PythonQtShell_SocExplorerPlot::eventFilter(QObject* arg__1, QEvent* arg__2)
4085 bool PythonQtShell_SocExplorerPlot::eventFilter(QObject* arg__1, QEvent* arg__2)
3757 {
4086 {
3758 if (_wrapper) {
4087 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3759 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
4088 static PyObject* name = PyString_FromString("eventFilter");
3760 PyErr_Clear();
4089 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3761 if (obj && !PythonQtSlotFunction_Check(obj)) {
4090 if (obj) {
3762 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4091 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
3763 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4092 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3764 bool returnValue;
4093 bool returnValue;
@@ -3777,16 +4106,18 if (_wrapper) {
3777 if (result) { Py_DECREF(result); }
4106 if (result) { Py_DECREF(result); }
3778 Py_DECREF(obj);
4107 Py_DECREF(obj);
3779 return returnValue;
4108 return returnValue;
4109 } else {
4110 PyErr_Clear();
3780 }
4111 }
3781 }
4112 }
3782 return SocExplorerPlot::eventFilter(arg__1, arg__2);
4113 return SocExplorerPlot::eventFilter(arg__1, arg__2);
3783 }
4114 }
3784 void PythonQtShell_SocExplorerPlot::focusInEvent(QFocusEvent* arg__1)
4115 void PythonQtShell_SocExplorerPlot::focusInEvent(QFocusEvent* arg__1)
3785 {
4116 {
3786 if (_wrapper) {
4117 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3787 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
4118 static PyObject* name = PyString_FromString("focusInEvent");
3788 PyErr_Clear();
4119 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3789 if (obj && !PythonQtSlotFunction_Check(obj)) {
4120 if (obj) {
3790 static const char* argumentList[] ={"" , "QFocusEvent*"};
4121 static const char* argumentList[] ={"" , "QFocusEvent*"};
3791 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4122 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3792 void* args[2] = {NULL, (void*)&arg__1};
4123 void* args[2] = {NULL, (void*)&arg__1};
@@ -3794,20 +4125,22 if (_wrapper) {
3794 if (result) { Py_DECREF(result); }
4125 if (result) { Py_DECREF(result); }
3795 Py_DECREF(obj);
4126 Py_DECREF(obj);
3796 return;
4127 return;
4128 } else {
4129 PyErr_Clear();
3797 }
4130 }
3798 }
4131 }
3799 SocExplorerPlot::focusInEvent(arg__1);
4132 SocExplorerPlot::focusInEvent(arg__1);
3800 }
4133 }
3801 bool PythonQtShell_SocExplorerPlot::focusNextPrevChild(bool next)
4134 bool PythonQtShell_SocExplorerPlot::focusNextPrevChild(bool next0)
3802 {
4135 {
3803 if (_wrapper) {
4136 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3804 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
4137 static PyObject* name = PyString_FromString("focusNextPrevChild");
3805 PyErr_Clear();
4138 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3806 if (obj && !PythonQtSlotFunction_Check(obj)) {
4139 if (obj) {
3807 static const char* argumentList[] ={"bool" , "bool"};
4140 static const char* argumentList[] ={"bool" , "bool"};
3808 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4141 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3809 bool returnValue;
4142 bool returnValue;
3810 void* args[2] = {NULL, (void*)&next};
4143 void* args[2] = {NULL, (void*)&next0};
3811 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4144 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3812 if (result) {
4145 if (result) {
3813 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4146 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -3822,16 +4155,18 if (_wrapper) {
3822 if (result) { Py_DECREF(result); }
4155 if (result) { Py_DECREF(result); }
3823 Py_DECREF(obj);
4156 Py_DECREF(obj);
3824 return returnValue;
4157 return returnValue;
3825 }
4158 } else {
3826 }
4159 PyErr_Clear();
3827 return SocExplorerPlot::focusNextPrevChild(next);
4160 }
4161 }
4162 return SocExplorerPlot::focusNextPrevChild(next0);
3828 }
4163 }
3829 void PythonQtShell_SocExplorerPlot::focusOutEvent(QFocusEvent* arg__1)
4164 void PythonQtShell_SocExplorerPlot::focusOutEvent(QFocusEvent* arg__1)
3830 {
4165 {
3831 if (_wrapper) {
4166 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3832 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
4167 static PyObject* name = PyString_FromString("focusOutEvent");
3833 PyErr_Clear();
4168 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3834 if (obj && !PythonQtSlotFunction_Check(obj)) {
4169 if (obj) {
3835 static const char* argumentList[] ={"" , "QFocusEvent*"};
4170 static const char* argumentList[] ={"" , "QFocusEvent*"};
3836 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4171 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3837 void* args[2] = {NULL, (void*)&arg__1};
4172 void* args[2] = {NULL, (void*)&arg__1};
@@ -3839,16 +4174,18 if (_wrapper) {
3839 if (result) { Py_DECREF(result); }
4174 if (result) { Py_DECREF(result); }
3840 Py_DECREF(obj);
4175 Py_DECREF(obj);
3841 return;
4176 return;
4177 } else {
4178 PyErr_Clear();
3842 }
4179 }
3843 }
4180 }
3844 SocExplorerPlot::focusOutEvent(arg__1);
4181 SocExplorerPlot::focusOutEvent(arg__1);
3845 }
4182 }
3846 bool PythonQtShell_SocExplorerPlot::hasHeightForWidth() const
4183 bool PythonQtShell_SocExplorerPlot::hasHeightForWidth() const
3847 {
4184 {
3848 if (_wrapper) {
4185 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3849 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
4186 static PyObject* name = PyString_FromString("hasHeightForWidth");
3850 PyErr_Clear();
4187 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3851 if (obj && !PythonQtSlotFunction_Check(obj)) {
4188 if (obj) {
3852 static const char* argumentList[] ={"bool"};
4189 static const char* argumentList[] ={"bool"};
3853 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4190 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3854 bool returnValue;
4191 bool returnValue;
@@ -3867,16 +4204,18 if (_wrapper) {
3867 if (result) { Py_DECREF(result); }
4204 if (result) { Py_DECREF(result); }
3868 Py_DECREF(obj);
4205 Py_DECREF(obj);
3869 return returnValue;
4206 return returnValue;
4207 } else {
4208 PyErr_Clear();
3870 }
4209 }
3871 }
4210 }
3872 return SocExplorerPlot::hasHeightForWidth();
4211 return SocExplorerPlot::hasHeightForWidth();
3873 }
4212 }
3874 int PythonQtShell_SocExplorerPlot::heightForWidth(int arg__1) const
4213 int PythonQtShell_SocExplorerPlot::heightForWidth(int arg__1) const
3875 {
4214 {
3876 if (_wrapper) {
4215 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3877 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
4216 static PyObject* name = PyString_FromString("heightForWidth");
3878 PyErr_Clear();
4217 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3879 if (obj && !PythonQtSlotFunction_Check(obj)) {
4218 if (obj) {
3880 static const char* argumentList[] ={"int" , "int"};
4219 static const char* argumentList[] ={"int" , "int"};
3881 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4220 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3882 int returnValue;
4221 int returnValue;
@@ -3895,16 +4234,18 if (_wrapper) {
3895 if (result) { Py_DECREF(result); }
4234 if (result) { Py_DECREF(result); }
3896 Py_DECREF(obj);
4235 Py_DECREF(obj);
3897 return returnValue;
4236 return returnValue;
4237 } else {
4238 PyErr_Clear();
3898 }
4239 }
3899 }
4240 }
3900 return SocExplorerPlot::heightForWidth(arg__1);
4241 return SocExplorerPlot::heightForWidth(arg__1);
3901 }
4242 }
3902 void PythonQtShell_SocExplorerPlot::hideEvent(QHideEvent* arg__1)
4243 void PythonQtShell_SocExplorerPlot::hideEvent(QHideEvent* arg__1)
3903 {
4244 {
3904 if (_wrapper) {
4245 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3905 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
4246 static PyObject* name = PyString_FromString("hideEvent");
3906 PyErr_Clear();
4247 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3907 if (obj && !PythonQtSlotFunction_Check(obj)) {
4248 if (obj) {
3908 static const char* argumentList[] ={"" , "QHideEvent*"};
4249 static const char* argumentList[] ={"" , "QHideEvent*"};
3909 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4250 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3910 void* args[2] = {NULL, (void*)&arg__1};
4251 void* args[2] = {NULL, (void*)&arg__1};
@@ -3912,33 +4253,37 if (_wrapper) {
3912 if (result) { Py_DECREF(result); }
4253 if (result) { Py_DECREF(result); }
3913 Py_DECREF(obj);
4254 Py_DECREF(obj);
3914 return;
4255 return;
4256 } else {
4257 PyErr_Clear();
3915 }
4258 }
3916 }
4259 }
3917 SocExplorerPlot::hideEvent(arg__1);
4260 SocExplorerPlot::hideEvent(arg__1);
3918 }
4261 }
3919 void PythonQtShell_SocExplorerPlot::initPainter(QPainter* painter) const
4262 void PythonQtShell_SocExplorerPlot::initPainter(QPainter* painter0) const
3920 {
4263 {
3921 if (_wrapper) {
4264 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3922 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
4265 static PyObject* name = PyString_FromString("initPainter");
3923 PyErr_Clear();
4266 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3924 if (obj && !PythonQtSlotFunction_Check(obj)) {
4267 if (obj) {
3925 static const char* argumentList[] ={"" , "QPainter*"};
4268 static const char* argumentList[] ={"" , "QPainter*"};
3926 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4269 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3927 void* args[2] = {NULL, (void*)&painter};
4270 void* args[2] = {NULL, (void*)&painter0};
3928 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4271 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3929 if (result) { Py_DECREF(result); }
4272 if (result) { Py_DECREF(result); }
3930 Py_DECREF(obj);
4273 Py_DECREF(obj);
3931 return;
4274 return;
3932 }
4275 } else {
3933 }
4276 PyErr_Clear();
3934 SocExplorerPlot::initPainter(painter);
4277 }
4278 }
4279 SocExplorerPlot::initPainter(painter0);
3935 }
4280 }
3936 void PythonQtShell_SocExplorerPlot::inputMethodEvent(QInputMethodEvent* arg__1)
4281 void PythonQtShell_SocExplorerPlot::inputMethodEvent(QInputMethodEvent* arg__1)
3937 {
4282 {
3938 if (_wrapper) {
4283 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3939 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
4284 static PyObject* name = PyString_FromString("inputMethodEvent");
3940 PyErr_Clear();
4285 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3941 if (obj && !PythonQtSlotFunction_Check(obj)) {
4286 if (obj) {
3942 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
4287 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
3943 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4288 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3944 void* args[2] = {NULL, (void*)&arg__1};
4289 void* args[2] = {NULL, (void*)&arg__1};
@@ -3946,16 +4291,18 if (_wrapper) {
3946 if (result) { Py_DECREF(result); }
4291 if (result) { Py_DECREF(result); }
3947 Py_DECREF(obj);
4292 Py_DECREF(obj);
3948 return;
4293 return;
4294 } else {
4295 PyErr_Clear();
3949 }
4296 }
3950 }
4297 }
3951 SocExplorerPlot::inputMethodEvent(arg__1);
4298 SocExplorerPlot::inputMethodEvent(arg__1);
3952 }
4299 }
3953 QVariant PythonQtShell_SocExplorerPlot::inputMethodQuery(Qt::InputMethodQuery arg__1) const
4300 QVariant PythonQtShell_SocExplorerPlot::inputMethodQuery(Qt::InputMethodQuery arg__1) const
3954 {
4301 {
3955 if (_wrapper) {
4302 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3956 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
4303 static PyObject* name = PyString_FromString("inputMethodQuery");
3957 PyErr_Clear();
4304 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3958 if (obj && !PythonQtSlotFunction_Check(obj)) {
4305 if (obj) {
3959 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
4306 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
3960 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4307 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3961 QVariant returnValue;
4308 QVariant returnValue;
@@ -3974,16 +4321,18 if (_wrapper) {
3974 if (result) { Py_DECREF(result); }
4321 if (result) { Py_DECREF(result); }
3975 Py_DECREF(obj);
4322 Py_DECREF(obj);
3976 return returnValue;
4323 return returnValue;
4324 } else {
4325 PyErr_Clear();
3977 }
4326 }
3978 }
4327 }
3979 return SocExplorerPlot::inputMethodQuery(arg__1);
4328 return SocExplorerPlot::inputMethodQuery(arg__1);
3980 }
4329 }
3981 void PythonQtShell_SocExplorerPlot::keyPressEvent(QKeyEvent* arg__1)
4330 void PythonQtShell_SocExplorerPlot::keyPressEvent(QKeyEvent* arg__1)
3982 {
4331 {
3983 if (_wrapper) {
4332 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3984 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
4333 static PyObject* name = PyString_FromString("keyPressEvent");
3985 PyErr_Clear();
4334 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3986 if (obj && !PythonQtSlotFunction_Check(obj)) {
4335 if (obj) {
3987 static const char* argumentList[] ={"" , "QKeyEvent*"};
4336 static const char* argumentList[] ={"" , "QKeyEvent*"};
3988 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4337 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3989 void* args[2] = {NULL, (void*)&arg__1};
4338 void* args[2] = {NULL, (void*)&arg__1};
@@ -3991,16 +4340,18 if (_wrapper) {
3991 if (result) { Py_DECREF(result); }
4340 if (result) { Py_DECREF(result); }
3992 Py_DECREF(obj);
4341 Py_DECREF(obj);
3993 return;
4342 return;
4343 } else {
4344 PyErr_Clear();
3994 }
4345 }
3995 }
4346 }
3996 SocExplorerPlot::keyPressEvent(arg__1);
4347 SocExplorerPlot::keyPressEvent(arg__1);
3997 }
4348 }
3998 void PythonQtShell_SocExplorerPlot::keyReleaseEvent(QKeyEvent* arg__1)
4349 void PythonQtShell_SocExplorerPlot::keyReleaseEvent(QKeyEvent* arg__1)
3999 {
4350 {
4000 if (_wrapper) {
4351 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4001 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
4352 static PyObject* name = PyString_FromString("keyReleaseEvent");
4002 PyErr_Clear();
4353 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4003 if (obj && !PythonQtSlotFunction_Check(obj)) {
4354 if (obj) {
4004 static const char* argumentList[] ={"" , "QKeyEvent*"};
4355 static const char* argumentList[] ={"" , "QKeyEvent*"};
4005 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4356 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4006 void* args[2] = {NULL, (void*)&arg__1};
4357 void* args[2] = {NULL, (void*)&arg__1};
@@ -4008,16 +4359,18 if (_wrapper) {
4008 if (result) { Py_DECREF(result); }
4359 if (result) { Py_DECREF(result); }
4009 Py_DECREF(obj);
4360 Py_DECREF(obj);
4010 return;
4361 return;
4362 } else {
4363 PyErr_Clear();
4011 }
4364 }
4012 }
4365 }
4013 SocExplorerPlot::keyReleaseEvent(arg__1);
4366 SocExplorerPlot::keyReleaseEvent(arg__1);
4014 }
4367 }
4015 void PythonQtShell_SocExplorerPlot::leaveEvent(QEvent* arg__1)
4368 void PythonQtShell_SocExplorerPlot::leaveEvent(QEvent* arg__1)
4016 {
4369 {
4017 if (_wrapper) {
4370 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4018 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
4371 static PyObject* name = PyString_FromString("leaveEvent");
4019 PyErr_Clear();
4372 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4020 if (obj && !PythonQtSlotFunction_Check(obj)) {
4373 if (obj) {
4021 static const char* argumentList[] ={"" , "QEvent*"};
4374 static const char* argumentList[] ={"" , "QEvent*"};
4022 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4375 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4023 void* args[2] = {NULL, (void*)&arg__1};
4376 void* args[2] = {NULL, (void*)&arg__1};
@@ -4025,16 +4378,18 if (_wrapper) {
4025 if (result) { Py_DECREF(result); }
4378 if (result) { Py_DECREF(result); }
4026 Py_DECREF(obj);
4379 Py_DECREF(obj);
4027 return;
4380 return;
4381 } else {
4382 PyErr_Clear();
4028 }
4383 }
4029 }
4384 }
4030 SocExplorerPlot::leaveEvent(arg__1);
4385 SocExplorerPlot::leaveEvent(arg__1);
4031 }
4386 }
4032 int PythonQtShell_SocExplorerPlot::metric(QPaintDevice::PaintDeviceMetric arg__1) const
4387 int PythonQtShell_SocExplorerPlot::metric(QPaintDevice::PaintDeviceMetric arg__1) const
4033 {
4388 {
4034 if (_wrapper) {
4389 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4035 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
4390 static PyObject* name = PyString_FromString("metric");
4036 PyErr_Clear();
4391 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4037 if (obj && !PythonQtSlotFunction_Check(obj)) {
4392 if (obj) {
4038 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
4393 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
4039 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4394 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4040 int returnValue;
4395 int returnValue;
@@ -4053,16 +4408,18 if (_wrapper) {
4053 if (result) { Py_DECREF(result); }
4408 if (result) { Py_DECREF(result); }
4054 Py_DECREF(obj);
4409 Py_DECREF(obj);
4055 return returnValue;
4410 return returnValue;
4411 } else {
4412 PyErr_Clear();
4056 }
4413 }
4057 }
4414 }
4058 return SocExplorerPlot::metric(arg__1);
4415 return SocExplorerPlot::metric(arg__1);
4059 }
4416 }
4060 QSize PythonQtShell_SocExplorerPlot::minimumSizeHint() const
4417 QSize PythonQtShell_SocExplorerPlot::minimumSizeHint() const
4061 {
4418 {
4062 if (_wrapper) {
4419 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4063 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
4420 static PyObject* name = PyString_FromString("getMinimumSizeHint");
4064 PyErr_Clear();
4421 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4065 if (obj && !PythonQtSlotFunction_Check(obj)) {
4422 if (obj) {
4066 static const char* argumentList[] ={"QSize"};
4423 static const char* argumentList[] ={"QSize"};
4067 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4424 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4068 QSize returnValue;
4425 QSize returnValue;
@@ -4081,16 +4438,18 if (_wrapper) {
4081 if (result) { Py_DECREF(result); }
4438 if (result) { Py_DECREF(result); }
4082 Py_DECREF(obj);
4439 Py_DECREF(obj);
4083 return returnValue;
4440 return returnValue;
4441 } else {
4442 PyErr_Clear();
4084 }
4443 }
4085 }
4444 }
4086 return SocExplorerPlot::minimumSizeHint();
4445 return SocExplorerPlot::minimumSizeHint();
4087 }
4446 }
4088 void PythonQtShell_SocExplorerPlot::mouseDoubleClickEvent(QMouseEvent* arg__1)
4447 void PythonQtShell_SocExplorerPlot::mouseDoubleClickEvent(QMouseEvent* arg__1)
4089 {
4448 {
4090 if (_wrapper) {
4449 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4091 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
4450 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
4092 PyErr_Clear();
4451 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4093 if (obj && !PythonQtSlotFunction_Check(obj)) {
4452 if (obj) {
4094 static const char* argumentList[] ={"" , "QMouseEvent*"};
4453 static const char* argumentList[] ={"" , "QMouseEvent*"};
4095 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4454 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4096 void* args[2] = {NULL, (void*)&arg__1};
4455 void* args[2] = {NULL, (void*)&arg__1};
@@ -4098,16 +4457,18 if (_wrapper) {
4098 if (result) { Py_DECREF(result); }
4457 if (result) { Py_DECREF(result); }
4099 Py_DECREF(obj);
4458 Py_DECREF(obj);
4100 return;
4459 return;
4460 } else {
4461 PyErr_Clear();
4101 }
4462 }
4102 }
4463 }
4103 SocExplorerPlot::mouseDoubleClickEvent(arg__1);
4464 SocExplorerPlot::mouseDoubleClickEvent(arg__1);
4104 }
4465 }
4105 void PythonQtShell_SocExplorerPlot::mouseMoveEvent(QMouseEvent* arg__1)
4466 void PythonQtShell_SocExplorerPlot::mouseMoveEvent(QMouseEvent* arg__1)
4106 {
4467 {
4107 if (_wrapper) {
4468 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4108 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
4469 static PyObject* name = PyString_FromString("mouseMoveEvent");
4109 PyErr_Clear();
4470 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4110 if (obj && !PythonQtSlotFunction_Check(obj)) {
4471 if (obj) {
4111 static const char* argumentList[] ={"" , "QMouseEvent*"};
4472 static const char* argumentList[] ={"" , "QMouseEvent*"};
4112 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4473 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4113 void* args[2] = {NULL, (void*)&arg__1};
4474 void* args[2] = {NULL, (void*)&arg__1};
@@ -4115,16 +4476,18 if (_wrapper) {
4115 if (result) { Py_DECREF(result); }
4476 if (result) { Py_DECREF(result); }
4116 Py_DECREF(obj);
4477 Py_DECREF(obj);
4117 return;
4478 return;
4479 } else {
4480 PyErr_Clear();
4118 }
4481 }
4119 }
4482 }
4120 SocExplorerPlot::mouseMoveEvent(arg__1);
4483 SocExplorerPlot::mouseMoveEvent(arg__1);
4121 }
4484 }
4122 void PythonQtShell_SocExplorerPlot::mousePressEvent(QMouseEvent* arg__1)
4485 void PythonQtShell_SocExplorerPlot::mousePressEvent(QMouseEvent* arg__1)
4123 {
4486 {
4124 if (_wrapper) {
4487 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4125 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
4488 static PyObject* name = PyString_FromString("mousePressEvent");
4126 PyErr_Clear();
4489 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4127 if (obj && !PythonQtSlotFunction_Check(obj)) {
4490 if (obj) {
4128 static const char* argumentList[] ={"" , "QMouseEvent*"};
4491 static const char* argumentList[] ={"" , "QMouseEvent*"};
4129 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4492 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4130 void* args[2] = {NULL, (void*)&arg__1};
4493 void* args[2] = {NULL, (void*)&arg__1};
@@ -4132,16 +4495,18 if (_wrapper) {
4132 if (result) { Py_DECREF(result); }
4495 if (result) { Py_DECREF(result); }
4133 Py_DECREF(obj);
4496 Py_DECREF(obj);
4134 return;
4497 return;
4498 } else {
4499 PyErr_Clear();
4135 }
4500 }
4136 }
4501 }
4137 SocExplorerPlot::mousePressEvent(arg__1);
4502 SocExplorerPlot::mousePressEvent(arg__1);
4138 }
4503 }
4139 void PythonQtShell_SocExplorerPlot::mouseReleaseEvent(QMouseEvent* arg__1)
4504 void PythonQtShell_SocExplorerPlot::mouseReleaseEvent(QMouseEvent* arg__1)
4140 {
4505 {
4141 if (_wrapper) {
4506 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4142 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
4507 static PyObject* name = PyString_FromString("mouseReleaseEvent");
4143 PyErr_Clear();
4508 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4144 if (obj && !PythonQtSlotFunction_Check(obj)) {
4509 if (obj) {
4145 static const char* argumentList[] ={"" , "QMouseEvent*"};
4510 static const char* argumentList[] ={"" , "QMouseEvent*"};
4146 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4511 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4147 void* args[2] = {NULL, (void*)&arg__1};
4512 void* args[2] = {NULL, (void*)&arg__1};
@@ -4149,16 +4514,18 if (_wrapper) {
4149 if (result) { Py_DECREF(result); }
4514 if (result) { Py_DECREF(result); }
4150 Py_DECREF(obj);
4515 Py_DECREF(obj);
4151 return;
4516 return;
4517 } else {
4518 PyErr_Clear();
4152 }
4519 }
4153 }
4520 }
4154 SocExplorerPlot::mouseReleaseEvent(arg__1);
4521 SocExplorerPlot::mouseReleaseEvent(arg__1);
4155 }
4522 }
4156 void PythonQtShell_SocExplorerPlot::moveEvent(QMoveEvent* arg__1)
4523 void PythonQtShell_SocExplorerPlot::moveEvent(QMoveEvent* arg__1)
4157 {
4524 {
4158 if (_wrapper) {
4525 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4159 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
4526 static PyObject* name = PyString_FromString("moveEvent");
4160 PyErr_Clear();
4527 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4161 if (obj && !PythonQtSlotFunction_Check(obj)) {
4528 if (obj) {
4162 static const char* argumentList[] ={"" , "QMoveEvent*"};
4529 static const char* argumentList[] ={"" , "QMoveEvent*"};
4163 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4530 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4164 void* args[2] = {NULL, (void*)&arg__1};
4531 void* args[2] = {NULL, (void*)&arg__1};
@@ -4166,20 +4533,22 if (_wrapper) {
4166 if (result) { Py_DECREF(result); }
4533 if (result) { Py_DECREF(result); }
4167 Py_DECREF(obj);
4534 Py_DECREF(obj);
4168 return;
4535 return;
4536 } else {
4537 PyErr_Clear();
4169 }
4538 }
4170 }
4539 }
4171 SocExplorerPlot::moveEvent(arg__1);
4540 SocExplorerPlot::moveEvent(arg__1);
4172 }
4541 }
4173 bool PythonQtShell_SocExplorerPlot::nativeEvent(const QByteArray& eventType, void* message, long* result)
4542 bool PythonQtShell_SocExplorerPlot::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
4174 {
4543 {
4175 if (_wrapper) {
4544 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4176 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
4545 static PyObject* name = PyString_FromString("nativeEvent");
4177 PyErr_Clear();
4546 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4178 if (obj && !PythonQtSlotFunction_Check(obj)) {
4547 if (obj) {
4179 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
4548 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
4180 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
4549 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
4181 bool returnValue;
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 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4552 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4184 if (result) {
4553 if (result) {
4185 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4554 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -4194,16 +4563,18 if (_wrapper) {
4194 if (result) { Py_DECREF(result); }
4563 if (result) { Py_DECREF(result); }
4195 Py_DECREF(obj);
4564 Py_DECREF(obj);
4196 return returnValue;
4565 return returnValue;
4197 }
4566 } else {
4198 }
4567 PyErr_Clear();
4199 return SocExplorerPlot::nativeEvent(eventType, message, result);
4568 }
4569 }
4570 return SocExplorerPlot::nativeEvent(eventType0, message1, result2);
4200 }
4571 }
4201 QPaintEngine* PythonQtShell_SocExplorerPlot::paintEngine() const
4572 QPaintEngine* PythonQtShell_SocExplorerPlot::paintEngine() const
4202 {
4573 {
4203 if (_wrapper) {
4574 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4204 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
4575 static PyObject* name = PyString_FromString("paintEngine");
4205 PyErr_Clear();
4576 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4206 if (obj && !PythonQtSlotFunction_Check(obj)) {
4577 if (obj) {
4207 static const char* argumentList[] ={"QPaintEngine*"};
4578 static const char* argumentList[] ={"QPaintEngine*"};
4208 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4579 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4209 QPaintEngine* returnValue;
4580 QPaintEngine* returnValue;
@@ -4222,16 +4593,18 if (_wrapper) {
4222 if (result) { Py_DECREF(result); }
4593 if (result) { Py_DECREF(result); }
4223 Py_DECREF(obj);
4594 Py_DECREF(obj);
4224 return returnValue;
4595 return returnValue;
4596 } else {
4597 PyErr_Clear();
4225 }
4598 }
4226 }
4599 }
4227 return SocExplorerPlot::paintEngine();
4600 return SocExplorerPlot::paintEngine();
4228 }
4601 }
4229 void PythonQtShell_SocExplorerPlot::paintEvent(QPaintEvent* arg__1)
4602 void PythonQtShell_SocExplorerPlot::paintEvent(QPaintEvent* arg__1)
4230 {
4603 {
4231 if (_wrapper) {
4604 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4232 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
4605 static PyObject* name = PyString_FromString("paintEvent");
4233 PyErr_Clear();
4606 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4234 if (obj && !PythonQtSlotFunction_Check(obj)) {
4607 if (obj) {
4235 static const char* argumentList[] ={"" , "QPaintEvent*"};
4608 static const char* argumentList[] ={"" , "QPaintEvent*"};
4236 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4609 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4237 void* args[2] = {NULL, (void*)&arg__1};
4610 void* args[2] = {NULL, (void*)&arg__1};
@@ -4239,20 +4612,22 if (_wrapper) {
4239 if (result) { Py_DECREF(result); }
4612 if (result) { Py_DECREF(result); }
4240 Py_DECREF(obj);
4613 Py_DECREF(obj);
4241 return;
4614 return;
4615 } else {
4616 PyErr_Clear();
4242 }
4617 }
4243 }
4618 }
4244 SocExplorerPlot::paintEvent(arg__1);
4619 SocExplorerPlot::paintEvent(arg__1);
4245 }
4620 }
4246 QPaintDevice* PythonQtShell_SocExplorerPlot::redirected(QPoint* offset) const
4621 QPaintDevice* PythonQtShell_SocExplorerPlot::redirected(QPoint* offset0) const
4247 {
4622 {
4248 if (_wrapper) {
4623 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4249 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
4624 static PyObject* name = PyString_FromString("redirected");
4250 PyErr_Clear();
4625 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4251 if (obj && !PythonQtSlotFunction_Check(obj)) {
4626 if (obj) {
4252 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
4627 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
4253 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4628 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4254 QPaintDevice* returnValue;
4629 QPaintDevice* returnValue;
4255 void* args[2] = {NULL, (void*)&offset};
4630 void* args[2] = {NULL, (void*)&offset0};
4256 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4631 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4257 if (result) {
4632 if (result) {
4258 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4633 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -4267,16 +4642,18 if (_wrapper) {
4267 if (result) { Py_DECREF(result); }
4642 if (result) { Py_DECREF(result); }
4268 Py_DECREF(obj);
4643 Py_DECREF(obj);
4269 return returnValue;
4644 return returnValue;
4270 }
4645 } else {
4271 }
4646 PyErr_Clear();
4272 return SocExplorerPlot::redirected(offset);
4647 }
4648 }
4649 return SocExplorerPlot::redirected(offset0);
4273 }
4650 }
4274 void PythonQtShell_SocExplorerPlot::resizeEvent(QResizeEvent* arg__1)
4651 void PythonQtShell_SocExplorerPlot::resizeEvent(QResizeEvent* arg__1)
4275 {
4652 {
4276 if (_wrapper) {
4653 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4277 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
4654 static PyObject* name = PyString_FromString("resizeEvent");
4278 PyErr_Clear();
4655 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4279 if (obj && !PythonQtSlotFunction_Check(obj)) {
4656 if (obj) {
4280 static const char* argumentList[] ={"" , "QResizeEvent*"};
4657 static const char* argumentList[] ={"" , "QResizeEvent*"};
4281 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4658 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4282 void* args[2] = {NULL, (void*)&arg__1};
4659 void* args[2] = {NULL, (void*)&arg__1};
@@ -4284,16 +4661,18 if (_wrapper) {
4284 if (result) { Py_DECREF(result); }
4661 if (result) { Py_DECREF(result); }
4285 Py_DECREF(obj);
4662 Py_DECREF(obj);
4286 return;
4663 return;
4664 } else {
4665 PyErr_Clear();
4287 }
4666 }
4288 }
4667 }
4289 SocExplorerPlot::resizeEvent(arg__1);
4668 SocExplorerPlot::resizeEvent(arg__1);
4290 }
4669 }
4291 QPainter* PythonQtShell_SocExplorerPlot::sharedPainter() const
4670 QPainter* PythonQtShell_SocExplorerPlot::sharedPainter() const
4292 {
4671 {
4293 if (_wrapper) {
4672 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4294 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
4673 static PyObject* name = PyString_FromString("sharedPainter");
4295 PyErr_Clear();
4674 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4296 if (obj && !PythonQtSlotFunction_Check(obj)) {
4675 if (obj) {
4297 static const char* argumentList[] ={"QPainter*"};
4676 static const char* argumentList[] ={"QPainter*"};
4298 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4677 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4299 QPainter* returnValue;
4678 QPainter* returnValue;
@@ -4312,16 +4691,18 if (_wrapper) {
4312 if (result) { Py_DECREF(result); }
4691 if (result) { Py_DECREF(result); }
4313 Py_DECREF(obj);
4692 Py_DECREF(obj);
4314 return returnValue;
4693 return returnValue;
4694 } else {
4695 PyErr_Clear();
4315 }
4696 }
4316 }
4697 }
4317 return SocExplorerPlot::sharedPainter();
4698 return SocExplorerPlot::sharedPainter();
4318 }
4699 }
4319 void PythonQtShell_SocExplorerPlot::showEvent(QShowEvent* arg__1)
4700 void PythonQtShell_SocExplorerPlot::showEvent(QShowEvent* arg__1)
4320 {
4701 {
4321 if (_wrapper) {
4702 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4322 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
4703 static PyObject* name = PyString_FromString("showEvent");
4323 PyErr_Clear();
4704 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4324 if (obj && !PythonQtSlotFunction_Check(obj)) {
4705 if (obj) {
4325 static const char* argumentList[] ={"" , "QShowEvent*"};
4706 static const char* argumentList[] ={"" , "QShowEvent*"};
4326 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4707 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4327 void* args[2] = {NULL, (void*)&arg__1};
4708 void* args[2] = {NULL, (void*)&arg__1};
@@ -4329,16 +4710,18 if (_wrapper) {
4329 if (result) { Py_DECREF(result); }
4710 if (result) { Py_DECREF(result); }
4330 Py_DECREF(obj);
4711 Py_DECREF(obj);
4331 return;
4712 return;
4713 } else {
4714 PyErr_Clear();
4332 }
4715 }
4333 }
4716 }
4334 SocExplorerPlot::showEvent(arg__1);
4717 SocExplorerPlot::showEvent(arg__1);
4335 }
4718 }
4336 QSize PythonQtShell_SocExplorerPlot::sizeHint() const
4719 QSize PythonQtShell_SocExplorerPlot::sizeHint() const
4337 {
4720 {
4338 if (_wrapper) {
4721 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4339 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
4722 static PyObject* name = PyString_FromString("getSizeHint");
4340 PyErr_Clear();
4723 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4341 if (obj && !PythonQtSlotFunction_Check(obj)) {
4724 if (obj) {
4342 static const char* argumentList[] ={"QSize"};
4725 static const char* argumentList[] ={"QSize"};
4343 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4726 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4344 QSize returnValue;
4727 QSize returnValue;
@@ -4357,16 +4740,18 if (_wrapper) {
4357 if (result) { Py_DECREF(result); }
4740 if (result) { Py_DECREF(result); }
4358 Py_DECREF(obj);
4741 Py_DECREF(obj);
4359 return returnValue;
4742 return returnValue;
4743 } else {
4744 PyErr_Clear();
4360 }
4745 }
4361 }
4746 }
4362 return SocExplorerPlot::sizeHint();
4747 return SocExplorerPlot::sizeHint();
4363 }
4748 }
4364 void PythonQtShell_SocExplorerPlot::tabletEvent(QTabletEvent* arg__1)
4749 void PythonQtShell_SocExplorerPlot::tabletEvent(QTabletEvent* arg__1)
4365 {
4750 {
4366 if (_wrapper) {
4751 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4367 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
4752 static PyObject* name = PyString_FromString("tabletEvent");
4368 PyErr_Clear();
4753 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4369 if (obj && !PythonQtSlotFunction_Check(obj)) {
4754 if (obj) {
4370 static const char* argumentList[] ={"" , "QTabletEvent*"};
4755 static const char* argumentList[] ={"" , "QTabletEvent*"};
4371 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4756 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4372 void* args[2] = {NULL, (void*)&arg__1};
4757 void* args[2] = {NULL, (void*)&arg__1};
@@ -4374,16 +4759,18 if (_wrapper) {
4374 if (result) { Py_DECREF(result); }
4759 if (result) { Py_DECREF(result); }
4375 Py_DECREF(obj);
4760 Py_DECREF(obj);
4376 return;
4761 return;
4762 } else {
4763 PyErr_Clear();
4377 }
4764 }
4378 }
4765 }
4379 SocExplorerPlot::tabletEvent(arg__1);
4766 SocExplorerPlot::tabletEvent(arg__1);
4380 }
4767 }
4381 void PythonQtShell_SocExplorerPlot::timerEvent(QTimerEvent* arg__1)
4768 void PythonQtShell_SocExplorerPlot::timerEvent(QTimerEvent* arg__1)
4382 {
4769 {
4383 if (_wrapper) {
4770 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4384 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
4771 static PyObject* name = PyString_FromString("timerEvent");
4385 PyErr_Clear();
4772 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4386 if (obj && !PythonQtSlotFunction_Check(obj)) {
4773 if (obj) {
4387 static const char* argumentList[] ={"" , "QTimerEvent*"};
4774 static const char* argumentList[] ={"" , "QTimerEvent*"};
4388 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4775 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4389 void* args[2] = {NULL, (void*)&arg__1};
4776 void* args[2] = {NULL, (void*)&arg__1};
@@ -4391,16 +4778,18 if (_wrapper) {
4391 if (result) { Py_DECREF(result); }
4778 if (result) { Py_DECREF(result); }
4392 Py_DECREF(obj);
4779 Py_DECREF(obj);
4393 return;
4780 return;
4781 } else {
4782 PyErr_Clear();
4394 }
4783 }
4395 }
4784 }
4396 SocExplorerPlot::timerEvent(arg__1);
4785 SocExplorerPlot::timerEvent(arg__1);
4397 }
4786 }
4398 void PythonQtShell_SocExplorerPlot::wheelEvent(QWheelEvent* arg__1)
4787 void PythonQtShell_SocExplorerPlot::wheelEvent(QWheelEvent* arg__1)
4399 {
4788 {
4400 if (_wrapper) {
4789 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4401 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
4790 static PyObject* name = PyString_FromString("wheelEvent");
4402 PyErr_Clear();
4791 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4403 if (obj && !PythonQtSlotFunction_Check(obj)) {
4792 if (obj) {
4404 static const char* argumentList[] ={"" , "QWheelEvent*"};
4793 static const char* argumentList[] ={"" , "QWheelEvent*"};
4405 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4794 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4406 void* args[2] = {NULL, (void*)&arg__1};
4795 void* args[2] = {NULL, (void*)&arg__1};
@@ -4408,6 +4797,8 if (_wrapper) {
4408 if (result) { Py_DECREF(result); }
4797 if (result) { Py_DECREF(result); }
4409 Py_DECREF(obj);
4798 Py_DECREF(obj);
4410 return;
4799 return;
4800 } else {
4801 PyErr_Clear();
4411 }
4802 }
4412 }
4803 }
4413 SocExplorerPlot::wheelEvent(arg__1);
4804 SocExplorerPlot::wheelEvent(arg__1);
@@ -4549,10 +4940,10 PythonQtShell_TCP_Terminal_Client::~Pyth
4549 }
4940 }
4550 void PythonQtShell_TCP_Terminal_Client::childEvent(QChildEvent* arg__1)
4941 void PythonQtShell_TCP_Terminal_Client::childEvent(QChildEvent* arg__1)
4551 {
4942 {
4552 if (_wrapper) {
4943 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4553 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
4944 static PyObject* name = PyString_FromString("childEvent");
4554 PyErr_Clear();
4945 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4555 if (obj && !PythonQtSlotFunction_Check(obj)) {
4946 if (obj) {
4556 static const char* argumentList[] ={"" , "QChildEvent*"};
4947 static const char* argumentList[] ={"" , "QChildEvent*"};
4557 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4948 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4558 void* args[2] = {NULL, (void*)&arg__1};
4949 void* args[2] = {NULL, (void*)&arg__1};
@@ -4560,16 +4951,18 if (_wrapper) {
4560 if (result) { Py_DECREF(result); }
4951 if (result) { Py_DECREF(result); }
4561 Py_DECREF(obj);
4952 Py_DECREF(obj);
4562 return;
4953 return;
4954 } else {
4955 PyErr_Clear();
4563 }
4956 }
4564 }
4957 }
4565 TCP_Terminal_Client::childEvent(arg__1);
4958 TCP_Terminal_Client::childEvent(arg__1);
4566 }
4959 }
4567 void PythonQtShell_TCP_Terminal_Client::customEvent(QEvent* arg__1)
4960 void PythonQtShell_TCP_Terminal_Client::customEvent(QEvent* arg__1)
4568 {
4961 {
4569 if (_wrapper) {
4962 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4570 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
4963 static PyObject* name = PyString_FromString("customEvent");
4571 PyErr_Clear();
4964 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4572 if (obj && !PythonQtSlotFunction_Check(obj)) {
4965 if (obj) {
4573 static const char* argumentList[] ={"" , "QEvent*"};
4966 static const char* argumentList[] ={"" , "QEvent*"};
4574 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4967 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4575 void* args[2] = {NULL, (void*)&arg__1};
4968 void* args[2] = {NULL, (void*)&arg__1};
@@ -4577,16 +4970,18 if (_wrapper) {
4577 if (result) { Py_DECREF(result); }
4970 if (result) { Py_DECREF(result); }
4578 Py_DECREF(obj);
4971 Py_DECREF(obj);
4579 return;
4972 return;
4973 } else {
4974 PyErr_Clear();
4580 }
4975 }
4581 }
4976 }
4582 TCP_Terminal_Client::customEvent(arg__1);
4977 TCP_Terminal_Client::customEvent(arg__1);
4583 }
4978 }
4584 bool PythonQtShell_TCP_Terminal_Client::event(QEvent* arg__1)
4979 bool PythonQtShell_TCP_Terminal_Client::event(QEvent* arg__1)
4585 {
4980 {
4586 if (_wrapper) {
4981 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4587 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
4982 static PyObject* name = PyString_FromString("event");
4588 PyErr_Clear();
4983 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4589 if (obj && !PythonQtSlotFunction_Check(obj)) {
4984 if (obj) {
4590 static const char* argumentList[] ={"bool" , "QEvent*"};
4985 static const char* argumentList[] ={"bool" , "QEvent*"};
4591 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4986 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4592 bool returnValue;
4987 bool returnValue;
@@ -4605,16 +5000,18 if (_wrapper) {
4605 if (result) { Py_DECREF(result); }
5000 if (result) { Py_DECREF(result); }
4606 Py_DECREF(obj);
5001 Py_DECREF(obj);
4607 return returnValue;
5002 return returnValue;
5003 } else {
5004 PyErr_Clear();
4608 }
5005 }
4609 }
5006 }
4610 return TCP_Terminal_Client::event(arg__1);
5007 return TCP_Terminal_Client::event(arg__1);
4611 }
5008 }
4612 bool PythonQtShell_TCP_Terminal_Client::eventFilter(QObject* arg__1, QEvent* arg__2)
5009 bool PythonQtShell_TCP_Terminal_Client::eventFilter(QObject* arg__1, QEvent* arg__2)
4613 {
5010 {
4614 if (_wrapper) {
5011 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4615 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
5012 static PyObject* name = PyString_FromString("eventFilter");
4616 PyErr_Clear();
5013 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4617 if (obj && !PythonQtSlotFunction_Check(obj)) {
5014 if (obj) {
4618 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5015 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4619 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5016 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4620 bool returnValue;
5017 bool returnValue;
@@ -4633,16 +5030,18 if (_wrapper) {
4633 if (result) { Py_DECREF(result); }
5030 if (result) { Py_DECREF(result); }
4634 Py_DECREF(obj);
5031 Py_DECREF(obj);
4635 return returnValue;
5032 return returnValue;
5033 } else {
5034 PyErr_Clear();
4636 }
5035 }
4637 }
5036 }
4638 return TCP_Terminal_Client::eventFilter(arg__1, arg__2);
5037 return TCP_Terminal_Client::eventFilter(arg__1, arg__2);
4639 }
5038 }
4640 void PythonQtShell_TCP_Terminal_Client::timerEvent(QTimerEvent* arg__1)
5039 void PythonQtShell_TCP_Terminal_Client::timerEvent(QTimerEvent* arg__1)
4641 {
5040 {
4642 if (_wrapper) {
5041 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4643 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
5042 static PyObject* name = PyString_FromString("timerEvent");
4644 PyErr_Clear();
5043 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4645 if (obj && !PythonQtSlotFunction_Check(obj)) {
5044 if (obj) {
4646 static const char* argumentList[] ={"" , "QTimerEvent*"};
5045 static const char* argumentList[] ={"" , "QTimerEvent*"};
4647 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5046 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4648 void* args[2] = {NULL, (void*)&arg__1};
5047 void* args[2] = {NULL, (void*)&arg__1};
@@ -4650,6 +5049,8 if (_wrapper) {
4650 if (result) { Py_DECREF(result); }
5049 if (result) { Py_DECREF(result); }
4651 Py_DECREF(obj);
5050 Py_DECREF(obj);
4652 return;
5051 return;
5052 } else {
5053 PyErr_Clear();
4653 }
5054 }
4654 }
5055 }
4655 TCP_Terminal_Client::timerEvent(arg__1);
5056 TCP_Terminal_Client::timerEvent(arg__1);
@@ -4802,10 +5203,10 PythonQtShell_abstractBinFile::~PythonQt
4802 }
5203 }
4803 void PythonQtShell_abstractBinFile::childEvent(QChildEvent* arg__1)
5204 void PythonQtShell_abstractBinFile::childEvent(QChildEvent* arg__1)
4804 {
5205 {
4805 if (_wrapper) {
5206 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4806 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
5207 static PyObject* name = PyString_FromString("childEvent");
4807 PyErr_Clear();
5208 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4808 if (obj && !PythonQtSlotFunction_Check(obj)) {
5209 if (obj) {
4809 static const char* argumentList[] ={"" , "QChildEvent*"};
5210 static const char* argumentList[] ={"" , "QChildEvent*"};
4810 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5211 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4811 void* args[2] = {NULL, (void*)&arg__1};
5212 void* args[2] = {NULL, (void*)&arg__1};
@@ -4813,16 +5214,18 if (_wrapper) {
4813 if (result) { Py_DECREF(result); }
5214 if (result) { Py_DECREF(result); }
4814 Py_DECREF(obj);
5215 Py_DECREF(obj);
4815 return;
5216 return;
5217 } else {
5218 PyErr_Clear();
4816 }
5219 }
4817 }
5220 }
4818 abstractBinFile::childEvent(arg__1);
5221 abstractBinFile::childEvent(arg__1);
4819 }
5222 }
4820 int PythonQtShell_abstractBinFile::closeFile()
5223 int PythonQtShell_abstractBinFile::closeFile()
4821 {
5224 {
4822 if (_wrapper) {
5225 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4823 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
5226 static PyObject* name = PyString_FromString("closeFile");
4824 PyErr_Clear();
5227 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4825 if (obj && !PythonQtSlotFunction_Check(obj)) {
5228 if (obj) {
4826 static const char* argumentList[] ={"int"};
5229 static const char* argumentList[] ={"int"};
4827 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5230 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4828 int returnValue;
5231 int returnValue;
@@ -4841,16 +5244,18 if (_wrapper) {
4841 if (result) { Py_DECREF(result); }
5244 if (result) { Py_DECREF(result); }
4842 Py_DECREF(obj);
5245 Py_DECREF(obj);
4843 return returnValue;
5246 return returnValue;
5247 } else {
5248 PyErr_Clear();
4844 }
5249 }
4845 }
5250 }
4846 return int();
5251 return int();
4847 }
5252 }
4848 void PythonQtShell_abstractBinFile::customEvent(QEvent* arg__1)
5253 void PythonQtShell_abstractBinFile::customEvent(QEvent* arg__1)
4849 {
5254 {
4850 if (_wrapper) {
5255 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4851 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
5256 static PyObject* name = PyString_FromString("customEvent");
4852 PyErr_Clear();
5257 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4853 if (obj && !PythonQtSlotFunction_Check(obj)) {
5258 if (obj) {
4854 static const char* argumentList[] ={"" , "QEvent*"};
5259 static const char* argumentList[] ={"" , "QEvent*"};
4855 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5260 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4856 void* args[2] = {NULL, (void*)&arg__1};
5261 void* args[2] = {NULL, (void*)&arg__1};
@@ -4858,16 +5263,18 if (_wrapper) {
4858 if (result) { Py_DECREF(result); }
5263 if (result) { Py_DECREF(result); }
4859 Py_DECREF(obj);
5264 Py_DECREF(obj);
4860 return;
5265 return;
5266 } else {
5267 PyErr_Clear();
4861 }
5268 }
4862 }
5269 }
4863 abstractBinFile::customEvent(arg__1);
5270 abstractBinFile::customEvent(arg__1);
4864 }
5271 }
4865 bool PythonQtShell_abstractBinFile::event(QEvent* arg__1)
5272 bool PythonQtShell_abstractBinFile::event(QEvent* arg__1)
4866 {
5273 {
4867 if (_wrapper) {
5274 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4868 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
5275 static PyObject* name = PyString_FromString("event");
4869 PyErr_Clear();
5276 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4870 if (obj && !PythonQtSlotFunction_Check(obj)) {
5277 if (obj) {
4871 static const char* argumentList[] ={"bool" , "QEvent*"};
5278 static const char* argumentList[] ={"bool" , "QEvent*"};
4872 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5279 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4873 bool returnValue;
5280 bool returnValue;
@@ -4886,16 +5293,18 if (_wrapper) {
4886 if (result) { Py_DECREF(result); }
5293 if (result) { Py_DECREF(result); }
4887 Py_DECREF(obj);
5294 Py_DECREF(obj);
4888 return returnValue;
5295 return returnValue;
5296 } else {
5297 PyErr_Clear();
4889 }
5298 }
4890 }
5299 }
4891 return abstractBinFile::event(arg__1);
5300 return abstractBinFile::event(arg__1);
4892 }
5301 }
4893 bool PythonQtShell_abstractBinFile::eventFilter(QObject* arg__1, QEvent* arg__2)
5302 bool PythonQtShell_abstractBinFile::eventFilter(QObject* arg__1, QEvent* arg__2)
4894 {
5303 {
4895 if (_wrapper) {
5304 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4896 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
5305 static PyObject* name = PyString_FromString("eventFilter");
4897 PyErr_Clear();
5306 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4898 if (obj && !PythonQtSlotFunction_Check(obj)) {
5307 if (obj) {
4899 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5308 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4900 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5309 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4901 bool returnValue;
5310 bool returnValue;
@@ -4914,16 +5323,18 if (_wrapper) {
4914 if (result) { Py_DECREF(result); }
5323 if (result) { Py_DECREF(result); }
4915 Py_DECREF(obj);
5324 Py_DECREF(obj);
4916 return returnValue;
5325 return returnValue;
5326 } else {
5327 PyErr_Clear();
4917 }
5328 }
4918 }
5329 }
4919 return abstractBinFile::eventFilter(arg__1, arg__2);
5330 return abstractBinFile::eventFilter(arg__1, arg__2);
4920 }
5331 }
4921 QList<codeFragment* > PythonQtShell_abstractBinFile::getFragments()
5332 QList<codeFragment* > PythonQtShell_abstractBinFile::getFragments()
4922 {
5333 {
4923 if (_wrapper) {
5334 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4924 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
5335 static PyObject* name = PyString_FromString("getFragments");
4925 PyErr_Clear();
5336 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4926 if (obj && !PythonQtSlotFunction_Check(obj)) {
5337 if (obj) {
4927 static const char* argumentList[] ={"QList<codeFragment* >"};
5338 static const char* argumentList[] ={"QList<codeFragment* >"};
4928 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5339 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4929 QList<codeFragment* > returnValue;
5340 QList<codeFragment* > returnValue;
@@ -4942,16 +5353,18 if (_wrapper) {
4942 if (result) { Py_DECREF(result); }
5353 if (result) { Py_DECREF(result); }
4943 Py_DECREF(obj);
5354 Py_DECREF(obj);
4944 return returnValue;
5355 return returnValue;
5356 } else {
5357 PyErr_Clear();
4945 }
5358 }
4946 }
5359 }
4947 return QList<codeFragment* >();
5360 return QList<codeFragment* >();
4948 }
5361 }
4949 bool PythonQtShell_abstractBinFile::isopened()
5362 bool PythonQtShell_abstractBinFile::isopened()
4950 {
5363 {
4951 if (_wrapper) {
5364 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4952 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
5365 static PyObject* name = PyString_FromString("isopened");
4953 PyErr_Clear();
5366 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4954 if (obj && !PythonQtSlotFunction_Check(obj)) {
5367 if (obj) {
4955 static const char* argumentList[] ={"bool"};
5368 static const char* argumentList[] ={"bool"};
4956 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5369 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4957 bool returnValue;
5370 bool returnValue;
@@ -4970,20 +5383,22 if (_wrapper) {
4970 if (result) { Py_DECREF(result); }
5383 if (result) { Py_DECREF(result); }
4971 Py_DECREF(obj);
5384 Py_DECREF(obj);
4972 return returnValue;
5385 return returnValue;
5386 } else {
5387 PyErr_Clear();
4973 }
5388 }
4974 }
5389 }
4975 return bool();
5390 return bool();
4976 }
5391 }
4977 bool PythonQtShell_abstractBinFile::openFile(const QString& File)
5392 bool PythonQtShell_abstractBinFile::openFile(const QString& File0)
4978 {
5393 {
4979 if (_wrapper) {
5394 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4980 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
5395 static PyObject* name = PyString_FromString("openFile");
4981 PyErr_Clear();
5396 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4982 if (obj && !PythonQtSlotFunction_Check(obj)) {
5397 if (obj) {
4983 static const char* argumentList[] ={"bool" , "const QString&"};
5398 static const char* argumentList[] ={"bool" , "const QString&"};
4984 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5399 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4985 bool returnValue;
5400 bool returnValue;
4986 void* args[2] = {NULL, (void*)&File};
5401 void* args[2] = {NULL, (void*)&File0};
4987 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5402 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4988 if (result) {
5403 if (result) {
4989 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5404 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -4998,16 +5413,18 if (_wrapper) {
4998 if (result) { Py_DECREF(result); }
5413 if (result) { Py_DECREF(result); }
4999 Py_DECREF(obj);
5414 Py_DECREF(obj);
5000 return returnValue;
5415 return returnValue;
5416 } else {
5417 PyErr_Clear();
5001 }
5418 }
5002 }
5419 }
5003 return bool();
5420 return bool();
5004 }
5421 }
5005 void PythonQtShell_abstractBinFile::timerEvent(QTimerEvent* arg__1)
5422 void PythonQtShell_abstractBinFile::timerEvent(QTimerEvent* arg__1)
5006 {
5423 {
5007 if (_wrapper) {
5424 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5008 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
5425 static PyObject* name = PyString_FromString("timerEvent");
5009 PyErr_Clear();
5426 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5010 if (obj && !PythonQtSlotFunction_Check(obj)) {
5427 if (obj) {
5011 static const char* argumentList[] ={"" , "QTimerEvent*"};
5428 static const char* argumentList[] ={"" , "QTimerEvent*"};
5012 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5429 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5013 void* args[2] = {NULL, (void*)&arg__1};
5430 void* args[2] = {NULL, (void*)&arg__1};
@@ -5015,20 +5432,22 if (_wrapper) {
5015 if (result) { Py_DECREF(result); }
5432 if (result) { Py_DECREF(result); }
5016 Py_DECREF(obj);
5433 Py_DECREF(obj);
5017 return;
5434 return;
5435 } else {
5436 PyErr_Clear();
5018 }
5437 }
5019 }
5438 }
5020 abstractBinFile::timerEvent(arg__1);
5439 abstractBinFile::timerEvent(arg__1);
5021 }
5440 }
5022 bool PythonQtShell_abstractBinFile::toBinary(const QString& File)
5441 bool PythonQtShell_abstractBinFile::toBinary(const QString& File0)
5023 {
5442 {
5024 if (_wrapper) {
5443 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5025 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
5444 static PyObject* name = PyString_FromString("toBinary");
5026 PyErr_Clear();
5445 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5027 if (obj && !PythonQtSlotFunction_Check(obj)) {
5446 if (obj) {
5028 static const char* argumentList[] ={"bool" , "const QString&"};
5447 static const char* argumentList[] ={"bool" , "const QString&"};
5029 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5448 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5030 bool returnValue;
5449 bool returnValue;
5031 void* args[2] = {NULL, (void*)&File};
5450 void* args[2] = {NULL, (void*)&File0};
5032 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5451 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5033 if (result) {
5452 if (result) {
5034 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5453 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -5043,20 +5462,22 if (_wrapper) {
5043 if (result) { Py_DECREF(result); }
5462 if (result) { Py_DECREF(result); }
5044 Py_DECREF(obj);
5463 Py_DECREF(obj);
5045 return returnValue;
5464 return returnValue;
5465 } else {
5466 PyErr_Clear();
5046 }
5467 }
5047 }
5468 }
5048 return bool();
5469 return bool();
5049 }
5470 }
5050 bool PythonQtShell_abstractBinFile::toSrec(const QString& File)
5471 bool PythonQtShell_abstractBinFile::toSrec(const QString& File0)
5051 {
5472 {
5052 if (_wrapper) {
5473 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5053 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
5474 static PyObject* name = PyString_FromString("toSrec");
5054 PyErr_Clear();
5475 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5055 if (obj && !PythonQtSlotFunction_Check(obj)) {
5476 if (obj) {
5056 static const char* argumentList[] ={"bool" , "const QString&"};
5477 static const char* argumentList[] ={"bool" , "const QString&"};
5057 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5478 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5058 bool returnValue;
5479 bool returnValue;
5059 void* args[2] = {NULL, (void*)&File};
5480 void* args[2] = {NULL, (void*)&File0};
5060 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5481 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5061 if (result) {
5482 if (result) {
5062 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5483 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -5071,6 +5492,8 if (_wrapper) {
5071 if (result) { Py_DECREF(result); }
5492 if (result) { Py_DECREF(result); }
5072 Py_DECREF(obj);
5493 Py_DECREF(obj);
5073 return returnValue;
5494 return returnValue;
5495 } else {
5496 PyErr_Clear();
5074 }
5497 }
5075 }
5498 }
5076 return bool();
5499 return bool();
@@ -5079,6 +5502,36 abstractBinFile* PythonQtWrapper_abstrac
5079 {
5502 {
5080 return new PythonQtShell_abstractBinFile(); }
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 PythonQtShell_abstractBinFileWidget::~PythonQtShell_abstractBinFileWidget() {
5537 PythonQtShell_abstractBinFileWidget::~PythonQtShell_abstractBinFileWidget() {
@@ -5087,10 +5540,10 PythonQtShell_abstractBinFileWidget::~Py
5087 }
5540 }
5088 void PythonQtShell_abstractBinFileWidget::actionEvent(QActionEvent* arg__1)
5541 void PythonQtShell_abstractBinFileWidget::actionEvent(QActionEvent* arg__1)
5089 {
5542 {
5090 if (_wrapper) {
5543 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5091 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
5544 static PyObject* name = PyString_FromString("actionEvent");
5092 PyErr_Clear();
5545 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5093 if (obj && !PythonQtSlotFunction_Check(obj)) {
5546 if (obj) {
5094 static const char* argumentList[] ={"" , "QActionEvent*"};
5547 static const char* argumentList[] ={"" , "QActionEvent*"};
5095 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5548 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5096 void* args[2] = {NULL, (void*)&arg__1};
5549 void* args[2] = {NULL, (void*)&arg__1};
@@ -5098,16 +5551,18 if (_wrapper) {
5098 if (result) { Py_DECREF(result); }
5551 if (result) { Py_DECREF(result); }
5099 Py_DECREF(obj);
5552 Py_DECREF(obj);
5100 return;
5553 return;
5554 } else {
5555 PyErr_Clear();
5101 }
5556 }
5102 }
5557 }
5103 abstractBinFileWidget::actionEvent(arg__1);
5558 abstractBinFileWidget::actionEvent(arg__1);
5104 }
5559 }
5105 void PythonQtShell_abstractBinFileWidget::changeEvent(QEvent* arg__1)
5560 void PythonQtShell_abstractBinFileWidget::changeEvent(QEvent* arg__1)
5106 {
5561 {
5107 if (_wrapper) {
5562 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5108 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
5563 static PyObject* name = PyString_FromString("changeEvent");
5109 PyErr_Clear();
5564 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5110 if (obj && !PythonQtSlotFunction_Check(obj)) {
5565 if (obj) {
5111 static const char* argumentList[] ={"" , "QEvent*"};
5566 static const char* argumentList[] ={"" , "QEvent*"};
5112 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5567 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5113 void* args[2] = {NULL, (void*)&arg__1};
5568 void* args[2] = {NULL, (void*)&arg__1};
@@ -5115,16 +5570,18 if (_wrapper) {
5115 if (result) { Py_DECREF(result); }
5570 if (result) { Py_DECREF(result); }
5116 Py_DECREF(obj);
5571 Py_DECREF(obj);
5117 return;
5572 return;
5573 } else {
5574 PyErr_Clear();
5118 }
5575 }
5119 }
5576 }
5120 abstractBinFileWidget::changeEvent(arg__1);
5577 abstractBinFileWidget::changeEvent(arg__1);
5121 }
5578 }
5122 void PythonQtShell_abstractBinFileWidget::childEvent(QChildEvent* arg__1)
5579 void PythonQtShell_abstractBinFileWidget::childEvent(QChildEvent* arg__1)
5123 {
5580 {
5124 if (_wrapper) {
5581 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5125 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
5582 static PyObject* name = PyString_FromString("childEvent");
5126 PyErr_Clear();
5583 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5127 if (obj && !PythonQtSlotFunction_Check(obj)) {
5584 if (obj) {
5128 static const char* argumentList[] ={"" , "QChildEvent*"};
5585 static const char* argumentList[] ={"" , "QChildEvent*"};
5129 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5586 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5130 void* args[2] = {NULL, (void*)&arg__1};
5587 void* args[2] = {NULL, (void*)&arg__1};
@@ -5132,16 +5589,18 if (_wrapper) {
5132 if (result) { Py_DECREF(result); }
5589 if (result) { Py_DECREF(result); }
5133 Py_DECREF(obj);
5590 Py_DECREF(obj);
5134 return;
5591 return;
5592 } else {
5593 PyErr_Clear();
5135 }
5594 }
5136 }
5595 }
5137 abstractBinFileWidget::childEvent(arg__1);
5596 abstractBinFileWidget::childEvent(arg__1);
5138 }
5597 }
5139 void PythonQtShell_abstractBinFileWidget::closeEvent(QCloseEvent* arg__1)
5598 void PythonQtShell_abstractBinFileWidget::closeEvent(QCloseEvent* arg__1)
5140 {
5599 {
5141 if (_wrapper) {
5600 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5142 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
5601 static PyObject* name = PyString_FromString("closeEvent");
5143 PyErr_Clear();
5602 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5144 if (obj && !PythonQtSlotFunction_Check(obj)) {
5603 if (obj) {
5145 static const char* argumentList[] ={"" , "QCloseEvent*"};
5604 static const char* argumentList[] ={"" , "QCloseEvent*"};
5146 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5605 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5147 void* args[2] = {NULL, (void*)&arg__1};
5606 void* args[2] = {NULL, (void*)&arg__1};
@@ -5149,16 +5608,18 if (_wrapper) {
5149 if (result) { Py_DECREF(result); }
5608 if (result) { Py_DECREF(result); }
5150 Py_DECREF(obj);
5609 Py_DECREF(obj);
5151 return;
5610 return;
5611 } else {
5612 PyErr_Clear();
5152 }
5613 }
5153 }
5614 }
5154 abstractBinFileWidget::closeEvent(arg__1);
5615 abstractBinFileWidget::closeEvent(arg__1);
5155 }
5616 }
5156 void PythonQtShell_abstractBinFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
5617 void PythonQtShell_abstractBinFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
5157 {
5618 {
5158 if (_wrapper) {
5619 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5159 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
5620 static PyObject* name = PyString_FromString("contextMenuEvent");
5160 PyErr_Clear();
5621 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5161 if (obj && !PythonQtSlotFunction_Check(obj)) {
5622 if (obj) {
5162 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
5623 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
5163 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5624 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5164 void* args[2] = {NULL, (void*)&arg__1};
5625 void* args[2] = {NULL, (void*)&arg__1};
@@ -5166,16 +5627,18 if (_wrapper) {
5166 if (result) { Py_DECREF(result); }
5627 if (result) { Py_DECREF(result); }
5167 Py_DECREF(obj);
5628 Py_DECREF(obj);
5168 return;
5629 return;
5630 } else {
5631 PyErr_Clear();
5169 }
5632 }
5170 }
5633 }
5171 abstractBinFileWidget::contextMenuEvent(arg__1);
5634 abstractBinFileWidget::contextMenuEvent(arg__1);
5172 }
5635 }
5173 void PythonQtShell_abstractBinFileWidget::customEvent(QEvent* arg__1)
5636 void PythonQtShell_abstractBinFileWidget::customEvent(QEvent* arg__1)
5174 {
5637 {
5175 if (_wrapper) {
5638 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5176 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
5639 static PyObject* name = PyString_FromString("customEvent");
5177 PyErr_Clear();
5640 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5178 if (obj && !PythonQtSlotFunction_Check(obj)) {
5641 if (obj) {
5179 static const char* argumentList[] ={"" , "QEvent*"};
5642 static const char* argumentList[] ={"" , "QEvent*"};
5180 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5643 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5181 void* args[2] = {NULL, (void*)&arg__1};
5644 void* args[2] = {NULL, (void*)&arg__1};
@@ -5183,16 +5646,18 if (_wrapper) {
5183 if (result) { Py_DECREF(result); }
5646 if (result) { Py_DECREF(result); }
5184 Py_DECREF(obj);
5647 Py_DECREF(obj);
5185 return;
5648 return;
5649 } else {
5650 PyErr_Clear();
5186 }
5651 }
5187 }
5652 }
5188 abstractBinFileWidget::customEvent(arg__1);
5653 abstractBinFileWidget::customEvent(arg__1);
5189 }
5654 }
5190 int PythonQtShell_abstractBinFileWidget::devType() const
5655 int PythonQtShell_abstractBinFileWidget::devType() const
5191 {
5656 {
5192 if (_wrapper) {
5657 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5193 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
5658 static PyObject* name = PyString_FromString("devType");
5194 PyErr_Clear();
5659 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5195 if (obj && !PythonQtSlotFunction_Check(obj)) {
5660 if (obj) {
5196 static const char* argumentList[] ={"int"};
5661 static const char* argumentList[] ={"int"};
5197 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5662 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5198 int returnValue;
5663 int returnValue;
@@ -5211,16 +5676,18 if (_wrapper) {
5211 if (result) { Py_DECREF(result); }
5676 if (result) { Py_DECREF(result); }
5212 Py_DECREF(obj);
5677 Py_DECREF(obj);
5213 return returnValue;
5678 return returnValue;
5679 } else {
5680 PyErr_Clear();
5214 }
5681 }
5215 }
5682 }
5216 return abstractBinFileWidget::devType();
5683 return abstractBinFileWidget::devType();
5217 }
5684 }
5218 void PythonQtShell_abstractBinFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
5685 void PythonQtShell_abstractBinFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
5219 {
5686 {
5220 if (_wrapper) {
5687 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5221 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
5688 static PyObject* name = PyString_FromString("dragEnterEvent");
5222 PyErr_Clear();
5689 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5223 if (obj && !PythonQtSlotFunction_Check(obj)) {
5690 if (obj) {
5224 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
5691 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
5225 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5692 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5226 void* args[2] = {NULL, (void*)&arg__1};
5693 void* args[2] = {NULL, (void*)&arg__1};
@@ -5228,16 +5695,18 if (_wrapper) {
5228 if (result) { Py_DECREF(result); }
5695 if (result) { Py_DECREF(result); }
5229 Py_DECREF(obj);
5696 Py_DECREF(obj);
5230 return;
5697 return;
5698 } else {
5699 PyErr_Clear();
5231 }
5700 }
5232 }
5701 }
5233 abstractBinFileWidget::dragEnterEvent(arg__1);
5702 abstractBinFileWidget::dragEnterEvent(arg__1);
5234 }
5703 }
5235 void PythonQtShell_abstractBinFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
5704 void PythonQtShell_abstractBinFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
5236 {
5705 {
5237 if (_wrapper) {
5706 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5238 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
5707 static PyObject* name = PyString_FromString("dragLeaveEvent");
5239 PyErr_Clear();
5708 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5240 if (obj && !PythonQtSlotFunction_Check(obj)) {
5709 if (obj) {
5241 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
5710 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
5242 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5711 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5243 void* args[2] = {NULL, (void*)&arg__1};
5712 void* args[2] = {NULL, (void*)&arg__1};
@@ -5245,16 +5714,18 if (_wrapper) {
5245 if (result) { Py_DECREF(result); }
5714 if (result) { Py_DECREF(result); }
5246 Py_DECREF(obj);
5715 Py_DECREF(obj);
5247 return;
5716 return;
5717 } else {
5718 PyErr_Clear();
5248 }
5719 }
5249 }
5720 }
5250 abstractBinFileWidget::dragLeaveEvent(arg__1);
5721 abstractBinFileWidget::dragLeaveEvent(arg__1);
5251 }
5722 }
5252 void PythonQtShell_abstractBinFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
5723 void PythonQtShell_abstractBinFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
5253 {
5724 {
5254 if (_wrapper) {
5725 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5255 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
5726 static PyObject* name = PyString_FromString("dragMoveEvent");
5256 PyErr_Clear();
5727 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5257 if (obj && !PythonQtSlotFunction_Check(obj)) {
5728 if (obj) {
5258 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
5729 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
5259 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5730 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5260 void* args[2] = {NULL, (void*)&arg__1};
5731 void* args[2] = {NULL, (void*)&arg__1};
@@ -5262,16 +5733,18 if (_wrapper) {
5262 if (result) { Py_DECREF(result); }
5733 if (result) { Py_DECREF(result); }
5263 Py_DECREF(obj);
5734 Py_DECREF(obj);
5264 return;
5735 return;
5736 } else {
5737 PyErr_Clear();
5265 }
5738 }
5266 }
5739 }
5267 abstractBinFileWidget::dragMoveEvent(arg__1);
5740 abstractBinFileWidget::dragMoveEvent(arg__1);
5268 }
5741 }
5269 void PythonQtShell_abstractBinFileWidget::dropEvent(QDropEvent* arg__1)
5742 void PythonQtShell_abstractBinFileWidget::dropEvent(QDropEvent* arg__1)
5270 {
5743 {
5271 if (_wrapper) {
5744 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5272 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
5745 static PyObject* name = PyString_FromString("dropEvent");
5273 PyErr_Clear();
5746 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5274 if (obj && !PythonQtSlotFunction_Check(obj)) {
5747 if (obj) {
5275 static const char* argumentList[] ={"" , "QDropEvent*"};
5748 static const char* argumentList[] ={"" , "QDropEvent*"};
5276 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5749 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5277 void* args[2] = {NULL, (void*)&arg__1};
5750 void* args[2] = {NULL, (void*)&arg__1};
@@ -5279,16 +5752,18 if (_wrapper) {
5279 if (result) { Py_DECREF(result); }
5752 if (result) { Py_DECREF(result); }
5280 Py_DECREF(obj);
5753 Py_DECREF(obj);
5281 return;
5754 return;
5755 } else {
5756 PyErr_Clear();
5282 }
5757 }
5283 }
5758 }
5284 abstractBinFileWidget::dropEvent(arg__1);
5759 abstractBinFileWidget::dropEvent(arg__1);
5285 }
5760 }
5286 void PythonQtShell_abstractBinFileWidget::enterEvent(QEvent* arg__1)
5761 void PythonQtShell_abstractBinFileWidget::enterEvent(QEvent* arg__1)
5287 {
5762 {
5288 if (_wrapper) {
5763 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5289 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
5764 static PyObject* name = PyString_FromString("enterEvent");
5290 PyErr_Clear();
5765 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5291 if (obj && !PythonQtSlotFunction_Check(obj)) {
5766 if (obj) {
5292 static const char* argumentList[] ={"" , "QEvent*"};
5767 static const char* argumentList[] ={"" , "QEvent*"};
5293 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5768 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5294 void* args[2] = {NULL, (void*)&arg__1};
5769 void* args[2] = {NULL, (void*)&arg__1};
@@ -5296,16 +5771,18 if (_wrapper) {
5296 if (result) { Py_DECREF(result); }
5771 if (result) { Py_DECREF(result); }
5297 Py_DECREF(obj);
5772 Py_DECREF(obj);
5298 return;
5773 return;
5774 } else {
5775 PyErr_Clear();
5299 }
5776 }
5300 }
5777 }
5301 abstractBinFileWidget::enterEvent(arg__1);
5778 abstractBinFileWidget::enterEvent(arg__1);
5302 }
5779 }
5303 bool PythonQtShell_abstractBinFileWidget::event(QEvent* arg__1)
5780 bool PythonQtShell_abstractBinFileWidget::event(QEvent* arg__1)
5304 {
5781 {
5305 if (_wrapper) {
5782 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5306 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
5783 static PyObject* name = PyString_FromString("event");
5307 PyErr_Clear();
5784 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5308 if (obj && !PythonQtSlotFunction_Check(obj)) {
5785 if (obj) {
5309 static const char* argumentList[] ={"bool" , "QEvent*"};
5786 static const char* argumentList[] ={"bool" , "QEvent*"};
5310 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5787 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5311 bool returnValue;
5788 bool returnValue;
@@ -5324,16 +5801,18 if (_wrapper) {
5324 if (result) { Py_DECREF(result); }
5801 if (result) { Py_DECREF(result); }
5325 Py_DECREF(obj);
5802 Py_DECREF(obj);
5326 return returnValue;
5803 return returnValue;
5804 } else {
5805 PyErr_Clear();
5327 }
5806 }
5328 }
5807 }
5329 return abstractBinFileWidget::event(arg__1);
5808 return abstractBinFileWidget::event(arg__1);
5330 }
5809 }
5331 bool PythonQtShell_abstractBinFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
5810 bool PythonQtShell_abstractBinFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
5332 {
5811 {
5333 if (_wrapper) {
5812 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5334 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
5813 static PyObject* name = PyString_FromString("eventFilter");
5335 PyErr_Clear();
5814 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5336 if (obj && !PythonQtSlotFunction_Check(obj)) {
5815 if (obj) {
5337 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5816 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5338 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5817 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5339 bool returnValue;
5818 bool returnValue;
@@ -5352,16 +5831,18 if (_wrapper) {
5352 if (result) { Py_DECREF(result); }
5831 if (result) { Py_DECREF(result); }
5353 Py_DECREF(obj);
5832 Py_DECREF(obj);
5354 return returnValue;
5833 return returnValue;
5834 } else {
5835 PyErr_Clear();
5355 }
5836 }
5356 }
5837 }
5357 return abstractBinFileWidget::eventFilter(arg__1, arg__2);
5838 return abstractBinFileWidget::eventFilter(arg__1, arg__2);
5358 }
5839 }
5359 void PythonQtShell_abstractBinFileWidget::focusInEvent(QFocusEvent* arg__1)
5840 void PythonQtShell_abstractBinFileWidget::focusInEvent(QFocusEvent* arg__1)
5360 {
5841 {
5361 if (_wrapper) {
5842 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5362 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
5843 static PyObject* name = PyString_FromString("focusInEvent");
5363 PyErr_Clear();
5844 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5364 if (obj && !PythonQtSlotFunction_Check(obj)) {
5845 if (obj) {
5365 static const char* argumentList[] ={"" , "QFocusEvent*"};
5846 static const char* argumentList[] ={"" , "QFocusEvent*"};
5366 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5847 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5367 void* args[2] = {NULL, (void*)&arg__1};
5848 void* args[2] = {NULL, (void*)&arg__1};
@@ -5369,20 +5850,22 if (_wrapper) {
5369 if (result) { Py_DECREF(result); }
5850 if (result) { Py_DECREF(result); }
5370 Py_DECREF(obj);
5851 Py_DECREF(obj);
5371 return;
5852 return;
5853 } else {
5854 PyErr_Clear();
5372 }
5855 }
5373 }
5856 }
5374 abstractBinFileWidget::focusInEvent(arg__1);
5857 abstractBinFileWidget::focusInEvent(arg__1);
5375 }
5858 }
5376 bool PythonQtShell_abstractBinFileWidget::focusNextPrevChild(bool next)
5859 bool PythonQtShell_abstractBinFileWidget::focusNextPrevChild(bool next0)
5377 {
5860 {
5378 if (_wrapper) {
5861 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5379 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
5862 static PyObject* name = PyString_FromString("focusNextPrevChild");
5380 PyErr_Clear();
5863 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5381 if (obj && !PythonQtSlotFunction_Check(obj)) {
5864 if (obj) {
5382 static const char* argumentList[] ={"bool" , "bool"};
5865 static const char* argumentList[] ={"bool" , "bool"};
5383 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5866 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5384 bool returnValue;
5867 bool returnValue;
5385 void* args[2] = {NULL, (void*)&next};
5868 void* args[2] = {NULL, (void*)&next0};
5386 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5869 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5387 if (result) {
5870 if (result) {
5388 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5871 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -5397,16 +5880,18 if (_wrapper) {
5397 if (result) { Py_DECREF(result); }
5880 if (result) { Py_DECREF(result); }
5398 Py_DECREF(obj);
5881 Py_DECREF(obj);
5399 return returnValue;
5882 return returnValue;
5400 }
5883 } else {
5401 }
5884 PyErr_Clear();
5402 return abstractBinFileWidget::focusNextPrevChild(next);
5885 }
5886 }
5887 return abstractBinFileWidget::focusNextPrevChild(next0);
5403 }
5888 }
5404 void PythonQtShell_abstractBinFileWidget::focusOutEvent(QFocusEvent* arg__1)
5889 void PythonQtShell_abstractBinFileWidget::focusOutEvent(QFocusEvent* arg__1)
5405 {
5890 {
5406 if (_wrapper) {
5891 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5407 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
5892 static PyObject* name = PyString_FromString("focusOutEvent");
5408 PyErr_Clear();
5893 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5409 if (obj && !PythonQtSlotFunction_Check(obj)) {
5894 if (obj) {
5410 static const char* argumentList[] ={"" , "QFocusEvent*"};
5895 static const char* argumentList[] ={"" , "QFocusEvent*"};
5411 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5896 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5412 void* args[2] = {NULL, (void*)&arg__1};
5897 void* args[2] = {NULL, (void*)&arg__1};
@@ -5414,16 +5899,18 if (_wrapper) {
5414 if (result) { Py_DECREF(result); }
5899 if (result) { Py_DECREF(result); }
5415 Py_DECREF(obj);
5900 Py_DECREF(obj);
5416 return;
5901 return;
5902 } else {
5903 PyErr_Clear();
5417 }
5904 }
5418 }
5905 }
5419 abstractBinFileWidget::focusOutEvent(arg__1);
5906 abstractBinFileWidget::focusOutEvent(arg__1);
5420 }
5907 }
5421 bool PythonQtShell_abstractBinFileWidget::hasHeightForWidth() const
5908 bool PythonQtShell_abstractBinFileWidget::hasHeightForWidth() const
5422 {
5909 {
5423 if (_wrapper) {
5910 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5424 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
5911 static PyObject* name = PyString_FromString("hasHeightForWidth");
5425 PyErr_Clear();
5912 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5426 if (obj && !PythonQtSlotFunction_Check(obj)) {
5913 if (obj) {
5427 static const char* argumentList[] ={"bool"};
5914 static const char* argumentList[] ={"bool"};
5428 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5915 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5429 bool returnValue;
5916 bool returnValue;
@@ -5442,16 +5929,18 if (_wrapper) {
5442 if (result) { Py_DECREF(result); }
5929 if (result) { Py_DECREF(result); }
5443 Py_DECREF(obj);
5930 Py_DECREF(obj);
5444 return returnValue;
5931 return returnValue;
5932 } else {
5933 PyErr_Clear();
5445 }
5934 }
5446 }
5935 }
5447 return abstractBinFileWidget::hasHeightForWidth();
5936 return abstractBinFileWidget::hasHeightForWidth();
5448 }
5937 }
5449 int PythonQtShell_abstractBinFileWidget::heightForWidth(int arg__1) const
5938 int PythonQtShell_abstractBinFileWidget::heightForWidth(int arg__1) const
5450 {
5939 {
5451 if (_wrapper) {
5940 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5452 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
5941 static PyObject* name = PyString_FromString("heightForWidth");
5453 PyErr_Clear();
5942 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5454 if (obj && !PythonQtSlotFunction_Check(obj)) {
5943 if (obj) {
5455 static const char* argumentList[] ={"int" , "int"};
5944 static const char* argumentList[] ={"int" , "int"};
5456 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5945 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5457 int returnValue;
5946 int returnValue;
@@ -5470,16 +5959,18 if (_wrapper) {
5470 if (result) { Py_DECREF(result); }
5959 if (result) { Py_DECREF(result); }
5471 Py_DECREF(obj);
5960 Py_DECREF(obj);
5472 return returnValue;
5961 return returnValue;
5962 } else {
5963 PyErr_Clear();
5473 }
5964 }
5474 }
5965 }
5475 return abstractBinFileWidget::heightForWidth(arg__1);
5966 return abstractBinFileWidget::heightForWidth(arg__1);
5476 }
5967 }
5477 void PythonQtShell_abstractBinFileWidget::hideEvent(QHideEvent* arg__1)
5968 void PythonQtShell_abstractBinFileWidget::hideEvent(QHideEvent* arg__1)
5478 {
5969 {
5479 if (_wrapper) {
5970 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5480 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
5971 static PyObject* name = PyString_FromString("hideEvent");
5481 PyErr_Clear();
5972 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5482 if (obj && !PythonQtSlotFunction_Check(obj)) {
5973 if (obj) {
5483 static const char* argumentList[] ={"" , "QHideEvent*"};
5974 static const char* argumentList[] ={"" , "QHideEvent*"};
5484 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5975 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5485 void* args[2] = {NULL, (void*)&arg__1};
5976 void* args[2] = {NULL, (void*)&arg__1};
@@ -5487,33 +5978,37 if (_wrapper) {
5487 if (result) { Py_DECREF(result); }
5978 if (result) { Py_DECREF(result); }
5488 Py_DECREF(obj);
5979 Py_DECREF(obj);
5489 return;
5980 return;
5981 } else {
5982 PyErr_Clear();
5490 }
5983 }
5491 }
5984 }
5492 abstractBinFileWidget::hideEvent(arg__1);
5985 abstractBinFileWidget::hideEvent(arg__1);
5493 }
5986 }
5494 void PythonQtShell_abstractBinFileWidget::initPainter(QPainter* painter) const
5987 void PythonQtShell_abstractBinFileWidget::initPainter(QPainter* painter0) const
5495 {
5988 {
5496 if (_wrapper) {
5989 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5497 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
5990 static PyObject* name = PyString_FromString("initPainter");
5498 PyErr_Clear();
5991 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5499 if (obj && !PythonQtSlotFunction_Check(obj)) {
5992 if (obj) {
5500 static const char* argumentList[] ={"" , "QPainter*"};
5993 static const char* argumentList[] ={"" , "QPainter*"};
5501 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5994 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5502 void* args[2] = {NULL, (void*)&painter};
5995 void* args[2] = {NULL, (void*)&painter0};
5503 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5996 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5504 if (result) { Py_DECREF(result); }
5997 if (result) { Py_DECREF(result); }
5505 Py_DECREF(obj);
5998 Py_DECREF(obj);
5506 return;
5999 return;
5507 }
6000 } else {
5508 }
6001 PyErr_Clear();
5509 abstractBinFileWidget::initPainter(painter);
6002 }
6003 }
6004 abstractBinFileWidget::initPainter(painter0);
5510 }
6005 }
5511 void PythonQtShell_abstractBinFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
6006 void PythonQtShell_abstractBinFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
5512 {
6007 {
5513 if (_wrapper) {
6008 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5514 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
6009 static PyObject* name = PyString_FromString("inputMethodEvent");
5515 PyErr_Clear();
6010 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5516 if (obj && !PythonQtSlotFunction_Check(obj)) {
6011 if (obj) {
5517 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
6012 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
5518 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6013 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5519 void* args[2] = {NULL, (void*)&arg__1};
6014 void* args[2] = {NULL, (void*)&arg__1};
@@ -5521,16 +6016,18 if (_wrapper) {
5521 if (result) { Py_DECREF(result); }
6016 if (result) { Py_DECREF(result); }
5522 Py_DECREF(obj);
6017 Py_DECREF(obj);
5523 return;
6018 return;
6019 } else {
6020 PyErr_Clear();
5524 }
6021 }
5525 }
6022 }
5526 abstractBinFileWidget::inputMethodEvent(arg__1);
6023 abstractBinFileWidget::inputMethodEvent(arg__1);
5527 }
6024 }
5528 QVariant PythonQtShell_abstractBinFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
6025 QVariant PythonQtShell_abstractBinFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
5529 {
6026 {
5530 if (_wrapper) {
6027 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5531 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
6028 static PyObject* name = PyString_FromString("inputMethodQuery");
5532 PyErr_Clear();
6029 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5533 if (obj && !PythonQtSlotFunction_Check(obj)) {
6030 if (obj) {
5534 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
6031 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
5535 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6032 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5536 QVariant returnValue;
6033 QVariant returnValue;
@@ -5549,16 +6046,18 if (_wrapper) {
5549 if (result) { Py_DECREF(result); }
6046 if (result) { Py_DECREF(result); }
5550 Py_DECREF(obj);
6047 Py_DECREF(obj);
5551 return returnValue;
6048 return returnValue;
6049 } else {
6050 PyErr_Clear();
5552 }
6051 }
5553 }
6052 }
5554 return abstractBinFileWidget::inputMethodQuery(arg__1);
6053 return abstractBinFileWidget::inputMethodQuery(arg__1);
5555 }
6054 }
5556 void PythonQtShell_abstractBinFileWidget::keyPressEvent(QKeyEvent* arg__1)
6055 void PythonQtShell_abstractBinFileWidget::keyPressEvent(QKeyEvent* arg__1)
5557 {
6056 {
5558 if (_wrapper) {
6057 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5559 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
6058 static PyObject* name = PyString_FromString("keyPressEvent");
5560 PyErr_Clear();
6059 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5561 if (obj && !PythonQtSlotFunction_Check(obj)) {
6060 if (obj) {
5562 static const char* argumentList[] ={"" , "QKeyEvent*"};
6061 static const char* argumentList[] ={"" , "QKeyEvent*"};
5563 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6062 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5564 void* args[2] = {NULL, (void*)&arg__1};
6063 void* args[2] = {NULL, (void*)&arg__1};
@@ -5566,16 +6065,18 if (_wrapper) {
5566 if (result) { Py_DECREF(result); }
6065 if (result) { Py_DECREF(result); }
5567 Py_DECREF(obj);
6066 Py_DECREF(obj);
5568 return;
6067 return;
6068 } else {
6069 PyErr_Clear();
5569 }
6070 }
5570 }
6071 }
5571 abstractBinFileWidget::keyPressEvent(arg__1);
6072 abstractBinFileWidget::keyPressEvent(arg__1);
5572 }
6073 }
5573 void PythonQtShell_abstractBinFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
6074 void PythonQtShell_abstractBinFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
5574 {
6075 {
5575 if (_wrapper) {
6076 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5576 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
6077 static PyObject* name = PyString_FromString("keyReleaseEvent");
5577 PyErr_Clear();
6078 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5578 if (obj && !PythonQtSlotFunction_Check(obj)) {
6079 if (obj) {
5579 static const char* argumentList[] ={"" , "QKeyEvent*"};
6080 static const char* argumentList[] ={"" , "QKeyEvent*"};
5580 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6081 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5581 void* args[2] = {NULL, (void*)&arg__1};
6082 void* args[2] = {NULL, (void*)&arg__1};
@@ -5583,16 +6084,18 if (_wrapper) {
5583 if (result) { Py_DECREF(result); }
6084 if (result) { Py_DECREF(result); }
5584 Py_DECREF(obj);
6085 Py_DECREF(obj);
5585 return;
6086 return;
6087 } else {
6088 PyErr_Clear();
5586 }
6089 }
5587 }
6090 }
5588 abstractBinFileWidget::keyReleaseEvent(arg__1);
6091 abstractBinFileWidget::keyReleaseEvent(arg__1);
5589 }
6092 }
5590 void PythonQtShell_abstractBinFileWidget::leaveEvent(QEvent* arg__1)
6093 void PythonQtShell_abstractBinFileWidget::leaveEvent(QEvent* arg__1)
5591 {
6094 {
5592 if (_wrapper) {
6095 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5593 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
6096 static PyObject* name = PyString_FromString("leaveEvent");
5594 PyErr_Clear();
6097 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5595 if (obj && !PythonQtSlotFunction_Check(obj)) {
6098 if (obj) {
5596 static const char* argumentList[] ={"" , "QEvent*"};
6099 static const char* argumentList[] ={"" , "QEvent*"};
5597 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6100 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5598 void* args[2] = {NULL, (void*)&arg__1};
6101 void* args[2] = {NULL, (void*)&arg__1};
@@ -5600,16 +6103,18 if (_wrapper) {
5600 if (result) { Py_DECREF(result); }
6103 if (result) { Py_DECREF(result); }
5601 Py_DECREF(obj);
6104 Py_DECREF(obj);
5602 return;
6105 return;
6106 } else {
6107 PyErr_Clear();
5603 }
6108 }
5604 }
6109 }
5605 abstractBinFileWidget::leaveEvent(arg__1);
6110 abstractBinFileWidget::leaveEvent(arg__1);
5606 }
6111 }
5607 int PythonQtShell_abstractBinFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
6112 int PythonQtShell_abstractBinFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
5608 {
6113 {
5609 if (_wrapper) {
6114 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5610 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
6115 static PyObject* name = PyString_FromString("metric");
5611 PyErr_Clear();
6116 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5612 if (obj && !PythonQtSlotFunction_Check(obj)) {
6117 if (obj) {
5613 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
6118 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
5614 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6119 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5615 int returnValue;
6120 int returnValue;
@@ -5628,16 +6133,18 if (_wrapper) {
5628 if (result) { Py_DECREF(result); }
6133 if (result) { Py_DECREF(result); }
5629 Py_DECREF(obj);
6134 Py_DECREF(obj);
5630 return returnValue;
6135 return returnValue;
6136 } else {
6137 PyErr_Clear();
5631 }
6138 }
5632 }
6139 }
5633 return abstractBinFileWidget::metric(arg__1);
6140 return abstractBinFileWidget::metric(arg__1);
5634 }
6141 }
5635 QSize PythonQtShell_abstractBinFileWidget::minimumSizeHint() const
6142 QSize PythonQtShell_abstractBinFileWidget::minimumSizeHint() const
5636 {
6143 {
5637 if (_wrapper) {
6144 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5638 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
6145 static PyObject* name = PyString_FromString("getMinimumSizeHint");
5639 PyErr_Clear();
6146 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5640 if (obj && !PythonQtSlotFunction_Check(obj)) {
6147 if (obj) {
5641 static const char* argumentList[] ={"QSize"};
6148 static const char* argumentList[] ={"QSize"};
5642 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6149 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5643 QSize returnValue;
6150 QSize returnValue;
@@ -5656,16 +6163,18 if (_wrapper) {
5656 if (result) { Py_DECREF(result); }
6163 if (result) { Py_DECREF(result); }
5657 Py_DECREF(obj);
6164 Py_DECREF(obj);
5658 return returnValue;
6165 return returnValue;
6166 } else {
6167 PyErr_Clear();
5659 }
6168 }
5660 }
6169 }
5661 return abstractBinFileWidget::minimumSizeHint();
6170 return abstractBinFileWidget::minimumSizeHint();
5662 }
6171 }
5663 void PythonQtShell_abstractBinFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
6172 void PythonQtShell_abstractBinFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
5664 {
6173 {
5665 if (_wrapper) {
6174 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5666 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
6175 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
5667 PyErr_Clear();
6176 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5668 if (obj && !PythonQtSlotFunction_Check(obj)) {
6177 if (obj) {
5669 static const char* argumentList[] ={"" , "QMouseEvent*"};
6178 static const char* argumentList[] ={"" , "QMouseEvent*"};
5670 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6179 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5671 void* args[2] = {NULL, (void*)&arg__1};
6180 void* args[2] = {NULL, (void*)&arg__1};
@@ -5673,16 +6182,18 if (_wrapper) {
5673 if (result) { Py_DECREF(result); }
6182 if (result) { Py_DECREF(result); }
5674 Py_DECREF(obj);
6183 Py_DECREF(obj);
5675 return;
6184 return;
6185 } else {
6186 PyErr_Clear();
5676 }
6187 }
5677 }
6188 }
5678 abstractBinFileWidget::mouseDoubleClickEvent(arg__1);
6189 abstractBinFileWidget::mouseDoubleClickEvent(arg__1);
5679 }
6190 }
5680 void PythonQtShell_abstractBinFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
6191 void PythonQtShell_abstractBinFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
5681 {
6192 {
5682 if (_wrapper) {
6193 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5683 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
6194 static PyObject* name = PyString_FromString("mouseMoveEvent");
5684 PyErr_Clear();
6195 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5685 if (obj && !PythonQtSlotFunction_Check(obj)) {
6196 if (obj) {
5686 static const char* argumentList[] ={"" , "QMouseEvent*"};
6197 static const char* argumentList[] ={"" , "QMouseEvent*"};
5687 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6198 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5688 void* args[2] = {NULL, (void*)&arg__1};
6199 void* args[2] = {NULL, (void*)&arg__1};
@@ -5690,16 +6201,18 if (_wrapper) {
5690 if (result) { Py_DECREF(result); }
6201 if (result) { Py_DECREF(result); }
5691 Py_DECREF(obj);
6202 Py_DECREF(obj);
5692 return;
6203 return;
6204 } else {
6205 PyErr_Clear();
5693 }
6206 }
5694 }
6207 }
5695 abstractBinFileWidget::mouseMoveEvent(arg__1);
6208 abstractBinFileWidget::mouseMoveEvent(arg__1);
5696 }
6209 }
5697 void PythonQtShell_abstractBinFileWidget::mousePressEvent(QMouseEvent* arg__1)
6210 void PythonQtShell_abstractBinFileWidget::mousePressEvent(QMouseEvent* arg__1)
5698 {
6211 {
5699 if (_wrapper) {
6212 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5700 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
6213 static PyObject* name = PyString_FromString("mousePressEvent");
5701 PyErr_Clear();
6214 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5702 if (obj && !PythonQtSlotFunction_Check(obj)) {
6215 if (obj) {
5703 static const char* argumentList[] ={"" , "QMouseEvent*"};
6216 static const char* argumentList[] ={"" , "QMouseEvent*"};
5704 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6217 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5705 void* args[2] = {NULL, (void*)&arg__1};
6218 void* args[2] = {NULL, (void*)&arg__1};
@@ -5707,16 +6220,18 if (_wrapper) {
5707 if (result) { Py_DECREF(result); }
6220 if (result) { Py_DECREF(result); }
5708 Py_DECREF(obj);
6221 Py_DECREF(obj);
5709 return;
6222 return;
6223 } else {
6224 PyErr_Clear();
5710 }
6225 }
5711 }
6226 }
5712 abstractBinFileWidget::mousePressEvent(arg__1);
6227 abstractBinFileWidget::mousePressEvent(arg__1);
5713 }
6228 }
5714 void PythonQtShell_abstractBinFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
6229 void PythonQtShell_abstractBinFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
5715 {
6230 {
5716 if (_wrapper) {
6231 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5717 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
6232 static PyObject* name = PyString_FromString("mouseReleaseEvent");
5718 PyErr_Clear();
6233 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5719 if (obj && !PythonQtSlotFunction_Check(obj)) {
6234 if (obj) {
5720 static const char* argumentList[] ={"" , "QMouseEvent*"};
6235 static const char* argumentList[] ={"" , "QMouseEvent*"};
5721 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6236 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5722 void* args[2] = {NULL, (void*)&arg__1};
6237 void* args[2] = {NULL, (void*)&arg__1};
@@ -5724,16 +6239,18 if (_wrapper) {
5724 if (result) { Py_DECREF(result); }
6239 if (result) { Py_DECREF(result); }
5725 Py_DECREF(obj);
6240 Py_DECREF(obj);
5726 return;
6241 return;
6242 } else {
6243 PyErr_Clear();
5727 }
6244 }
5728 }
6245 }
5729 abstractBinFileWidget::mouseReleaseEvent(arg__1);
6246 abstractBinFileWidget::mouseReleaseEvent(arg__1);
5730 }
6247 }
5731 void PythonQtShell_abstractBinFileWidget::moveEvent(QMoveEvent* arg__1)
6248 void PythonQtShell_abstractBinFileWidget::moveEvent(QMoveEvent* arg__1)
5732 {
6249 {
5733 if (_wrapper) {
6250 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5734 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
6251 static PyObject* name = PyString_FromString("moveEvent");
5735 PyErr_Clear();
6252 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5736 if (obj && !PythonQtSlotFunction_Check(obj)) {
6253 if (obj) {
5737 static const char* argumentList[] ={"" , "QMoveEvent*"};
6254 static const char* argumentList[] ={"" , "QMoveEvent*"};
5738 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6255 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5739 void* args[2] = {NULL, (void*)&arg__1};
6256 void* args[2] = {NULL, (void*)&arg__1};
@@ -5741,20 +6258,22 if (_wrapper) {
5741 if (result) { Py_DECREF(result); }
6258 if (result) { Py_DECREF(result); }
5742 Py_DECREF(obj);
6259 Py_DECREF(obj);
5743 return;
6260 return;
6261 } else {
6262 PyErr_Clear();
5744 }
6263 }
5745 }
6264 }
5746 abstractBinFileWidget::moveEvent(arg__1);
6265 abstractBinFileWidget::moveEvent(arg__1);
5747 }
6266 }
5748 bool PythonQtShell_abstractBinFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result)
6267 bool PythonQtShell_abstractBinFileWidget::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
5749 {
6268 {
5750 if (_wrapper) {
6269 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5751 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
6270 static PyObject* name = PyString_FromString("nativeEvent");
5752 PyErr_Clear();
6271 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5753 if (obj && !PythonQtSlotFunction_Check(obj)) {
6272 if (obj) {
5754 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
6273 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
5755 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
6274 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
5756 bool returnValue;
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 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6277 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5759 if (result) {
6278 if (result) {
5760 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6279 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -5769,16 +6288,18 if (_wrapper) {
5769 if (result) { Py_DECREF(result); }
6288 if (result) { Py_DECREF(result); }
5770 Py_DECREF(obj);
6289 Py_DECREF(obj);
5771 return returnValue;
6290 return returnValue;
5772 }
6291 } else {
5773 }
6292 PyErr_Clear();
5774 return abstractBinFileWidget::nativeEvent(eventType, message, result);
6293 }
6294 }
6295 return abstractBinFileWidget::nativeEvent(eventType0, message1, result2);
5775 }
6296 }
5776 QPaintEngine* PythonQtShell_abstractBinFileWidget::paintEngine() const
6297 QPaintEngine* PythonQtShell_abstractBinFileWidget::paintEngine() const
5777 {
6298 {
5778 if (_wrapper) {
6299 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5779 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
6300 static PyObject* name = PyString_FromString("paintEngine");
5780 PyErr_Clear();
6301 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5781 if (obj && !PythonQtSlotFunction_Check(obj)) {
6302 if (obj) {
5782 static const char* argumentList[] ={"QPaintEngine*"};
6303 static const char* argumentList[] ={"QPaintEngine*"};
5783 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6304 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5784 QPaintEngine* returnValue;
6305 QPaintEngine* returnValue;
@@ -5797,16 +6318,18 if (_wrapper) {
5797 if (result) { Py_DECREF(result); }
6318 if (result) { Py_DECREF(result); }
5798 Py_DECREF(obj);
6319 Py_DECREF(obj);
5799 return returnValue;
6320 return returnValue;
6321 } else {
6322 PyErr_Clear();
5800 }
6323 }
5801 }
6324 }
5802 return abstractBinFileWidget::paintEngine();
6325 return abstractBinFileWidget::paintEngine();
5803 }
6326 }
5804 void PythonQtShell_abstractBinFileWidget::paintEvent(QPaintEvent* arg__1)
6327 void PythonQtShell_abstractBinFileWidget::paintEvent(QPaintEvent* arg__1)
5805 {
6328 {
5806 if (_wrapper) {
6329 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5807 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
6330 static PyObject* name = PyString_FromString("paintEvent");
5808 PyErr_Clear();
6331 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5809 if (obj && !PythonQtSlotFunction_Check(obj)) {
6332 if (obj) {
5810 static const char* argumentList[] ={"" , "QPaintEvent*"};
6333 static const char* argumentList[] ={"" , "QPaintEvent*"};
5811 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6334 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5812 void* args[2] = {NULL, (void*)&arg__1};
6335 void* args[2] = {NULL, (void*)&arg__1};
@@ -5814,20 +6337,22 if (_wrapper) {
5814 if (result) { Py_DECREF(result); }
6337 if (result) { Py_DECREF(result); }
5815 Py_DECREF(obj);
6338 Py_DECREF(obj);
5816 return;
6339 return;
6340 } else {
6341 PyErr_Clear();
5817 }
6342 }
5818 }
6343 }
5819 abstractBinFileWidget::paintEvent(arg__1);
6344 abstractBinFileWidget::paintEvent(arg__1);
5820 }
6345 }
5821 QPaintDevice* PythonQtShell_abstractBinFileWidget::redirected(QPoint* offset) const
6346 QPaintDevice* PythonQtShell_abstractBinFileWidget::redirected(QPoint* offset0) const
5822 {
6347 {
5823 if (_wrapper) {
6348 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5824 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
6349 static PyObject* name = PyString_FromString("redirected");
5825 PyErr_Clear();
6350 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5826 if (obj && !PythonQtSlotFunction_Check(obj)) {
6351 if (obj) {
5827 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
6352 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
5828 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6353 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5829 QPaintDevice* returnValue;
6354 QPaintDevice* returnValue;
5830 void* args[2] = {NULL, (void*)&offset};
6355 void* args[2] = {NULL, (void*)&offset0};
5831 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6356 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5832 if (result) {
6357 if (result) {
5833 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6358 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -5842,16 +6367,18 if (_wrapper) {
5842 if (result) { Py_DECREF(result); }
6367 if (result) { Py_DECREF(result); }
5843 Py_DECREF(obj);
6368 Py_DECREF(obj);
5844 return returnValue;
6369 return returnValue;
5845 }
6370 } else {
5846 }
6371 PyErr_Clear();
5847 return abstractBinFileWidget::redirected(offset);
6372 }
6373 }
6374 return abstractBinFileWidget::redirected(offset0);
5848 }
6375 }
5849 void PythonQtShell_abstractBinFileWidget::reloadFile()
6376 void PythonQtShell_abstractBinFileWidget::reloadFile()
5850 {
6377 {
5851 if (_wrapper) {
6378 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5852 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
6379 static PyObject* name = PyString_FromString("reloadFile");
5853 PyErr_Clear();
6380 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5854 if (obj && !PythonQtSlotFunction_Check(obj)) {
6381 if (obj) {
5855 static const char* argumentList[] ={""};
6382 static const char* argumentList[] ={""};
5856 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6383 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5857 void* args[1] = {NULL};
6384 void* args[1] = {NULL};
@@ -5859,16 +6386,18 if (_wrapper) {
5859 if (result) { Py_DECREF(result); }
6386 if (result) { Py_DECREF(result); }
5860 Py_DECREF(obj);
6387 Py_DECREF(obj);
5861 return;
6388 return;
6389 } else {
6390 PyErr_Clear();
5862 }
6391 }
5863 }
6392 }
5864
6393
5865 }
6394 }
5866 void PythonQtShell_abstractBinFileWidget::resizeEvent(QResizeEvent* arg__1)
6395 void PythonQtShell_abstractBinFileWidget::resizeEvent(QResizeEvent* arg__1)
5867 {
6396 {
5868 if (_wrapper) {
6397 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5869 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
6398 static PyObject* name = PyString_FromString("resizeEvent");
5870 PyErr_Clear();
6399 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5871 if (obj && !PythonQtSlotFunction_Check(obj)) {
6400 if (obj) {
5872 static const char* argumentList[] ={"" , "QResizeEvent*"};
6401 static const char* argumentList[] ={"" , "QResizeEvent*"};
5873 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6402 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5874 void* args[2] = {NULL, (void*)&arg__1};
6403 void* args[2] = {NULL, (void*)&arg__1};
@@ -5876,33 +6405,37 if (_wrapper) {
5876 if (result) { Py_DECREF(result); }
6405 if (result) { Py_DECREF(result); }
5877 Py_DECREF(obj);
6406 Py_DECREF(obj);
5878 return;
6407 return;
6408 } else {
6409 PyErr_Clear();
5879 }
6410 }
5880 }
6411 }
5881 abstractBinFileWidget::resizeEvent(arg__1);
6412 abstractBinFileWidget::resizeEvent(arg__1);
5882 }
6413 }
5883 void PythonQtShell_abstractBinFileWidget::setFile(abstractBinFile* file)
6414 void PythonQtShell_abstractBinFileWidget::setFile(abstractBinFile* file0)
5884 {
6415 {
5885 if (_wrapper) {
6416 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5886 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
6417 static PyObject* name = PyString_FromString("setFile");
5887 PyErr_Clear();
6418 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5888 if (obj && !PythonQtSlotFunction_Check(obj)) {
6419 if (obj) {
5889 static const char* argumentList[] ={"" , "abstractBinFile*"};
6420 static const char* argumentList[] ={"" , "abstractBinFile*"};
5890 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6421 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5891 void* args[2] = {NULL, (void*)&file};
6422 void* args[2] = {NULL, (void*)&file0};
5892 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6423 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5893 if (result) { Py_DECREF(result); }
6424 if (result) { Py_DECREF(result); }
5894 Py_DECREF(obj);
6425 Py_DECREF(obj);
5895 return;
6426 return;
6427 } else {
6428 PyErr_Clear();
5896 }
6429 }
5897 }
6430 }
5898
6431
5899 }
6432 }
5900 QPainter* PythonQtShell_abstractBinFileWidget::sharedPainter() const
6433 QPainter* PythonQtShell_abstractBinFileWidget::sharedPainter() const
5901 {
6434 {
5902 if (_wrapper) {
6435 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5903 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
6436 static PyObject* name = PyString_FromString("sharedPainter");
5904 PyErr_Clear();
6437 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5905 if (obj && !PythonQtSlotFunction_Check(obj)) {
6438 if (obj) {
5906 static const char* argumentList[] ={"QPainter*"};
6439 static const char* argumentList[] ={"QPainter*"};
5907 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6440 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5908 QPainter* returnValue;
6441 QPainter* returnValue;
@@ -5921,16 +6454,18 if (_wrapper) {
5921 if (result) { Py_DECREF(result); }
6454 if (result) { Py_DECREF(result); }
5922 Py_DECREF(obj);
6455 Py_DECREF(obj);
5923 return returnValue;
6456 return returnValue;
6457 } else {
6458 PyErr_Clear();
5924 }
6459 }
5925 }
6460 }
5926 return abstractBinFileWidget::sharedPainter();
6461 return abstractBinFileWidget::sharedPainter();
5927 }
6462 }
5928 void PythonQtShell_abstractBinFileWidget::showEvent(QShowEvent* arg__1)
6463 void PythonQtShell_abstractBinFileWidget::showEvent(QShowEvent* arg__1)
5929 {
6464 {
5930 if (_wrapper) {
6465 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5931 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
6466 static PyObject* name = PyString_FromString("showEvent");
5932 PyErr_Clear();
6467 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5933 if (obj && !PythonQtSlotFunction_Check(obj)) {
6468 if (obj) {
5934 static const char* argumentList[] ={"" , "QShowEvent*"};
6469 static const char* argumentList[] ={"" , "QShowEvent*"};
5935 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6470 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5936 void* args[2] = {NULL, (void*)&arg__1};
6471 void* args[2] = {NULL, (void*)&arg__1};
@@ -5938,16 +6473,18 if (_wrapper) {
5938 if (result) { Py_DECREF(result); }
6473 if (result) { Py_DECREF(result); }
5939 Py_DECREF(obj);
6474 Py_DECREF(obj);
5940 return;
6475 return;
6476 } else {
6477 PyErr_Clear();
5941 }
6478 }
5942 }
6479 }
5943 abstractBinFileWidget::showEvent(arg__1);
6480 abstractBinFileWidget::showEvent(arg__1);
5944 }
6481 }
5945 QSize PythonQtShell_abstractBinFileWidget::sizeHint() const
6482 QSize PythonQtShell_abstractBinFileWidget::sizeHint() const
5946 {
6483 {
5947 if (_wrapper) {
6484 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5948 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
6485 static PyObject* name = PyString_FromString("getSizeHint");
5949 PyErr_Clear();
6486 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5950 if (obj && !PythonQtSlotFunction_Check(obj)) {
6487 if (obj) {
5951 static const char* argumentList[] ={"QSize"};
6488 static const char* argumentList[] ={"QSize"};
5952 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6489 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5953 QSize returnValue;
6490 QSize returnValue;
@@ -5966,16 +6503,18 if (_wrapper) {
5966 if (result) { Py_DECREF(result); }
6503 if (result) { Py_DECREF(result); }
5967 Py_DECREF(obj);
6504 Py_DECREF(obj);
5968 return returnValue;
6505 return returnValue;
6506 } else {
6507 PyErr_Clear();
5969 }
6508 }
5970 }
6509 }
5971 return abstractBinFileWidget::sizeHint();
6510 return abstractBinFileWidget::sizeHint();
5972 }
6511 }
5973 void PythonQtShell_abstractBinFileWidget::tabletEvent(QTabletEvent* arg__1)
6512 void PythonQtShell_abstractBinFileWidget::tabletEvent(QTabletEvent* arg__1)
5974 {
6513 {
5975 if (_wrapper) {
6514 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5976 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
6515 static PyObject* name = PyString_FromString("tabletEvent");
5977 PyErr_Clear();
6516 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5978 if (obj && !PythonQtSlotFunction_Check(obj)) {
6517 if (obj) {
5979 static const char* argumentList[] ={"" , "QTabletEvent*"};
6518 static const char* argumentList[] ={"" , "QTabletEvent*"};
5980 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6519 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5981 void* args[2] = {NULL, (void*)&arg__1};
6520 void* args[2] = {NULL, (void*)&arg__1};
@@ -5983,16 +6522,18 if (_wrapper) {
5983 if (result) { Py_DECREF(result); }
6522 if (result) { Py_DECREF(result); }
5984 Py_DECREF(obj);
6523 Py_DECREF(obj);
5985 return;
6524 return;
6525 } else {
6526 PyErr_Clear();
5986 }
6527 }
5987 }
6528 }
5988 abstractBinFileWidget::tabletEvent(arg__1);
6529 abstractBinFileWidget::tabletEvent(arg__1);
5989 }
6530 }
5990 void PythonQtShell_abstractBinFileWidget::timerEvent(QTimerEvent* arg__1)
6531 void PythonQtShell_abstractBinFileWidget::timerEvent(QTimerEvent* arg__1)
5991 {
6532 {
5992 if (_wrapper) {
6533 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5993 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
6534 static PyObject* name = PyString_FromString("timerEvent");
5994 PyErr_Clear();
6535 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5995 if (obj && !PythonQtSlotFunction_Check(obj)) {
6536 if (obj) {
5996 static const char* argumentList[] ={"" , "QTimerEvent*"};
6537 static const char* argumentList[] ={"" , "QTimerEvent*"};
5997 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6538 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5998 void* args[2] = {NULL, (void*)&arg__1};
6539 void* args[2] = {NULL, (void*)&arg__1};
@@ -6000,16 +6541,18 if (_wrapper) {
6000 if (result) { Py_DECREF(result); }
6541 if (result) { Py_DECREF(result); }
6001 Py_DECREF(obj);
6542 Py_DECREF(obj);
6002 return;
6543 return;
6544 } else {
6545 PyErr_Clear();
6003 }
6546 }
6004 }
6547 }
6005 abstractBinFileWidget::timerEvent(arg__1);
6548 abstractBinFileWidget::timerEvent(arg__1);
6006 }
6549 }
6007 void PythonQtShell_abstractBinFileWidget::wheelEvent(QWheelEvent* arg__1)
6550 void PythonQtShell_abstractBinFileWidget::wheelEvent(QWheelEvent* arg__1)
6008 {
6551 {
6009 if (_wrapper) {
6552 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6010 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
6553 static PyObject* name = PyString_FromString("wheelEvent");
6011 PyErr_Clear();
6554 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6012 if (obj && !PythonQtSlotFunction_Check(obj)) {
6555 if (obj) {
6013 static const char* argumentList[] ={"" , "QWheelEvent*"};
6556 static const char* argumentList[] ={"" , "QWheelEvent*"};
6014 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6557 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6015 void* args[2] = {NULL, (void*)&arg__1};
6558 void* args[2] = {NULL, (void*)&arg__1};
@@ -6017,6 +6560,8 if (_wrapper) {
6017 if (result) { Py_DECREF(result); }
6560 if (result) { Py_DECREF(result); }
6018 Py_DECREF(obj);
6561 Py_DECREF(obj);
6019 return;
6562 return;
6563 } else {
6564 PyErr_Clear();
6020 }
6565 }
6021 }
6566 }
6022 abstractBinFileWidget::wheelEvent(arg__1);
6567 abstractBinFileWidget::wheelEvent(arg__1);
@@ -6025,6 +6570,16 abstractBinFileWidget* PythonQtWrapper_a
6025 {
6570 {
6026 return new PythonQtShell_abstractBinFileWidget(parent); }
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 PythonQtShell_binaryFile::~PythonQtShell_binaryFile() {
6585 PythonQtShell_binaryFile::~PythonQtShell_binaryFile() {
@@ -6033,10 +6588,10 PythonQtShell_binaryFile::~PythonQtShell
6033 }
6588 }
6034 int PythonQtShell_binaryFile::closeFile()
6589 int PythonQtShell_binaryFile::closeFile()
6035 {
6590 {
6036 if (_wrapper) {
6591 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6037 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
6592 static PyObject* name = PyString_FromString("closeFile");
6038 PyErr_Clear();
6593 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6039 if (obj && !PythonQtSlotFunction_Check(obj)) {
6594 if (obj) {
6040 static const char* argumentList[] ={"int"};
6595 static const char* argumentList[] ={"int"};
6041 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6596 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6042 int returnValue;
6597 int returnValue;
@@ -6055,16 +6610,18 if (_wrapper) {
6055 if (result) { Py_DECREF(result); }
6610 if (result) { Py_DECREF(result); }
6056 Py_DECREF(obj);
6611 Py_DECREF(obj);
6057 return returnValue;
6612 return returnValue;
6613 } else {
6614 PyErr_Clear();
6058 }
6615 }
6059 }
6616 }
6060 return binaryFile::closeFile();
6617 return binaryFile::closeFile();
6061 }
6618 }
6062 QList<codeFragment* > PythonQtShell_binaryFile::getFragments()
6619 QList<codeFragment* > PythonQtShell_binaryFile::getFragments()
6063 {
6620 {
6064 if (_wrapper) {
6621 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6065 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
6622 static PyObject* name = PyString_FromString("getFragments");
6066 PyErr_Clear();
6623 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6067 if (obj && !PythonQtSlotFunction_Check(obj)) {
6624 if (obj) {
6068 static const char* argumentList[] ={"QList<codeFragment* >"};
6625 static const char* argumentList[] ={"QList<codeFragment* >"};
6069 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6626 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6070 QList<codeFragment* > returnValue;
6627 QList<codeFragment* > returnValue;
@@ -6083,16 +6640,18 if (_wrapper) {
6083 if (result) { Py_DECREF(result); }
6640 if (result) { Py_DECREF(result); }
6084 Py_DECREF(obj);
6641 Py_DECREF(obj);
6085 return returnValue;
6642 return returnValue;
6643 } else {
6644 PyErr_Clear();
6086 }
6645 }
6087 }
6646 }
6088 return binaryFile::getFragments();
6647 return binaryFile::getFragments();
6089 }
6648 }
6090 bool PythonQtShell_binaryFile::isopened()
6649 bool PythonQtShell_binaryFile::isopened()
6091 {
6650 {
6092 if (_wrapper) {
6651 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6093 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
6652 static PyObject* name = PyString_FromString("isopened");
6094 PyErr_Clear();
6653 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6095 if (obj && !PythonQtSlotFunction_Check(obj)) {
6654 if (obj) {
6096 static const char* argumentList[] ={"bool"};
6655 static const char* argumentList[] ={"bool"};
6097 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6656 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6098 bool returnValue;
6657 bool returnValue;
@@ -6111,20 +6670,22 if (_wrapper) {
6111 if (result) { Py_DECREF(result); }
6670 if (result) { Py_DECREF(result); }
6112 Py_DECREF(obj);
6671 Py_DECREF(obj);
6113 return returnValue;
6672 return returnValue;
6673 } else {
6674 PyErr_Clear();
6114 }
6675 }
6115 }
6676 }
6116 return binaryFile::isopened();
6677 return binaryFile::isopened();
6117 }
6678 }
6118 bool PythonQtShell_binaryFile::openFile(const QString& File)
6679 bool PythonQtShell_binaryFile::openFile(const QString& File0)
6119 {
6680 {
6120 if (_wrapper) {
6681 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6121 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
6682 static PyObject* name = PyString_FromString("openFile");
6122 PyErr_Clear();
6683 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6123 if (obj && !PythonQtSlotFunction_Check(obj)) {
6684 if (obj) {
6124 static const char* argumentList[] ={"bool" , "const QString&"};
6685 static const char* argumentList[] ={"bool" , "const QString&"};
6125 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6686 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6126 bool returnValue;
6687 bool returnValue;
6127 void* args[2] = {NULL, (void*)&File};
6688 void* args[2] = {NULL, (void*)&File0};
6128 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6689 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6129 if (result) {
6690 if (result) {
6130 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6691 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -6139,20 +6700,22 if (_wrapper) {
6139 if (result) { Py_DECREF(result); }
6700 if (result) { Py_DECREF(result); }
6140 Py_DECREF(obj);
6701 Py_DECREF(obj);
6141 return returnValue;
6702 return returnValue;
6142 }
6703 } else {
6143 }
6704 PyErr_Clear();
6144 return binaryFile::openFile(File);
6705 }
6145 }
6706 }
6146 bool PythonQtShell_binaryFile::toBinary(const QString& fileName)
6707 return binaryFile::openFile(File0);
6147 {
6708 }
6148 if (_wrapper) {
6709 bool PythonQtShell_binaryFile::toBinary(const QString& fileName0)
6149 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
6710 {
6150 PyErr_Clear();
6711 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6151 if (obj && !PythonQtSlotFunction_Check(obj)) {
6712 static PyObject* name = PyString_FromString("toBinary");
6713 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6714 if (obj) {
6152 static const char* argumentList[] ={"bool" , "const QString&"};
6715 static const char* argumentList[] ={"bool" , "const QString&"};
6153 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6716 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6154 bool returnValue;
6717 bool returnValue;
6155 void* args[2] = {NULL, (void*)&fileName};
6718 void* args[2] = {NULL, (void*)&fileName0};
6156 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6719 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6157 if (result) {
6720 if (result) {
6158 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6721 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -6167,20 +6730,22 if (_wrapper) {
6167 if (result) { Py_DECREF(result); }
6730 if (result) { Py_DECREF(result); }
6168 Py_DECREF(obj);
6731 Py_DECREF(obj);
6169 return returnValue;
6732 return returnValue;
6170 }
6733 } else {
6171 }
6734 PyErr_Clear();
6172 return binaryFile::toBinary(fileName);
6735 }
6173 }
6736 }
6174 bool PythonQtShell_binaryFile::toSrec(const QString& fileName)
6737 return binaryFile::toBinary(fileName0);
6175 {
6738 }
6176 if (_wrapper) {
6739 bool PythonQtShell_binaryFile::toSrec(const QString& fileName0)
6177 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
6740 {
6178 PyErr_Clear();
6741 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6179 if (obj && !PythonQtSlotFunction_Check(obj)) {
6742 static PyObject* name = PyString_FromString("toSrec");
6743 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6744 if (obj) {
6180 static const char* argumentList[] ={"bool" , "const QString&"};
6745 static const char* argumentList[] ={"bool" , "const QString&"};
6181 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6746 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6182 bool returnValue;
6747 bool returnValue;
6183 void* args[2] = {NULL, (void*)&fileName};
6748 void* args[2] = {NULL, (void*)&fileName0};
6184 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6749 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6185 if (result) {
6750 if (result) {
6186 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6751 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -6195,9 +6760,11 if (_wrapper) {
6195 if (result) { Py_DECREF(result); }
6760 if (result) { Py_DECREF(result); }
6196 Py_DECREF(obj);
6761 Py_DECREF(obj);
6197 return returnValue;
6762 return returnValue;
6198 }
6763 } else {
6199 }
6764 PyErr_Clear();
6200 return binaryFile::toSrec(fileName);
6765 }
6766 }
6767 return binaryFile::toSrec(fileName0);
6201 }
6768 }
6202 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile()
6769 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile()
6203 {
6770 {
@@ -6289,10 +6856,10 PythonQtShell_binaryFileWidget::~PythonQ
6289 }
6856 }
6290 void PythonQtShell_binaryFileWidget::reloadFile()
6857 void PythonQtShell_binaryFileWidget::reloadFile()
6291 {
6858 {
6292 if (_wrapper) {
6859 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6293 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
6860 static PyObject* name = PyString_FromString("reloadFile");
6294 PyErr_Clear();
6861 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6295 if (obj && !PythonQtSlotFunction_Check(obj)) {
6862 if (obj) {
6296 static const char* argumentList[] ={""};
6863 static const char* argumentList[] ={""};
6297 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6864 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6298 void* args[1] = {NULL};
6865 void* args[1] = {NULL};
@@ -6300,26 +6867,30 if (_wrapper) {
6300 if (result) { Py_DECREF(result); }
6867 if (result) { Py_DECREF(result); }
6301 Py_DECREF(obj);
6868 Py_DECREF(obj);
6302 return;
6869 return;
6870 } else {
6871 PyErr_Clear();
6303 }
6872 }
6304 }
6873 }
6305 binaryFileWidget::reloadFile();
6874 binaryFileWidget::reloadFile();
6306 }
6875 }
6307 void PythonQtShell_binaryFileWidget::setFile(abstractBinFile* file)
6876 void PythonQtShell_binaryFileWidget::setFile(abstractBinFile* file0)
6308 {
6877 {
6309 if (_wrapper) {
6878 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6310 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
6879 static PyObject* name = PyString_FromString("setFile");
6311 PyErr_Clear();
6880 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6312 if (obj && !PythonQtSlotFunction_Check(obj)) {
6881 if (obj) {
6313 static const char* argumentList[] ={"" , "abstractBinFile*"};
6882 static const char* argumentList[] ={"" , "abstractBinFile*"};
6314 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6883 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6315 void* args[2] = {NULL, (void*)&file};
6884 void* args[2] = {NULL, (void*)&file0};
6316 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6885 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6317 if (result) { Py_DECREF(result); }
6886 if (result) { Py_DECREF(result); }
6318 Py_DECREF(obj);
6887 Py_DECREF(obj);
6319 return;
6888 return;
6320 }
6889 } else {
6321 }
6890 PyErr_Clear();
6322 binaryFileWidget::setFile(file);
6891 }
6892 }
6893 binaryFileWidget::setFile(file0);
6323 }
6894 }
6324 binaryFileWidget* PythonQtWrapper_binaryFileWidget::new_binaryFileWidget(QWidget* parent)
6895 binaryFileWidget* PythonQtWrapper_binaryFileWidget::new_binaryFileWidget(QWidget* parent)
6325 {
6896 {
@@ -6357,10 +6928,10 PythonQtShell_elfFileWidget::~PythonQtSh
6357 }
6928 }
6358 void PythonQtShell_elfFileWidget::reloadFile()
6929 void PythonQtShell_elfFileWidget::reloadFile()
6359 {
6930 {
6360 if (_wrapper) {
6931 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6361 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
6932 static PyObject* name = PyString_FromString("reloadFile");
6362 PyErr_Clear();
6933 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6363 if (obj && !PythonQtSlotFunction_Check(obj)) {
6934 if (obj) {
6364 static const char* argumentList[] ={""};
6935 static const char* argumentList[] ={""};
6365 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6936 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6366 void* args[1] = {NULL};
6937 void* args[1] = {NULL};
@@ -6368,26 +6939,30 if (_wrapper) {
6368 if (result) { Py_DECREF(result); }
6939 if (result) { Py_DECREF(result); }
6369 Py_DECREF(obj);
6940 Py_DECREF(obj);
6370 return;
6941 return;
6942 } else {
6943 PyErr_Clear();
6371 }
6944 }
6372 }
6945 }
6373 elfFileWidget::reloadFile();
6946 elfFileWidget::reloadFile();
6374 }
6947 }
6375 void PythonQtShell_elfFileWidget::setFile(abstractBinFile* file)
6948 void PythonQtShell_elfFileWidget::setFile(abstractBinFile* file0)
6376 {
6949 {
6377 if (_wrapper) {
6950 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6378 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
6951 static PyObject* name = PyString_FromString("setFile");
6379 PyErr_Clear();
6952 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6380 if (obj && !PythonQtSlotFunction_Check(obj)) {
6953 if (obj) {
6381 static const char* argumentList[] ={"" , "abstractBinFile*"};
6954 static const char* argumentList[] ={"" , "abstractBinFile*"};
6382 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6955 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6383 void* args[2] = {NULL, (void*)&file};
6956 void* args[2] = {NULL, (void*)&file0};
6384 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6957 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6385 if (result) { Py_DECREF(result); }
6958 if (result) { Py_DECREF(result); }
6386 Py_DECREF(obj);
6959 Py_DECREF(obj);
6387 return;
6960 return;
6388 }
6961 } else {
6389 }
6962 PyErr_Clear();
6390 elfFileWidget::setFile(file);
6963 }
6964 }
6965 elfFileWidget::setFile(file0);
6391 }
6966 }
6392 elfFileWidget* PythonQtWrapper_elfFileWidget::new_elfFileWidget(QWidget* parent)
6967 elfFileWidget* PythonQtWrapper_elfFileWidget::new_elfFileWidget(QWidget* parent)
6393 {
6968 {
@@ -6411,10 +6986,10 PythonQtShell_elfInfoWdgt::~PythonQtShel
6411 }
6986 }
6412 void PythonQtShell_elfInfoWdgt::actionEvent(QActionEvent* arg__1)
6987 void PythonQtShell_elfInfoWdgt::actionEvent(QActionEvent* arg__1)
6413 {
6988 {
6414 if (_wrapper) {
6989 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6415 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
6990 static PyObject* name = PyString_FromString("actionEvent");
6416 PyErr_Clear();
6991 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6417 if (obj && !PythonQtSlotFunction_Check(obj)) {
6992 if (obj) {
6418 static const char* argumentList[] ={"" , "QActionEvent*"};
6993 static const char* argumentList[] ={"" , "QActionEvent*"};
6419 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6994 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6420 void* args[2] = {NULL, (void*)&arg__1};
6995 void* args[2] = {NULL, (void*)&arg__1};
@@ -6422,16 +6997,18 if (_wrapper) {
6422 if (result) { Py_DECREF(result); }
6997 if (result) { Py_DECREF(result); }
6423 Py_DECREF(obj);
6998 Py_DECREF(obj);
6424 return;
6999 return;
7000 } else {
7001 PyErr_Clear();
6425 }
7002 }
6426 }
7003 }
6427 elfInfoWdgt::actionEvent(arg__1);
7004 elfInfoWdgt::actionEvent(arg__1);
6428 }
7005 }
6429 void PythonQtShell_elfInfoWdgt::changeEvent(QEvent* arg__1)
7006 void PythonQtShell_elfInfoWdgt::changeEvent(QEvent* arg__1)
6430 {
7007 {
6431 if (_wrapper) {
7008 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6432 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
7009 static PyObject* name = PyString_FromString("changeEvent");
6433 PyErr_Clear();
7010 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6434 if (obj && !PythonQtSlotFunction_Check(obj)) {
7011 if (obj) {
6435 static const char* argumentList[] ={"" , "QEvent*"};
7012 static const char* argumentList[] ={"" , "QEvent*"};
6436 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7013 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6437 void* args[2] = {NULL, (void*)&arg__1};
7014 void* args[2] = {NULL, (void*)&arg__1};
@@ -6439,16 +7016,18 if (_wrapper) {
6439 if (result) { Py_DECREF(result); }
7016 if (result) { Py_DECREF(result); }
6440 Py_DECREF(obj);
7017 Py_DECREF(obj);
6441 return;
7018 return;
7019 } else {
7020 PyErr_Clear();
6442 }
7021 }
6443 }
7022 }
6444 elfInfoWdgt::changeEvent(arg__1);
7023 elfInfoWdgt::changeEvent(arg__1);
6445 }
7024 }
6446 void PythonQtShell_elfInfoWdgt::childEvent(QChildEvent* arg__1)
7025 void PythonQtShell_elfInfoWdgt::childEvent(QChildEvent* arg__1)
6447 {
7026 {
6448 if (_wrapper) {
7027 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6449 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
7028 static PyObject* name = PyString_FromString("childEvent");
6450 PyErr_Clear();
7029 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6451 if (obj && !PythonQtSlotFunction_Check(obj)) {
7030 if (obj) {
6452 static const char* argumentList[] ={"" , "QChildEvent*"};
7031 static const char* argumentList[] ={"" , "QChildEvent*"};
6453 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7032 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6454 void* args[2] = {NULL, (void*)&arg__1};
7033 void* args[2] = {NULL, (void*)&arg__1};
@@ -6456,16 +7035,18 if (_wrapper) {
6456 if (result) { Py_DECREF(result); }
7035 if (result) { Py_DECREF(result); }
6457 Py_DECREF(obj);
7036 Py_DECREF(obj);
6458 return;
7037 return;
7038 } else {
7039 PyErr_Clear();
6459 }
7040 }
6460 }
7041 }
6461 elfInfoWdgt::childEvent(arg__1);
7042 elfInfoWdgt::childEvent(arg__1);
6462 }
7043 }
6463 void PythonQtShell_elfInfoWdgt::closeEvent(QCloseEvent* arg__1)
7044 void PythonQtShell_elfInfoWdgt::closeEvent(QCloseEvent* arg__1)
6464 {
7045 {
6465 if (_wrapper) {
7046 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6466 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
7047 static PyObject* name = PyString_FromString("closeEvent");
6467 PyErr_Clear();
7048 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6468 if (obj && !PythonQtSlotFunction_Check(obj)) {
7049 if (obj) {
6469 static const char* argumentList[] ={"" , "QCloseEvent*"};
7050 static const char* argumentList[] ={"" , "QCloseEvent*"};
6470 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7051 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6471 void* args[2] = {NULL, (void*)&arg__1};
7052 void* args[2] = {NULL, (void*)&arg__1};
@@ -6473,16 +7054,18 if (_wrapper) {
6473 if (result) { Py_DECREF(result); }
7054 if (result) { Py_DECREF(result); }
6474 Py_DECREF(obj);
7055 Py_DECREF(obj);
6475 return;
7056 return;
7057 } else {
7058 PyErr_Clear();
6476 }
7059 }
6477 }
7060 }
6478 elfInfoWdgt::closeEvent(arg__1);
7061 elfInfoWdgt::closeEvent(arg__1);
6479 }
7062 }
6480 void PythonQtShell_elfInfoWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
7063 void PythonQtShell_elfInfoWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
6481 {
7064 {
6482 if (_wrapper) {
7065 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6483 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
7066 static PyObject* name = PyString_FromString("contextMenuEvent");
6484 PyErr_Clear();
7067 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6485 if (obj && !PythonQtSlotFunction_Check(obj)) {
7068 if (obj) {
6486 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
7069 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
6487 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7070 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6488 void* args[2] = {NULL, (void*)&arg__1};
7071 void* args[2] = {NULL, (void*)&arg__1};
@@ -6490,16 +7073,18 if (_wrapper) {
6490 if (result) { Py_DECREF(result); }
7073 if (result) { Py_DECREF(result); }
6491 Py_DECREF(obj);
7074 Py_DECREF(obj);
6492 return;
7075 return;
7076 } else {
7077 PyErr_Clear();
6493 }
7078 }
6494 }
7079 }
6495 elfInfoWdgt::contextMenuEvent(arg__1);
7080 elfInfoWdgt::contextMenuEvent(arg__1);
6496 }
7081 }
6497 void PythonQtShell_elfInfoWdgt::customEvent(QEvent* arg__1)
7082 void PythonQtShell_elfInfoWdgt::customEvent(QEvent* arg__1)
6498 {
7083 {
6499 if (_wrapper) {
7084 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6500 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
7085 static PyObject* name = PyString_FromString("customEvent");
6501 PyErr_Clear();
7086 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6502 if (obj && !PythonQtSlotFunction_Check(obj)) {
7087 if (obj) {
6503 static const char* argumentList[] ={"" , "QEvent*"};
7088 static const char* argumentList[] ={"" , "QEvent*"};
6504 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7089 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6505 void* args[2] = {NULL, (void*)&arg__1};
7090 void* args[2] = {NULL, (void*)&arg__1};
@@ -6507,16 +7092,18 if (_wrapper) {
6507 if (result) { Py_DECREF(result); }
7092 if (result) { Py_DECREF(result); }
6508 Py_DECREF(obj);
7093 Py_DECREF(obj);
6509 return;
7094 return;
7095 } else {
7096 PyErr_Clear();
6510 }
7097 }
6511 }
7098 }
6512 elfInfoWdgt::customEvent(arg__1);
7099 elfInfoWdgt::customEvent(arg__1);
6513 }
7100 }
6514 int PythonQtShell_elfInfoWdgt::devType() const
7101 int PythonQtShell_elfInfoWdgt::devType() const
6515 {
7102 {
6516 if (_wrapper) {
7103 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6517 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
7104 static PyObject* name = PyString_FromString("devType");
6518 PyErr_Clear();
7105 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6519 if (obj && !PythonQtSlotFunction_Check(obj)) {
7106 if (obj) {
6520 static const char* argumentList[] ={"int"};
7107 static const char* argumentList[] ={"int"};
6521 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7108 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6522 int returnValue;
7109 int returnValue;
@@ -6535,16 +7122,18 if (_wrapper) {
6535 if (result) { Py_DECREF(result); }
7122 if (result) { Py_DECREF(result); }
6536 Py_DECREF(obj);
7123 Py_DECREF(obj);
6537 return returnValue;
7124 return returnValue;
7125 } else {
7126 PyErr_Clear();
6538 }
7127 }
6539 }
7128 }
6540 return elfInfoWdgt::devType();
7129 return elfInfoWdgt::devType();
6541 }
7130 }
6542 void PythonQtShell_elfInfoWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
7131 void PythonQtShell_elfInfoWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
6543 {
7132 {
6544 if (_wrapper) {
7133 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6545 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
7134 static PyObject* name = PyString_FromString("dragEnterEvent");
6546 PyErr_Clear();
7135 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6547 if (obj && !PythonQtSlotFunction_Check(obj)) {
7136 if (obj) {
6548 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
7137 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
6549 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7138 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6550 void* args[2] = {NULL, (void*)&arg__1};
7139 void* args[2] = {NULL, (void*)&arg__1};
@@ -6552,16 +7141,18 if (_wrapper) {
6552 if (result) { Py_DECREF(result); }
7141 if (result) { Py_DECREF(result); }
6553 Py_DECREF(obj);
7142 Py_DECREF(obj);
6554 return;
7143 return;
7144 } else {
7145 PyErr_Clear();
6555 }
7146 }
6556 }
7147 }
6557 elfInfoWdgt::dragEnterEvent(arg__1);
7148 elfInfoWdgt::dragEnterEvent(arg__1);
6558 }
7149 }
6559 void PythonQtShell_elfInfoWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
7150 void PythonQtShell_elfInfoWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
6560 {
7151 {
6561 if (_wrapper) {
7152 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6562 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
7153 static PyObject* name = PyString_FromString("dragLeaveEvent");
6563 PyErr_Clear();
7154 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6564 if (obj && !PythonQtSlotFunction_Check(obj)) {
7155 if (obj) {
6565 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
7156 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
6566 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7157 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6567 void* args[2] = {NULL, (void*)&arg__1};
7158 void* args[2] = {NULL, (void*)&arg__1};
@@ -6569,16 +7160,18 if (_wrapper) {
6569 if (result) { Py_DECREF(result); }
7160 if (result) { Py_DECREF(result); }
6570 Py_DECREF(obj);
7161 Py_DECREF(obj);
6571 return;
7162 return;
7163 } else {
7164 PyErr_Clear();
6572 }
7165 }
6573 }
7166 }
6574 elfInfoWdgt::dragLeaveEvent(arg__1);
7167 elfInfoWdgt::dragLeaveEvent(arg__1);
6575 }
7168 }
6576 void PythonQtShell_elfInfoWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
7169 void PythonQtShell_elfInfoWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
6577 {
7170 {
6578 if (_wrapper) {
7171 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6579 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
7172 static PyObject* name = PyString_FromString("dragMoveEvent");
6580 PyErr_Clear();
7173 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6581 if (obj && !PythonQtSlotFunction_Check(obj)) {
7174 if (obj) {
6582 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
7175 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
6583 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7176 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6584 void* args[2] = {NULL, (void*)&arg__1};
7177 void* args[2] = {NULL, (void*)&arg__1};
@@ -6586,16 +7179,18 if (_wrapper) {
6586 if (result) { Py_DECREF(result); }
7179 if (result) { Py_DECREF(result); }
6587 Py_DECREF(obj);
7180 Py_DECREF(obj);
6588 return;
7181 return;
7182 } else {
7183 PyErr_Clear();
6589 }
7184 }
6590 }
7185 }
6591 elfInfoWdgt::dragMoveEvent(arg__1);
7186 elfInfoWdgt::dragMoveEvent(arg__1);
6592 }
7187 }
6593 void PythonQtShell_elfInfoWdgt::dropEvent(QDropEvent* arg__1)
7188 void PythonQtShell_elfInfoWdgt::dropEvent(QDropEvent* arg__1)
6594 {
7189 {
6595 if (_wrapper) {
7190 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6596 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
7191 static PyObject* name = PyString_FromString("dropEvent");
6597 PyErr_Clear();
7192 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6598 if (obj && !PythonQtSlotFunction_Check(obj)) {
7193 if (obj) {
6599 static const char* argumentList[] ={"" , "QDropEvent*"};
7194 static const char* argumentList[] ={"" , "QDropEvent*"};
6600 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7195 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6601 void* args[2] = {NULL, (void*)&arg__1};
7196 void* args[2] = {NULL, (void*)&arg__1};
@@ -6603,16 +7198,18 if (_wrapper) {
6603 if (result) { Py_DECREF(result); }
7198 if (result) { Py_DECREF(result); }
6604 Py_DECREF(obj);
7199 Py_DECREF(obj);
6605 return;
7200 return;
7201 } else {
7202 PyErr_Clear();
6606 }
7203 }
6607 }
7204 }
6608 elfInfoWdgt::dropEvent(arg__1);
7205 elfInfoWdgt::dropEvent(arg__1);
6609 }
7206 }
6610 void PythonQtShell_elfInfoWdgt::enterEvent(QEvent* arg__1)
7207 void PythonQtShell_elfInfoWdgt::enterEvent(QEvent* arg__1)
6611 {
7208 {
6612 if (_wrapper) {
7209 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6613 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
7210 static PyObject* name = PyString_FromString("enterEvent");
6614 PyErr_Clear();
7211 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6615 if (obj && !PythonQtSlotFunction_Check(obj)) {
7212 if (obj) {
6616 static const char* argumentList[] ={"" , "QEvent*"};
7213 static const char* argumentList[] ={"" , "QEvent*"};
6617 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7214 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6618 void* args[2] = {NULL, (void*)&arg__1};
7215 void* args[2] = {NULL, (void*)&arg__1};
@@ -6620,16 +7217,18 if (_wrapper) {
6620 if (result) { Py_DECREF(result); }
7217 if (result) { Py_DECREF(result); }
6621 Py_DECREF(obj);
7218 Py_DECREF(obj);
6622 return;
7219 return;
7220 } else {
7221 PyErr_Clear();
6623 }
7222 }
6624 }
7223 }
6625 elfInfoWdgt::enterEvent(arg__1);
7224 elfInfoWdgt::enterEvent(arg__1);
6626 }
7225 }
6627 bool PythonQtShell_elfInfoWdgt::event(QEvent* arg__1)
7226 bool PythonQtShell_elfInfoWdgt::event(QEvent* arg__1)
6628 {
7227 {
6629 if (_wrapper) {
7228 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6630 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
7229 static PyObject* name = PyString_FromString("event");
6631 PyErr_Clear();
7230 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6632 if (obj && !PythonQtSlotFunction_Check(obj)) {
7231 if (obj) {
6633 static const char* argumentList[] ={"bool" , "QEvent*"};
7232 static const char* argumentList[] ={"bool" , "QEvent*"};
6634 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7233 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6635 bool returnValue;
7234 bool returnValue;
@@ -6648,16 +7247,18 if (_wrapper) {
6648 if (result) { Py_DECREF(result); }
7247 if (result) { Py_DECREF(result); }
6649 Py_DECREF(obj);
7248 Py_DECREF(obj);
6650 return returnValue;
7249 return returnValue;
7250 } else {
7251 PyErr_Clear();
6651 }
7252 }
6652 }
7253 }
6653 return elfInfoWdgt::event(arg__1);
7254 return elfInfoWdgt::event(arg__1);
6654 }
7255 }
6655 bool PythonQtShell_elfInfoWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
7256 bool PythonQtShell_elfInfoWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
6656 {
7257 {
6657 if (_wrapper) {
7258 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6658 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
7259 static PyObject* name = PyString_FromString("eventFilter");
6659 PyErr_Clear();
7260 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6660 if (obj && !PythonQtSlotFunction_Check(obj)) {
7261 if (obj) {
6661 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
7262 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
6662 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
7263 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
6663 bool returnValue;
7264 bool returnValue;
@@ -6676,16 +7277,18 if (_wrapper) {
6676 if (result) { Py_DECREF(result); }
7277 if (result) { Py_DECREF(result); }
6677 Py_DECREF(obj);
7278 Py_DECREF(obj);
6678 return returnValue;
7279 return returnValue;
7280 } else {
7281 PyErr_Clear();
6679 }
7282 }
6680 }
7283 }
6681 return elfInfoWdgt::eventFilter(arg__1, arg__2);
7284 return elfInfoWdgt::eventFilter(arg__1, arg__2);
6682 }
7285 }
6683 void PythonQtShell_elfInfoWdgt::focusInEvent(QFocusEvent* arg__1)
7286 void PythonQtShell_elfInfoWdgt::focusInEvent(QFocusEvent* arg__1)
6684 {
7287 {
6685 if (_wrapper) {
7288 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6686 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
7289 static PyObject* name = PyString_FromString("focusInEvent");
6687 PyErr_Clear();
7290 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6688 if (obj && !PythonQtSlotFunction_Check(obj)) {
7291 if (obj) {
6689 static const char* argumentList[] ={"" , "QFocusEvent*"};
7292 static const char* argumentList[] ={"" , "QFocusEvent*"};
6690 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7293 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6691 void* args[2] = {NULL, (void*)&arg__1};
7294 void* args[2] = {NULL, (void*)&arg__1};
@@ -6693,20 +7296,22 if (_wrapper) {
6693 if (result) { Py_DECREF(result); }
7296 if (result) { Py_DECREF(result); }
6694 Py_DECREF(obj);
7297 Py_DECREF(obj);
6695 return;
7298 return;
7299 } else {
7300 PyErr_Clear();
6696 }
7301 }
6697 }
7302 }
6698 elfInfoWdgt::focusInEvent(arg__1);
7303 elfInfoWdgt::focusInEvent(arg__1);
6699 }
7304 }
6700 bool PythonQtShell_elfInfoWdgt::focusNextPrevChild(bool next)
7305 bool PythonQtShell_elfInfoWdgt::focusNextPrevChild(bool next0)
6701 {
7306 {
6702 if (_wrapper) {
7307 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6703 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
7308 static PyObject* name = PyString_FromString("focusNextPrevChild");
6704 PyErr_Clear();
7309 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6705 if (obj && !PythonQtSlotFunction_Check(obj)) {
7310 if (obj) {
6706 static const char* argumentList[] ={"bool" , "bool"};
7311 static const char* argumentList[] ={"bool" , "bool"};
6707 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7312 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6708 bool returnValue;
7313 bool returnValue;
6709 void* args[2] = {NULL, (void*)&next};
7314 void* args[2] = {NULL, (void*)&next0};
6710 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7315 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6711 if (result) {
7316 if (result) {
6712 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7317 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -6721,16 +7326,18 if (_wrapper) {
6721 if (result) { Py_DECREF(result); }
7326 if (result) { Py_DECREF(result); }
6722 Py_DECREF(obj);
7327 Py_DECREF(obj);
6723 return returnValue;
7328 return returnValue;
6724 }
7329 } else {
6725 }
7330 PyErr_Clear();
6726 return elfInfoWdgt::focusNextPrevChild(next);
7331 }
7332 }
7333 return elfInfoWdgt::focusNextPrevChild(next0);
6727 }
7334 }
6728 void PythonQtShell_elfInfoWdgt::focusOutEvent(QFocusEvent* arg__1)
7335 void PythonQtShell_elfInfoWdgt::focusOutEvent(QFocusEvent* arg__1)
6729 {
7336 {
6730 if (_wrapper) {
7337 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6731 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
7338 static PyObject* name = PyString_FromString("focusOutEvent");
6732 PyErr_Clear();
7339 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6733 if (obj && !PythonQtSlotFunction_Check(obj)) {
7340 if (obj) {
6734 static const char* argumentList[] ={"" , "QFocusEvent*"};
7341 static const char* argumentList[] ={"" , "QFocusEvent*"};
6735 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7342 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6736 void* args[2] = {NULL, (void*)&arg__1};
7343 void* args[2] = {NULL, (void*)&arg__1};
@@ -6738,16 +7345,18 if (_wrapper) {
6738 if (result) { Py_DECREF(result); }
7345 if (result) { Py_DECREF(result); }
6739 Py_DECREF(obj);
7346 Py_DECREF(obj);
6740 return;
7347 return;
7348 } else {
7349 PyErr_Clear();
6741 }
7350 }
6742 }
7351 }
6743 elfInfoWdgt::focusOutEvent(arg__1);
7352 elfInfoWdgt::focusOutEvent(arg__1);
6744 }
7353 }
6745 bool PythonQtShell_elfInfoWdgt::hasHeightForWidth() const
7354 bool PythonQtShell_elfInfoWdgt::hasHeightForWidth() const
6746 {
7355 {
6747 if (_wrapper) {
7356 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6748 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
7357 static PyObject* name = PyString_FromString("hasHeightForWidth");
6749 PyErr_Clear();
7358 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6750 if (obj && !PythonQtSlotFunction_Check(obj)) {
7359 if (obj) {
6751 static const char* argumentList[] ={"bool"};
7360 static const char* argumentList[] ={"bool"};
6752 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7361 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6753 bool returnValue;
7362 bool returnValue;
@@ -6766,16 +7375,18 if (_wrapper) {
6766 if (result) { Py_DECREF(result); }
7375 if (result) { Py_DECREF(result); }
6767 Py_DECREF(obj);
7376 Py_DECREF(obj);
6768 return returnValue;
7377 return returnValue;
7378 } else {
7379 PyErr_Clear();
6769 }
7380 }
6770 }
7381 }
6771 return elfInfoWdgt::hasHeightForWidth();
7382 return elfInfoWdgt::hasHeightForWidth();
6772 }
7383 }
6773 int PythonQtShell_elfInfoWdgt::heightForWidth(int arg__1) const
7384 int PythonQtShell_elfInfoWdgt::heightForWidth(int arg__1) const
6774 {
7385 {
6775 if (_wrapper) {
7386 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6776 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
7387 static PyObject* name = PyString_FromString("heightForWidth");
6777 PyErr_Clear();
7388 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6778 if (obj && !PythonQtSlotFunction_Check(obj)) {
7389 if (obj) {
6779 static const char* argumentList[] ={"int" , "int"};
7390 static const char* argumentList[] ={"int" , "int"};
6780 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7391 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6781 int returnValue;
7392 int returnValue;
@@ -6794,16 +7405,18 if (_wrapper) {
6794 if (result) { Py_DECREF(result); }
7405 if (result) { Py_DECREF(result); }
6795 Py_DECREF(obj);
7406 Py_DECREF(obj);
6796 return returnValue;
7407 return returnValue;
7408 } else {
7409 PyErr_Clear();
6797 }
7410 }
6798 }
7411 }
6799 return elfInfoWdgt::heightForWidth(arg__1);
7412 return elfInfoWdgt::heightForWidth(arg__1);
6800 }
7413 }
6801 void PythonQtShell_elfInfoWdgt::hideEvent(QHideEvent* arg__1)
7414 void PythonQtShell_elfInfoWdgt::hideEvent(QHideEvent* arg__1)
6802 {
7415 {
6803 if (_wrapper) {
7416 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6804 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
7417 static PyObject* name = PyString_FromString("hideEvent");
6805 PyErr_Clear();
7418 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6806 if (obj && !PythonQtSlotFunction_Check(obj)) {
7419 if (obj) {
6807 static const char* argumentList[] ={"" , "QHideEvent*"};
7420 static const char* argumentList[] ={"" , "QHideEvent*"};
6808 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7421 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6809 void* args[2] = {NULL, (void*)&arg__1};
7422 void* args[2] = {NULL, (void*)&arg__1};
@@ -6811,33 +7424,37 if (_wrapper) {
6811 if (result) { Py_DECREF(result); }
7424 if (result) { Py_DECREF(result); }
6812 Py_DECREF(obj);
7425 Py_DECREF(obj);
6813 return;
7426 return;
7427 } else {
7428 PyErr_Clear();
6814 }
7429 }
6815 }
7430 }
6816 elfInfoWdgt::hideEvent(arg__1);
7431 elfInfoWdgt::hideEvent(arg__1);
6817 }
7432 }
6818 void PythonQtShell_elfInfoWdgt::initPainter(QPainter* painter) const
7433 void PythonQtShell_elfInfoWdgt::initPainter(QPainter* painter0) const
6819 {
7434 {
6820 if (_wrapper) {
7435 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6821 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
7436 static PyObject* name = PyString_FromString("initPainter");
6822 PyErr_Clear();
7437 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6823 if (obj && !PythonQtSlotFunction_Check(obj)) {
7438 if (obj) {
6824 static const char* argumentList[] ={"" , "QPainter*"};
7439 static const char* argumentList[] ={"" , "QPainter*"};
6825 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7440 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6826 void* args[2] = {NULL, (void*)&painter};
7441 void* args[2] = {NULL, (void*)&painter0};
6827 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7442 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6828 if (result) { Py_DECREF(result); }
7443 if (result) { Py_DECREF(result); }
6829 Py_DECREF(obj);
7444 Py_DECREF(obj);
6830 return;
7445 return;
6831 }
7446 } else {
6832 }
7447 PyErr_Clear();
6833 elfInfoWdgt::initPainter(painter);
7448 }
7449 }
7450 elfInfoWdgt::initPainter(painter0);
6834 }
7451 }
6835 void PythonQtShell_elfInfoWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
7452 void PythonQtShell_elfInfoWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
6836 {
7453 {
6837 if (_wrapper) {
7454 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6838 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
7455 static PyObject* name = PyString_FromString("inputMethodEvent");
6839 PyErr_Clear();
7456 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6840 if (obj && !PythonQtSlotFunction_Check(obj)) {
7457 if (obj) {
6841 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
7458 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
6842 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7459 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6843 void* args[2] = {NULL, (void*)&arg__1};
7460 void* args[2] = {NULL, (void*)&arg__1};
@@ -6845,16 +7462,18 if (_wrapper) {
6845 if (result) { Py_DECREF(result); }
7462 if (result) { Py_DECREF(result); }
6846 Py_DECREF(obj);
7463 Py_DECREF(obj);
6847 return;
7464 return;
7465 } else {
7466 PyErr_Clear();
6848 }
7467 }
6849 }
7468 }
6850 elfInfoWdgt::inputMethodEvent(arg__1);
7469 elfInfoWdgt::inputMethodEvent(arg__1);
6851 }
7470 }
6852 QVariant PythonQtShell_elfInfoWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
7471 QVariant PythonQtShell_elfInfoWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
6853 {
7472 {
6854 if (_wrapper) {
7473 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6855 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
7474 static PyObject* name = PyString_FromString("inputMethodQuery");
6856 PyErr_Clear();
7475 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6857 if (obj && !PythonQtSlotFunction_Check(obj)) {
7476 if (obj) {
6858 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
7477 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
6859 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7478 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6860 QVariant returnValue;
7479 QVariant returnValue;
@@ -6873,16 +7492,18 if (_wrapper) {
6873 if (result) { Py_DECREF(result); }
7492 if (result) { Py_DECREF(result); }
6874 Py_DECREF(obj);
7493 Py_DECREF(obj);
6875 return returnValue;
7494 return returnValue;
7495 } else {
7496 PyErr_Clear();
6876 }
7497 }
6877 }
7498 }
6878 return elfInfoWdgt::inputMethodQuery(arg__1);
7499 return elfInfoWdgt::inputMethodQuery(arg__1);
6879 }
7500 }
6880 void PythonQtShell_elfInfoWdgt::keyPressEvent(QKeyEvent* arg__1)
7501 void PythonQtShell_elfInfoWdgt::keyPressEvent(QKeyEvent* arg__1)
6881 {
7502 {
6882 if (_wrapper) {
7503 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6883 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
7504 static PyObject* name = PyString_FromString("keyPressEvent");
6884 PyErr_Clear();
7505 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6885 if (obj && !PythonQtSlotFunction_Check(obj)) {
7506 if (obj) {
6886 static const char* argumentList[] ={"" , "QKeyEvent*"};
7507 static const char* argumentList[] ={"" , "QKeyEvent*"};
6887 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7508 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6888 void* args[2] = {NULL, (void*)&arg__1};
7509 void* args[2] = {NULL, (void*)&arg__1};
@@ -6890,16 +7511,18 if (_wrapper) {
6890 if (result) { Py_DECREF(result); }
7511 if (result) { Py_DECREF(result); }
6891 Py_DECREF(obj);
7512 Py_DECREF(obj);
6892 return;
7513 return;
7514 } else {
7515 PyErr_Clear();
6893 }
7516 }
6894 }
7517 }
6895 elfInfoWdgt::keyPressEvent(arg__1);
7518 elfInfoWdgt::keyPressEvent(arg__1);
6896 }
7519 }
6897 void PythonQtShell_elfInfoWdgt::keyReleaseEvent(QKeyEvent* arg__1)
7520 void PythonQtShell_elfInfoWdgt::keyReleaseEvent(QKeyEvent* arg__1)
6898 {
7521 {
6899 if (_wrapper) {
7522 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6900 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
7523 static PyObject* name = PyString_FromString("keyReleaseEvent");
6901 PyErr_Clear();
7524 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6902 if (obj && !PythonQtSlotFunction_Check(obj)) {
7525 if (obj) {
6903 static const char* argumentList[] ={"" , "QKeyEvent*"};
7526 static const char* argumentList[] ={"" , "QKeyEvent*"};
6904 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7527 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6905 void* args[2] = {NULL, (void*)&arg__1};
7528 void* args[2] = {NULL, (void*)&arg__1};
@@ -6907,16 +7530,18 if (_wrapper) {
6907 if (result) { Py_DECREF(result); }
7530 if (result) { Py_DECREF(result); }
6908 Py_DECREF(obj);
7531 Py_DECREF(obj);
6909 return;
7532 return;
7533 } else {
7534 PyErr_Clear();
6910 }
7535 }
6911 }
7536 }
6912 elfInfoWdgt::keyReleaseEvent(arg__1);
7537 elfInfoWdgt::keyReleaseEvent(arg__1);
6913 }
7538 }
6914 void PythonQtShell_elfInfoWdgt::leaveEvent(QEvent* arg__1)
7539 void PythonQtShell_elfInfoWdgt::leaveEvent(QEvent* arg__1)
6915 {
7540 {
6916 if (_wrapper) {
7541 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6917 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
7542 static PyObject* name = PyString_FromString("leaveEvent");
6918 PyErr_Clear();
7543 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6919 if (obj && !PythonQtSlotFunction_Check(obj)) {
7544 if (obj) {
6920 static const char* argumentList[] ={"" , "QEvent*"};
7545 static const char* argumentList[] ={"" , "QEvent*"};
6921 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7546 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6922 void* args[2] = {NULL, (void*)&arg__1};
7547 void* args[2] = {NULL, (void*)&arg__1};
@@ -6924,16 +7549,18 if (_wrapper) {
6924 if (result) { Py_DECREF(result); }
7549 if (result) { Py_DECREF(result); }
6925 Py_DECREF(obj);
7550 Py_DECREF(obj);
6926 return;
7551 return;
7552 } else {
7553 PyErr_Clear();
6927 }
7554 }
6928 }
7555 }
6929 elfInfoWdgt::leaveEvent(arg__1);
7556 elfInfoWdgt::leaveEvent(arg__1);
6930 }
7557 }
6931 int PythonQtShell_elfInfoWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
7558 int PythonQtShell_elfInfoWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
6932 {
7559 {
6933 if (_wrapper) {
7560 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6934 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
7561 static PyObject* name = PyString_FromString("metric");
6935 PyErr_Clear();
7562 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6936 if (obj && !PythonQtSlotFunction_Check(obj)) {
7563 if (obj) {
6937 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
7564 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
6938 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7565 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6939 int returnValue;
7566 int returnValue;
@@ -6952,16 +7579,18 if (_wrapper) {
6952 if (result) { Py_DECREF(result); }
7579 if (result) { Py_DECREF(result); }
6953 Py_DECREF(obj);
7580 Py_DECREF(obj);
6954 return returnValue;
7581 return returnValue;
7582 } else {
7583 PyErr_Clear();
6955 }
7584 }
6956 }
7585 }
6957 return elfInfoWdgt::metric(arg__1);
7586 return elfInfoWdgt::metric(arg__1);
6958 }
7587 }
6959 QSize PythonQtShell_elfInfoWdgt::minimumSizeHint() const
7588 QSize PythonQtShell_elfInfoWdgt::minimumSizeHint() const
6960 {
7589 {
6961 if (_wrapper) {
7590 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6962 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
7591 static PyObject* name = PyString_FromString("getMinimumSizeHint");
6963 PyErr_Clear();
7592 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6964 if (obj && !PythonQtSlotFunction_Check(obj)) {
7593 if (obj) {
6965 static const char* argumentList[] ={"QSize"};
7594 static const char* argumentList[] ={"QSize"};
6966 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7595 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6967 QSize returnValue;
7596 QSize returnValue;
@@ -6980,16 +7609,18 if (_wrapper) {
6980 if (result) { Py_DECREF(result); }
7609 if (result) { Py_DECREF(result); }
6981 Py_DECREF(obj);
7610 Py_DECREF(obj);
6982 return returnValue;
7611 return returnValue;
7612 } else {
7613 PyErr_Clear();
6983 }
7614 }
6984 }
7615 }
6985 return elfInfoWdgt::minimumSizeHint();
7616 return elfInfoWdgt::minimumSizeHint();
6986 }
7617 }
6987 void PythonQtShell_elfInfoWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
7618 void PythonQtShell_elfInfoWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
6988 {
7619 {
6989 if (_wrapper) {
7620 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6990 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
7621 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
6991 PyErr_Clear();
7622 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6992 if (obj && !PythonQtSlotFunction_Check(obj)) {
7623 if (obj) {
6993 static const char* argumentList[] ={"" , "QMouseEvent*"};
7624 static const char* argumentList[] ={"" , "QMouseEvent*"};
6994 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7625 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6995 void* args[2] = {NULL, (void*)&arg__1};
7626 void* args[2] = {NULL, (void*)&arg__1};
@@ -6997,16 +7628,18 if (_wrapper) {
6997 if (result) { Py_DECREF(result); }
7628 if (result) { Py_DECREF(result); }
6998 Py_DECREF(obj);
7629 Py_DECREF(obj);
6999 return;
7630 return;
7631 } else {
7632 PyErr_Clear();
7000 }
7633 }
7001 }
7634 }
7002 elfInfoWdgt::mouseDoubleClickEvent(arg__1);
7635 elfInfoWdgt::mouseDoubleClickEvent(arg__1);
7003 }
7636 }
7004 void PythonQtShell_elfInfoWdgt::mouseMoveEvent(QMouseEvent* arg__1)
7637 void PythonQtShell_elfInfoWdgt::mouseMoveEvent(QMouseEvent* arg__1)
7005 {
7638 {
7006 if (_wrapper) {
7639 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7007 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
7640 static PyObject* name = PyString_FromString("mouseMoveEvent");
7008 PyErr_Clear();
7641 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7009 if (obj && !PythonQtSlotFunction_Check(obj)) {
7642 if (obj) {
7010 static const char* argumentList[] ={"" , "QMouseEvent*"};
7643 static const char* argumentList[] ={"" , "QMouseEvent*"};
7011 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7644 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7012 void* args[2] = {NULL, (void*)&arg__1};
7645 void* args[2] = {NULL, (void*)&arg__1};
@@ -7014,16 +7647,18 if (_wrapper) {
7014 if (result) { Py_DECREF(result); }
7647 if (result) { Py_DECREF(result); }
7015 Py_DECREF(obj);
7648 Py_DECREF(obj);
7016 return;
7649 return;
7650 } else {
7651 PyErr_Clear();
7017 }
7652 }
7018 }
7653 }
7019 elfInfoWdgt::mouseMoveEvent(arg__1);
7654 elfInfoWdgt::mouseMoveEvent(arg__1);
7020 }
7655 }
7021 void PythonQtShell_elfInfoWdgt::mousePressEvent(QMouseEvent* arg__1)
7656 void PythonQtShell_elfInfoWdgt::mousePressEvent(QMouseEvent* arg__1)
7022 {
7657 {
7023 if (_wrapper) {
7658 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7024 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
7659 static PyObject* name = PyString_FromString("mousePressEvent");
7025 PyErr_Clear();
7660 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7026 if (obj && !PythonQtSlotFunction_Check(obj)) {
7661 if (obj) {
7027 static const char* argumentList[] ={"" , "QMouseEvent*"};
7662 static const char* argumentList[] ={"" , "QMouseEvent*"};
7028 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7663 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7029 void* args[2] = {NULL, (void*)&arg__1};
7664 void* args[2] = {NULL, (void*)&arg__1};
@@ -7031,16 +7666,18 if (_wrapper) {
7031 if (result) { Py_DECREF(result); }
7666 if (result) { Py_DECREF(result); }
7032 Py_DECREF(obj);
7667 Py_DECREF(obj);
7033 return;
7668 return;
7669 } else {
7670 PyErr_Clear();
7034 }
7671 }
7035 }
7672 }
7036 elfInfoWdgt::mousePressEvent(arg__1);
7673 elfInfoWdgt::mousePressEvent(arg__1);
7037 }
7674 }
7038 void PythonQtShell_elfInfoWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
7675 void PythonQtShell_elfInfoWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
7039 {
7676 {
7040 if (_wrapper) {
7677 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7041 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
7678 static PyObject* name = PyString_FromString("mouseReleaseEvent");
7042 PyErr_Clear();
7679 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7043 if (obj && !PythonQtSlotFunction_Check(obj)) {
7680 if (obj) {
7044 static const char* argumentList[] ={"" , "QMouseEvent*"};
7681 static const char* argumentList[] ={"" , "QMouseEvent*"};
7045 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7682 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7046 void* args[2] = {NULL, (void*)&arg__1};
7683 void* args[2] = {NULL, (void*)&arg__1};
@@ -7048,16 +7685,18 if (_wrapper) {
7048 if (result) { Py_DECREF(result); }
7685 if (result) { Py_DECREF(result); }
7049 Py_DECREF(obj);
7686 Py_DECREF(obj);
7050 return;
7687 return;
7688 } else {
7689 PyErr_Clear();
7051 }
7690 }
7052 }
7691 }
7053 elfInfoWdgt::mouseReleaseEvent(arg__1);
7692 elfInfoWdgt::mouseReleaseEvent(arg__1);
7054 }
7693 }
7055 void PythonQtShell_elfInfoWdgt::moveEvent(QMoveEvent* arg__1)
7694 void PythonQtShell_elfInfoWdgt::moveEvent(QMoveEvent* arg__1)
7056 {
7695 {
7057 if (_wrapper) {
7696 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7058 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
7697 static PyObject* name = PyString_FromString("moveEvent");
7059 PyErr_Clear();
7698 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7060 if (obj && !PythonQtSlotFunction_Check(obj)) {
7699 if (obj) {
7061 static const char* argumentList[] ={"" , "QMoveEvent*"};
7700 static const char* argumentList[] ={"" , "QMoveEvent*"};
7062 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7701 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7063 void* args[2] = {NULL, (void*)&arg__1};
7702 void* args[2] = {NULL, (void*)&arg__1};
@@ -7065,20 +7704,22 if (_wrapper) {
7065 if (result) { Py_DECREF(result); }
7704 if (result) { Py_DECREF(result); }
7066 Py_DECREF(obj);
7705 Py_DECREF(obj);
7067 return;
7706 return;
7707 } else {
7708 PyErr_Clear();
7068 }
7709 }
7069 }
7710 }
7070 elfInfoWdgt::moveEvent(arg__1);
7711 elfInfoWdgt::moveEvent(arg__1);
7071 }
7712 }
7072 bool PythonQtShell_elfInfoWdgt::nativeEvent(const QByteArray& eventType, void* message, long* result)
7713 bool PythonQtShell_elfInfoWdgt::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
7073 {
7714 {
7074 if (_wrapper) {
7715 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7075 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
7716 static PyObject* name = PyString_FromString("nativeEvent");
7076 PyErr_Clear();
7717 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7077 if (obj && !PythonQtSlotFunction_Check(obj)) {
7718 if (obj) {
7078 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
7719 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
7079 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
7720 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
7080 bool returnValue;
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 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7723 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7083 if (result) {
7724 if (result) {
7084 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7725 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -7093,16 +7734,18 if (_wrapper) {
7093 if (result) { Py_DECREF(result); }
7734 if (result) { Py_DECREF(result); }
7094 Py_DECREF(obj);
7735 Py_DECREF(obj);
7095 return returnValue;
7736 return returnValue;
7096 }
7737 } else {
7097 }
7738 PyErr_Clear();
7098 return elfInfoWdgt::nativeEvent(eventType, message, result);
7739 }
7740 }
7741 return elfInfoWdgt::nativeEvent(eventType0, message1, result2);
7099 }
7742 }
7100 QPaintEngine* PythonQtShell_elfInfoWdgt::paintEngine() const
7743 QPaintEngine* PythonQtShell_elfInfoWdgt::paintEngine() const
7101 {
7744 {
7102 if (_wrapper) {
7745 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7103 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
7746 static PyObject* name = PyString_FromString("paintEngine");
7104 PyErr_Clear();
7747 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7105 if (obj && !PythonQtSlotFunction_Check(obj)) {
7748 if (obj) {
7106 static const char* argumentList[] ={"QPaintEngine*"};
7749 static const char* argumentList[] ={"QPaintEngine*"};
7107 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7750 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7108 QPaintEngine* returnValue;
7751 QPaintEngine* returnValue;
@@ -7121,16 +7764,18 if (_wrapper) {
7121 if (result) { Py_DECREF(result); }
7764 if (result) { Py_DECREF(result); }
7122 Py_DECREF(obj);
7765 Py_DECREF(obj);
7123 return returnValue;
7766 return returnValue;
7767 } else {
7768 PyErr_Clear();
7124 }
7769 }
7125 }
7770 }
7126 return elfInfoWdgt::paintEngine();
7771 return elfInfoWdgt::paintEngine();
7127 }
7772 }
7128 void PythonQtShell_elfInfoWdgt::paintEvent(QPaintEvent* arg__1)
7773 void PythonQtShell_elfInfoWdgt::paintEvent(QPaintEvent* arg__1)
7129 {
7774 {
7130 if (_wrapper) {
7775 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7131 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
7776 static PyObject* name = PyString_FromString("paintEvent");
7132 PyErr_Clear();
7777 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7133 if (obj && !PythonQtSlotFunction_Check(obj)) {
7778 if (obj) {
7134 static const char* argumentList[] ={"" , "QPaintEvent*"};
7779 static const char* argumentList[] ={"" , "QPaintEvent*"};
7135 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7780 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7136 void* args[2] = {NULL, (void*)&arg__1};
7781 void* args[2] = {NULL, (void*)&arg__1};
@@ -7138,20 +7783,22 if (_wrapper) {
7138 if (result) { Py_DECREF(result); }
7783 if (result) { Py_DECREF(result); }
7139 Py_DECREF(obj);
7784 Py_DECREF(obj);
7140 return;
7785 return;
7786 } else {
7787 PyErr_Clear();
7141 }
7788 }
7142 }
7789 }
7143 elfInfoWdgt::paintEvent(arg__1);
7790 elfInfoWdgt::paintEvent(arg__1);
7144 }
7791 }
7145 QPaintDevice* PythonQtShell_elfInfoWdgt::redirected(QPoint* offset) const
7792 QPaintDevice* PythonQtShell_elfInfoWdgt::redirected(QPoint* offset0) const
7146 {
7793 {
7147 if (_wrapper) {
7794 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7148 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
7795 static PyObject* name = PyString_FromString("redirected");
7149 PyErr_Clear();
7796 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7150 if (obj && !PythonQtSlotFunction_Check(obj)) {
7797 if (obj) {
7151 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
7798 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
7152 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7799 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7153 QPaintDevice* returnValue;
7800 QPaintDevice* returnValue;
7154 void* args[2] = {NULL, (void*)&offset};
7801 void* args[2] = {NULL, (void*)&offset0};
7155 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7802 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7156 if (result) {
7803 if (result) {
7157 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7804 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -7166,16 +7813,18 if (_wrapper) {
7166 if (result) { Py_DECREF(result); }
7813 if (result) { Py_DECREF(result); }
7167 Py_DECREF(obj);
7814 Py_DECREF(obj);
7168 return returnValue;
7815 return returnValue;
7169 }
7816 } else {
7170 }
7817 PyErr_Clear();
7171 return elfInfoWdgt::redirected(offset);
7818 }
7819 }
7820 return elfInfoWdgt::redirected(offset0);
7172 }
7821 }
7173 void PythonQtShell_elfInfoWdgt::resizeEvent(QResizeEvent* arg__1)
7822 void PythonQtShell_elfInfoWdgt::resizeEvent(QResizeEvent* arg__1)
7174 {
7823 {
7175 if (_wrapper) {
7824 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7176 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
7825 static PyObject* name = PyString_FromString("resizeEvent");
7177 PyErr_Clear();
7826 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7178 if (obj && !PythonQtSlotFunction_Check(obj)) {
7827 if (obj) {
7179 static const char* argumentList[] ={"" , "QResizeEvent*"};
7828 static const char* argumentList[] ={"" , "QResizeEvent*"};
7180 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7829 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7181 void* args[2] = {NULL, (void*)&arg__1};
7830 void* args[2] = {NULL, (void*)&arg__1};
@@ -7183,16 +7832,18 if (_wrapper) {
7183 if (result) { Py_DECREF(result); }
7832 if (result) { Py_DECREF(result); }
7184 Py_DECREF(obj);
7833 Py_DECREF(obj);
7185 return;
7834 return;
7835 } else {
7836 PyErr_Clear();
7186 }
7837 }
7187 }
7838 }
7188 elfInfoWdgt::resizeEvent(arg__1);
7839 elfInfoWdgt::resizeEvent(arg__1);
7189 }
7840 }
7190 QPainter* PythonQtShell_elfInfoWdgt::sharedPainter() const
7841 QPainter* PythonQtShell_elfInfoWdgt::sharedPainter() const
7191 {
7842 {
7192 if (_wrapper) {
7843 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7193 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
7844 static PyObject* name = PyString_FromString("sharedPainter");
7194 PyErr_Clear();
7845 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7195 if (obj && !PythonQtSlotFunction_Check(obj)) {
7846 if (obj) {
7196 static const char* argumentList[] ={"QPainter*"};
7847 static const char* argumentList[] ={"QPainter*"};
7197 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7848 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7198 QPainter* returnValue;
7849 QPainter* returnValue;
@@ -7211,16 +7862,18 if (_wrapper) {
7211 if (result) { Py_DECREF(result); }
7862 if (result) { Py_DECREF(result); }
7212 Py_DECREF(obj);
7863 Py_DECREF(obj);
7213 return returnValue;
7864 return returnValue;
7865 } else {
7866 PyErr_Clear();
7214 }
7867 }
7215 }
7868 }
7216 return elfInfoWdgt::sharedPainter();
7869 return elfInfoWdgt::sharedPainter();
7217 }
7870 }
7218 void PythonQtShell_elfInfoWdgt::showEvent(QShowEvent* arg__1)
7871 void PythonQtShell_elfInfoWdgt::showEvent(QShowEvent* arg__1)
7219 {
7872 {
7220 if (_wrapper) {
7873 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7221 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
7874 static PyObject* name = PyString_FromString("showEvent");
7222 PyErr_Clear();
7875 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7223 if (obj && !PythonQtSlotFunction_Check(obj)) {
7876 if (obj) {
7224 static const char* argumentList[] ={"" , "QShowEvent*"};
7877 static const char* argumentList[] ={"" , "QShowEvent*"};
7225 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7878 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7226 void* args[2] = {NULL, (void*)&arg__1};
7879 void* args[2] = {NULL, (void*)&arg__1};
@@ -7228,16 +7881,18 if (_wrapper) {
7228 if (result) { Py_DECREF(result); }
7881 if (result) { Py_DECREF(result); }
7229 Py_DECREF(obj);
7882 Py_DECREF(obj);
7230 return;
7883 return;
7884 } else {
7885 PyErr_Clear();
7231 }
7886 }
7232 }
7887 }
7233 elfInfoWdgt::showEvent(arg__1);
7888 elfInfoWdgt::showEvent(arg__1);
7234 }
7889 }
7235 QSize PythonQtShell_elfInfoWdgt::sizeHint() const
7890 QSize PythonQtShell_elfInfoWdgt::sizeHint() const
7236 {
7891 {
7237 if (_wrapper) {
7892 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7238 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
7893 static PyObject* name = PyString_FromString("getSizeHint");
7239 PyErr_Clear();
7894 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7240 if (obj && !PythonQtSlotFunction_Check(obj)) {
7895 if (obj) {
7241 static const char* argumentList[] ={"QSize"};
7896 static const char* argumentList[] ={"QSize"};
7242 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7897 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7243 QSize returnValue;
7898 QSize returnValue;
@@ -7256,16 +7911,18 if (_wrapper) {
7256 if (result) { Py_DECREF(result); }
7911 if (result) { Py_DECREF(result); }
7257 Py_DECREF(obj);
7912 Py_DECREF(obj);
7258 return returnValue;
7913 return returnValue;
7914 } else {
7915 PyErr_Clear();
7259 }
7916 }
7260 }
7917 }
7261 return elfInfoWdgt::sizeHint();
7918 return elfInfoWdgt::sizeHint();
7262 }
7919 }
7263 void PythonQtShell_elfInfoWdgt::tabletEvent(QTabletEvent* arg__1)
7920 void PythonQtShell_elfInfoWdgt::tabletEvent(QTabletEvent* arg__1)
7264 {
7921 {
7265 if (_wrapper) {
7922 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7266 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
7923 static PyObject* name = PyString_FromString("tabletEvent");
7267 PyErr_Clear();
7924 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7268 if (obj && !PythonQtSlotFunction_Check(obj)) {
7925 if (obj) {
7269 static const char* argumentList[] ={"" , "QTabletEvent*"};
7926 static const char* argumentList[] ={"" , "QTabletEvent*"};
7270 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7927 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7271 void* args[2] = {NULL, (void*)&arg__1};
7928 void* args[2] = {NULL, (void*)&arg__1};
@@ -7273,16 +7930,18 if (_wrapper) {
7273 if (result) { Py_DECREF(result); }
7930 if (result) { Py_DECREF(result); }
7274 Py_DECREF(obj);
7931 Py_DECREF(obj);
7275 return;
7932 return;
7933 } else {
7934 PyErr_Clear();
7276 }
7935 }
7277 }
7936 }
7278 elfInfoWdgt::tabletEvent(arg__1);
7937 elfInfoWdgt::tabletEvent(arg__1);
7279 }
7938 }
7280 void PythonQtShell_elfInfoWdgt::timerEvent(QTimerEvent* arg__1)
7939 void PythonQtShell_elfInfoWdgt::timerEvent(QTimerEvent* arg__1)
7281 {
7940 {
7282 if (_wrapper) {
7941 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7283 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
7942 static PyObject* name = PyString_FromString("timerEvent");
7284 PyErr_Clear();
7943 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7285 if (obj && !PythonQtSlotFunction_Check(obj)) {
7944 if (obj) {
7286 static const char* argumentList[] ={"" , "QTimerEvent*"};
7945 static const char* argumentList[] ={"" , "QTimerEvent*"};
7287 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7946 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7288 void* args[2] = {NULL, (void*)&arg__1};
7947 void* args[2] = {NULL, (void*)&arg__1};
@@ -7290,16 +7949,18 if (_wrapper) {
7290 if (result) { Py_DECREF(result); }
7949 if (result) { Py_DECREF(result); }
7291 Py_DECREF(obj);
7950 Py_DECREF(obj);
7292 return;
7951 return;
7952 } else {
7953 PyErr_Clear();
7293 }
7954 }
7294 }
7955 }
7295 elfInfoWdgt::timerEvent(arg__1);
7956 elfInfoWdgt::timerEvent(arg__1);
7296 }
7957 }
7297 void PythonQtShell_elfInfoWdgt::wheelEvent(QWheelEvent* arg__1)
7958 void PythonQtShell_elfInfoWdgt::wheelEvent(QWheelEvent* arg__1)
7298 {
7959 {
7299 if (_wrapper) {
7960 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7300 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
7961 static PyObject* name = PyString_FromString("wheelEvent");
7301 PyErr_Clear();
7962 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7302 if (obj && !PythonQtSlotFunction_Check(obj)) {
7963 if (obj) {
7303 static const char* argumentList[] ={"" , "QWheelEvent*"};
7964 static const char* argumentList[] ={"" , "QWheelEvent*"};
7304 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7965 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7305 void* args[2] = {NULL, (void*)&arg__1};
7966 void* args[2] = {NULL, (void*)&arg__1};
@@ -7307,6 +7968,8 if (_wrapper) {
7307 if (result) { Py_DECREF(result); }
7968 if (result) { Py_DECREF(result); }
7308 Py_DECREF(obj);
7969 Py_DECREF(obj);
7309 return;
7970 return;
7971 } else {
7972 PyErr_Clear();
7310 }
7973 }
7311 }
7974 }
7312 elfInfoWdgt::wheelEvent(arg__1);
7975 elfInfoWdgt::wheelEvent(arg__1);
@@ -7464,10 +8127,10 PythonQtShell_genericBinaryFileWidget::~
7464 }
8127 }
7465 void PythonQtShell_genericBinaryFileWidget::actionEvent(QActionEvent* arg__1)
8128 void PythonQtShell_genericBinaryFileWidget::actionEvent(QActionEvent* arg__1)
7466 {
8129 {
7467 if (_wrapper) {
8130 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7468 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
8131 static PyObject* name = PyString_FromString("actionEvent");
7469 PyErr_Clear();
8132 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7470 if (obj && !PythonQtSlotFunction_Check(obj)) {
8133 if (obj) {
7471 static const char* argumentList[] ={"" , "QActionEvent*"};
8134 static const char* argumentList[] ={"" , "QActionEvent*"};
7472 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8135 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7473 void* args[2] = {NULL, (void*)&arg__1};
8136 void* args[2] = {NULL, (void*)&arg__1};
@@ -7475,16 +8138,18 if (_wrapper) {
7475 if (result) { Py_DECREF(result); }
8138 if (result) { Py_DECREF(result); }
7476 Py_DECREF(obj);
8139 Py_DECREF(obj);
7477 return;
8140 return;
8141 } else {
8142 PyErr_Clear();
7478 }
8143 }
7479 }
8144 }
7480 genericBinaryFileWidget::actionEvent(arg__1);
8145 genericBinaryFileWidget::actionEvent(arg__1);
7481 }
8146 }
7482 void PythonQtShell_genericBinaryFileWidget::changeEvent(QEvent* arg__1)
8147 void PythonQtShell_genericBinaryFileWidget::changeEvent(QEvent* arg__1)
7483 {
8148 {
7484 if (_wrapper) {
8149 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7485 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
8150 static PyObject* name = PyString_FromString("changeEvent");
7486 PyErr_Clear();
8151 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7487 if (obj && !PythonQtSlotFunction_Check(obj)) {
8152 if (obj) {
7488 static const char* argumentList[] ={"" , "QEvent*"};
8153 static const char* argumentList[] ={"" , "QEvent*"};
7489 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8154 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7490 void* args[2] = {NULL, (void*)&arg__1};
8155 void* args[2] = {NULL, (void*)&arg__1};
@@ -7492,16 +8157,18 if (_wrapper) {
7492 if (result) { Py_DECREF(result); }
8157 if (result) { Py_DECREF(result); }
7493 Py_DECREF(obj);
8158 Py_DECREF(obj);
7494 return;
8159 return;
8160 } else {
8161 PyErr_Clear();
7495 }
8162 }
7496 }
8163 }
7497 genericBinaryFileWidget::changeEvent(arg__1);
8164 genericBinaryFileWidget::changeEvent(arg__1);
7498 }
8165 }
7499 void PythonQtShell_genericBinaryFileWidget::childEvent(QChildEvent* arg__1)
8166 void PythonQtShell_genericBinaryFileWidget::childEvent(QChildEvent* arg__1)
7500 {
8167 {
7501 if (_wrapper) {
8168 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7502 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
8169 static PyObject* name = PyString_FromString("childEvent");
7503 PyErr_Clear();
8170 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7504 if (obj && !PythonQtSlotFunction_Check(obj)) {
8171 if (obj) {
7505 static const char* argumentList[] ={"" , "QChildEvent*"};
8172 static const char* argumentList[] ={"" , "QChildEvent*"};
7506 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8173 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7507 void* args[2] = {NULL, (void*)&arg__1};
8174 void* args[2] = {NULL, (void*)&arg__1};
@@ -7509,16 +8176,18 if (_wrapper) {
7509 if (result) { Py_DECREF(result); }
8176 if (result) { Py_DECREF(result); }
7510 Py_DECREF(obj);
8177 Py_DECREF(obj);
7511 return;
8178 return;
8179 } else {
8180 PyErr_Clear();
7512 }
8181 }
7513 }
8182 }
7514 genericBinaryFileWidget::childEvent(arg__1);
8183 genericBinaryFileWidget::childEvent(arg__1);
7515 }
8184 }
7516 void PythonQtShell_genericBinaryFileWidget::closeEvent(QCloseEvent* arg__1)
8185 void PythonQtShell_genericBinaryFileWidget::closeEvent(QCloseEvent* arg__1)
7517 {
8186 {
7518 if (_wrapper) {
8187 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7519 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
8188 static PyObject* name = PyString_FromString("closeEvent");
7520 PyErr_Clear();
8189 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7521 if (obj && !PythonQtSlotFunction_Check(obj)) {
8190 if (obj) {
7522 static const char* argumentList[] ={"" , "QCloseEvent*"};
8191 static const char* argumentList[] ={"" , "QCloseEvent*"};
7523 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8192 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7524 void* args[2] = {NULL, (void*)&arg__1};
8193 void* args[2] = {NULL, (void*)&arg__1};
@@ -7526,16 +8195,18 if (_wrapper) {
7526 if (result) { Py_DECREF(result); }
8195 if (result) { Py_DECREF(result); }
7527 Py_DECREF(obj);
8196 Py_DECREF(obj);
7528 return;
8197 return;
8198 } else {
8199 PyErr_Clear();
7529 }
8200 }
7530 }
8201 }
7531 genericBinaryFileWidget::closeEvent(arg__1);
8202 genericBinaryFileWidget::closeEvent(arg__1);
7532 }
8203 }
7533 void PythonQtShell_genericBinaryFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
8204 void PythonQtShell_genericBinaryFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
7534 {
8205 {
7535 if (_wrapper) {
8206 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7536 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
8207 static PyObject* name = PyString_FromString("contextMenuEvent");
7537 PyErr_Clear();
8208 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7538 if (obj && !PythonQtSlotFunction_Check(obj)) {
8209 if (obj) {
7539 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
8210 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
7540 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8211 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7541 void* args[2] = {NULL, (void*)&arg__1};
8212 void* args[2] = {NULL, (void*)&arg__1};
@@ -7543,16 +8214,18 if (_wrapper) {
7543 if (result) { Py_DECREF(result); }
8214 if (result) { Py_DECREF(result); }
7544 Py_DECREF(obj);
8215 Py_DECREF(obj);
7545 return;
8216 return;
8217 } else {
8218 PyErr_Clear();
7546 }
8219 }
7547 }
8220 }
7548 genericBinaryFileWidget::contextMenuEvent(arg__1);
8221 genericBinaryFileWidget::contextMenuEvent(arg__1);
7549 }
8222 }
7550 void PythonQtShell_genericBinaryFileWidget::customEvent(QEvent* arg__1)
8223 void PythonQtShell_genericBinaryFileWidget::customEvent(QEvent* arg__1)
7551 {
8224 {
7552 if (_wrapper) {
8225 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7553 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
8226 static PyObject* name = PyString_FromString("customEvent");
7554 PyErr_Clear();
8227 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7555 if (obj && !PythonQtSlotFunction_Check(obj)) {
8228 if (obj) {
7556 static const char* argumentList[] ={"" , "QEvent*"};
8229 static const char* argumentList[] ={"" , "QEvent*"};
7557 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8230 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7558 void* args[2] = {NULL, (void*)&arg__1};
8231 void* args[2] = {NULL, (void*)&arg__1};
@@ -7560,16 +8233,18 if (_wrapper) {
7560 if (result) { Py_DECREF(result); }
8233 if (result) { Py_DECREF(result); }
7561 Py_DECREF(obj);
8234 Py_DECREF(obj);
7562 return;
8235 return;
8236 } else {
8237 PyErr_Clear();
7563 }
8238 }
7564 }
8239 }
7565 genericBinaryFileWidget::customEvent(arg__1);
8240 genericBinaryFileWidget::customEvent(arg__1);
7566 }
8241 }
7567 int PythonQtShell_genericBinaryFileWidget::devType() const
8242 int PythonQtShell_genericBinaryFileWidget::devType() const
7568 {
8243 {
7569 if (_wrapper) {
8244 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7570 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
8245 static PyObject* name = PyString_FromString("devType");
7571 PyErr_Clear();
8246 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7572 if (obj && !PythonQtSlotFunction_Check(obj)) {
8247 if (obj) {
7573 static const char* argumentList[] ={"int"};
8248 static const char* argumentList[] ={"int"};
7574 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8249 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7575 int returnValue;
8250 int returnValue;
@@ -7588,16 +8263,18 if (_wrapper) {
7588 if (result) { Py_DECREF(result); }
8263 if (result) { Py_DECREF(result); }
7589 Py_DECREF(obj);
8264 Py_DECREF(obj);
7590 return returnValue;
8265 return returnValue;
8266 } else {
8267 PyErr_Clear();
7591 }
8268 }
7592 }
8269 }
7593 return genericBinaryFileWidget::devType();
8270 return genericBinaryFileWidget::devType();
7594 }
8271 }
7595 void PythonQtShell_genericBinaryFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
8272 void PythonQtShell_genericBinaryFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
7596 {
8273 {
7597 if (_wrapper) {
8274 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7598 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
8275 static PyObject* name = PyString_FromString("dragEnterEvent");
7599 PyErr_Clear();
8276 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7600 if (obj && !PythonQtSlotFunction_Check(obj)) {
8277 if (obj) {
7601 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
8278 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
7602 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8279 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7603 void* args[2] = {NULL, (void*)&arg__1};
8280 void* args[2] = {NULL, (void*)&arg__1};
@@ -7605,16 +8282,18 if (_wrapper) {
7605 if (result) { Py_DECREF(result); }
8282 if (result) { Py_DECREF(result); }
7606 Py_DECREF(obj);
8283 Py_DECREF(obj);
7607 return;
8284 return;
8285 } else {
8286 PyErr_Clear();
7608 }
8287 }
7609 }
8288 }
7610 genericBinaryFileWidget::dragEnterEvent(arg__1);
8289 genericBinaryFileWidget::dragEnterEvent(arg__1);
7611 }
8290 }
7612 void PythonQtShell_genericBinaryFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
8291 void PythonQtShell_genericBinaryFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
7613 {
8292 {
7614 if (_wrapper) {
8293 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7615 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
8294 static PyObject* name = PyString_FromString("dragLeaveEvent");
7616 PyErr_Clear();
8295 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7617 if (obj && !PythonQtSlotFunction_Check(obj)) {
8296 if (obj) {
7618 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
8297 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
7619 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8298 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7620 void* args[2] = {NULL, (void*)&arg__1};
8299 void* args[2] = {NULL, (void*)&arg__1};
@@ -7622,16 +8301,18 if (_wrapper) {
7622 if (result) { Py_DECREF(result); }
8301 if (result) { Py_DECREF(result); }
7623 Py_DECREF(obj);
8302 Py_DECREF(obj);
7624 return;
8303 return;
8304 } else {
8305 PyErr_Clear();
7625 }
8306 }
7626 }
8307 }
7627 genericBinaryFileWidget::dragLeaveEvent(arg__1);
8308 genericBinaryFileWidget::dragLeaveEvent(arg__1);
7628 }
8309 }
7629 void PythonQtShell_genericBinaryFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
8310 void PythonQtShell_genericBinaryFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
7630 {
8311 {
7631 if (_wrapper) {
8312 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7632 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
8313 static PyObject* name = PyString_FromString("dragMoveEvent");
7633 PyErr_Clear();
8314 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7634 if (obj && !PythonQtSlotFunction_Check(obj)) {
8315 if (obj) {
7635 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
8316 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
7636 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8317 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7637 void* args[2] = {NULL, (void*)&arg__1};
8318 void* args[2] = {NULL, (void*)&arg__1};
@@ -7639,16 +8320,18 if (_wrapper) {
7639 if (result) { Py_DECREF(result); }
8320 if (result) { Py_DECREF(result); }
7640 Py_DECREF(obj);
8321 Py_DECREF(obj);
7641 return;
8322 return;
8323 } else {
8324 PyErr_Clear();
7642 }
8325 }
7643 }
8326 }
7644 genericBinaryFileWidget::dragMoveEvent(arg__1);
8327 genericBinaryFileWidget::dragMoveEvent(arg__1);
7645 }
8328 }
7646 void PythonQtShell_genericBinaryFileWidget::dropEvent(QDropEvent* arg__1)
8329 void PythonQtShell_genericBinaryFileWidget::dropEvent(QDropEvent* arg__1)
7647 {
8330 {
7648 if (_wrapper) {
8331 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7649 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
8332 static PyObject* name = PyString_FromString("dropEvent");
7650 PyErr_Clear();
8333 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7651 if (obj && !PythonQtSlotFunction_Check(obj)) {
8334 if (obj) {
7652 static const char* argumentList[] ={"" , "QDropEvent*"};
8335 static const char* argumentList[] ={"" , "QDropEvent*"};
7653 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8336 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7654 void* args[2] = {NULL, (void*)&arg__1};
8337 void* args[2] = {NULL, (void*)&arg__1};
@@ -7656,16 +8339,18 if (_wrapper) {
7656 if (result) { Py_DECREF(result); }
8339 if (result) { Py_DECREF(result); }
7657 Py_DECREF(obj);
8340 Py_DECREF(obj);
7658 return;
8341 return;
8342 } else {
8343 PyErr_Clear();
7659 }
8344 }
7660 }
8345 }
7661 genericBinaryFileWidget::dropEvent(arg__1);
8346 genericBinaryFileWidget::dropEvent(arg__1);
7662 }
8347 }
7663 void PythonQtShell_genericBinaryFileWidget::enterEvent(QEvent* arg__1)
8348 void PythonQtShell_genericBinaryFileWidget::enterEvent(QEvent* arg__1)
7664 {
8349 {
7665 if (_wrapper) {
8350 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7666 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
8351 static PyObject* name = PyString_FromString("enterEvent");
7667 PyErr_Clear();
8352 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7668 if (obj && !PythonQtSlotFunction_Check(obj)) {
8353 if (obj) {
7669 static const char* argumentList[] ={"" , "QEvent*"};
8354 static const char* argumentList[] ={"" , "QEvent*"};
7670 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8355 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7671 void* args[2] = {NULL, (void*)&arg__1};
8356 void* args[2] = {NULL, (void*)&arg__1};
@@ -7673,16 +8358,18 if (_wrapper) {
7673 if (result) { Py_DECREF(result); }
8358 if (result) { Py_DECREF(result); }
7674 Py_DECREF(obj);
8359 Py_DECREF(obj);
7675 return;
8360 return;
8361 } else {
8362 PyErr_Clear();
7676 }
8363 }
7677 }
8364 }
7678 genericBinaryFileWidget::enterEvent(arg__1);
8365 genericBinaryFileWidget::enterEvent(arg__1);
7679 }
8366 }
7680 bool PythonQtShell_genericBinaryFileWidget::event(QEvent* arg__1)
8367 bool PythonQtShell_genericBinaryFileWidget::event(QEvent* arg__1)
7681 {
8368 {
7682 if (_wrapper) {
8369 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7683 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
8370 static PyObject* name = PyString_FromString("event");
7684 PyErr_Clear();
8371 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7685 if (obj && !PythonQtSlotFunction_Check(obj)) {
8372 if (obj) {
7686 static const char* argumentList[] ={"bool" , "QEvent*"};
8373 static const char* argumentList[] ={"bool" , "QEvent*"};
7687 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8374 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7688 bool returnValue;
8375 bool returnValue;
@@ -7701,16 +8388,18 if (_wrapper) {
7701 if (result) { Py_DECREF(result); }
8388 if (result) { Py_DECREF(result); }
7702 Py_DECREF(obj);
8389 Py_DECREF(obj);
7703 return returnValue;
8390 return returnValue;
8391 } else {
8392 PyErr_Clear();
7704 }
8393 }
7705 }
8394 }
7706 return genericBinaryFileWidget::event(arg__1);
8395 return genericBinaryFileWidget::event(arg__1);
7707 }
8396 }
7708 bool PythonQtShell_genericBinaryFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
8397 bool PythonQtShell_genericBinaryFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
7709 {
8398 {
7710 if (_wrapper) {
8399 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7711 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
8400 static PyObject* name = PyString_FromString("eventFilter");
7712 PyErr_Clear();
8401 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7713 if (obj && !PythonQtSlotFunction_Check(obj)) {
8402 if (obj) {
7714 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
8403 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
7715 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
8404 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
7716 bool returnValue;
8405 bool returnValue;
@@ -7729,16 +8418,18 if (_wrapper) {
7729 if (result) { Py_DECREF(result); }
8418 if (result) { Py_DECREF(result); }
7730 Py_DECREF(obj);
8419 Py_DECREF(obj);
7731 return returnValue;
8420 return returnValue;
8421 } else {
8422 PyErr_Clear();
7732 }
8423 }
7733 }
8424 }
7734 return genericBinaryFileWidget::eventFilter(arg__1, arg__2);
8425 return genericBinaryFileWidget::eventFilter(arg__1, arg__2);
7735 }
8426 }
7736 void PythonQtShell_genericBinaryFileWidget::focusInEvent(QFocusEvent* arg__1)
8427 void PythonQtShell_genericBinaryFileWidget::focusInEvent(QFocusEvent* arg__1)
7737 {
8428 {
7738 if (_wrapper) {
8429 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7739 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
8430 static PyObject* name = PyString_FromString("focusInEvent");
7740 PyErr_Clear();
8431 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7741 if (obj && !PythonQtSlotFunction_Check(obj)) {
8432 if (obj) {
7742 static const char* argumentList[] ={"" , "QFocusEvent*"};
8433 static const char* argumentList[] ={"" , "QFocusEvent*"};
7743 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8434 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7744 void* args[2] = {NULL, (void*)&arg__1};
8435 void* args[2] = {NULL, (void*)&arg__1};
@@ -7746,20 +8437,22 if (_wrapper) {
7746 if (result) { Py_DECREF(result); }
8437 if (result) { Py_DECREF(result); }
7747 Py_DECREF(obj);
8438 Py_DECREF(obj);
7748 return;
8439 return;
8440 } else {
8441 PyErr_Clear();
7749 }
8442 }
7750 }
8443 }
7751 genericBinaryFileWidget::focusInEvent(arg__1);
8444 genericBinaryFileWidget::focusInEvent(arg__1);
7752 }
8445 }
7753 bool PythonQtShell_genericBinaryFileWidget::focusNextPrevChild(bool next)
8446 bool PythonQtShell_genericBinaryFileWidget::focusNextPrevChild(bool next0)
7754 {
8447 {
7755 if (_wrapper) {
8448 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7756 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
8449 static PyObject* name = PyString_FromString("focusNextPrevChild");
7757 PyErr_Clear();
8450 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7758 if (obj && !PythonQtSlotFunction_Check(obj)) {
8451 if (obj) {
7759 static const char* argumentList[] ={"bool" , "bool"};
8452 static const char* argumentList[] ={"bool" , "bool"};
7760 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8453 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7761 bool returnValue;
8454 bool returnValue;
7762 void* args[2] = {NULL, (void*)&next};
8455 void* args[2] = {NULL, (void*)&next0};
7763 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8456 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7764 if (result) {
8457 if (result) {
7765 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8458 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -7774,16 +8467,18 if (_wrapper) {
7774 if (result) { Py_DECREF(result); }
8467 if (result) { Py_DECREF(result); }
7775 Py_DECREF(obj);
8468 Py_DECREF(obj);
7776 return returnValue;
8469 return returnValue;
7777 }
8470 } else {
7778 }
8471 PyErr_Clear();
7779 return genericBinaryFileWidget::focusNextPrevChild(next);
8472 }
8473 }
8474 return genericBinaryFileWidget::focusNextPrevChild(next0);
7780 }
8475 }
7781 void PythonQtShell_genericBinaryFileWidget::focusOutEvent(QFocusEvent* arg__1)
8476 void PythonQtShell_genericBinaryFileWidget::focusOutEvent(QFocusEvent* arg__1)
7782 {
8477 {
7783 if (_wrapper) {
8478 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7784 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
8479 static PyObject* name = PyString_FromString("focusOutEvent");
7785 PyErr_Clear();
8480 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7786 if (obj && !PythonQtSlotFunction_Check(obj)) {
8481 if (obj) {
7787 static const char* argumentList[] ={"" , "QFocusEvent*"};
8482 static const char* argumentList[] ={"" , "QFocusEvent*"};
7788 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8483 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7789 void* args[2] = {NULL, (void*)&arg__1};
8484 void* args[2] = {NULL, (void*)&arg__1};
@@ -7791,16 +8486,18 if (_wrapper) {
7791 if (result) { Py_DECREF(result); }
8486 if (result) { Py_DECREF(result); }
7792 Py_DECREF(obj);
8487 Py_DECREF(obj);
7793 return;
8488 return;
8489 } else {
8490 PyErr_Clear();
7794 }
8491 }
7795 }
8492 }
7796 genericBinaryFileWidget::focusOutEvent(arg__1);
8493 genericBinaryFileWidget::focusOutEvent(arg__1);
7797 }
8494 }
7798 bool PythonQtShell_genericBinaryFileWidget::hasHeightForWidth() const
8495 bool PythonQtShell_genericBinaryFileWidget::hasHeightForWidth() const
7799 {
8496 {
7800 if (_wrapper) {
8497 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7801 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
8498 static PyObject* name = PyString_FromString("hasHeightForWidth");
7802 PyErr_Clear();
8499 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7803 if (obj && !PythonQtSlotFunction_Check(obj)) {
8500 if (obj) {
7804 static const char* argumentList[] ={"bool"};
8501 static const char* argumentList[] ={"bool"};
7805 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8502 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7806 bool returnValue;
8503 bool returnValue;
@@ -7819,16 +8516,18 if (_wrapper) {
7819 if (result) { Py_DECREF(result); }
8516 if (result) { Py_DECREF(result); }
7820 Py_DECREF(obj);
8517 Py_DECREF(obj);
7821 return returnValue;
8518 return returnValue;
8519 } else {
8520 PyErr_Clear();
7822 }
8521 }
7823 }
8522 }
7824 return genericBinaryFileWidget::hasHeightForWidth();
8523 return genericBinaryFileWidget::hasHeightForWidth();
7825 }
8524 }
7826 int PythonQtShell_genericBinaryFileWidget::heightForWidth(int arg__1) const
8525 int PythonQtShell_genericBinaryFileWidget::heightForWidth(int arg__1) const
7827 {
8526 {
7828 if (_wrapper) {
8527 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7829 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
8528 static PyObject* name = PyString_FromString("heightForWidth");
7830 PyErr_Clear();
8529 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7831 if (obj && !PythonQtSlotFunction_Check(obj)) {
8530 if (obj) {
7832 static const char* argumentList[] ={"int" , "int"};
8531 static const char* argumentList[] ={"int" , "int"};
7833 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8532 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7834 int returnValue;
8533 int returnValue;
@@ -7847,16 +8546,18 if (_wrapper) {
7847 if (result) { Py_DECREF(result); }
8546 if (result) { Py_DECREF(result); }
7848 Py_DECREF(obj);
8547 Py_DECREF(obj);
7849 return returnValue;
8548 return returnValue;
8549 } else {
8550 PyErr_Clear();
7850 }
8551 }
7851 }
8552 }
7852 return genericBinaryFileWidget::heightForWidth(arg__1);
8553 return genericBinaryFileWidget::heightForWidth(arg__1);
7853 }
8554 }
7854 void PythonQtShell_genericBinaryFileWidget::hideEvent(QHideEvent* arg__1)
8555 void PythonQtShell_genericBinaryFileWidget::hideEvent(QHideEvent* arg__1)
7855 {
8556 {
7856 if (_wrapper) {
8557 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7857 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
8558 static PyObject* name = PyString_FromString("hideEvent");
7858 PyErr_Clear();
8559 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7859 if (obj && !PythonQtSlotFunction_Check(obj)) {
8560 if (obj) {
7860 static const char* argumentList[] ={"" , "QHideEvent*"};
8561 static const char* argumentList[] ={"" , "QHideEvent*"};
7861 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8562 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7862 void* args[2] = {NULL, (void*)&arg__1};
8563 void* args[2] = {NULL, (void*)&arg__1};
@@ -7864,33 +8565,37 if (_wrapper) {
7864 if (result) { Py_DECREF(result); }
8565 if (result) { Py_DECREF(result); }
7865 Py_DECREF(obj);
8566 Py_DECREF(obj);
7866 return;
8567 return;
8568 } else {
8569 PyErr_Clear();
7867 }
8570 }
7868 }
8571 }
7869 genericBinaryFileWidget::hideEvent(arg__1);
8572 genericBinaryFileWidget::hideEvent(arg__1);
7870 }
8573 }
7871 void PythonQtShell_genericBinaryFileWidget::initPainter(QPainter* painter) const
8574 void PythonQtShell_genericBinaryFileWidget::initPainter(QPainter* painter0) const
7872 {
8575 {
7873 if (_wrapper) {
8576 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7874 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
8577 static PyObject* name = PyString_FromString("initPainter");
7875 PyErr_Clear();
8578 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7876 if (obj && !PythonQtSlotFunction_Check(obj)) {
8579 if (obj) {
7877 static const char* argumentList[] ={"" , "QPainter*"};
8580 static const char* argumentList[] ={"" , "QPainter*"};
7878 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8581 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7879 void* args[2] = {NULL, (void*)&painter};
8582 void* args[2] = {NULL, (void*)&painter0};
7880 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8583 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7881 if (result) { Py_DECREF(result); }
8584 if (result) { Py_DECREF(result); }
7882 Py_DECREF(obj);
8585 Py_DECREF(obj);
7883 return;
8586 return;
7884 }
8587 } else {
7885 }
8588 PyErr_Clear();
7886 genericBinaryFileWidget::initPainter(painter);
8589 }
8590 }
8591 genericBinaryFileWidget::initPainter(painter0);
7887 }
8592 }
7888 void PythonQtShell_genericBinaryFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
8593 void PythonQtShell_genericBinaryFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
7889 {
8594 {
7890 if (_wrapper) {
8595 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7891 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
8596 static PyObject* name = PyString_FromString("inputMethodEvent");
7892 PyErr_Clear();
8597 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7893 if (obj && !PythonQtSlotFunction_Check(obj)) {
8598 if (obj) {
7894 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
8599 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
7895 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8600 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7896 void* args[2] = {NULL, (void*)&arg__1};
8601 void* args[2] = {NULL, (void*)&arg__1};
@@ -7898,16 +8603,18 if (_wrapper) {
7898 if (result) { Py_DECREF(result); }
8603 if (result) { Py_DECREF(result); }
7899 Py_DECREF(obj);
8604 Py_DECREF(obj);
7900 return;
8605 return;
8606 } else {
8607 PyErr_Clear();
7901 }
8608 }
7902 }
8609 }
7903 genericBinaryFileWidget::inputMethodEvent(arg__1);
8610 genericBinaryFileWidget::inputMethodEvent(arg__1);
7904 }
8611 }
7905 QVariant PythonQtShell_genericBinaryFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
8612 QVariant PythonQtShell_genericBinaryFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
7906 {
8613 {
7907 if (_wrapper) {
8614 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7908 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
8615 static PyObject* name = PyString_FromString("inputMethodQuery");
7909 PyErr_Clear();
8616 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7910 if (obj && !PythonQtSlotFunction_Check(obj)) {
8617 if (obj) {
7911 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
8618 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
7912 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8619 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7913 QVariant returnValue;
8620 QVariant returnValue;
@@ -7926,16 +8633,18 if (_wrapper) {
7926 if (result) { Py_DECREF(result); }
8633 if (result) { Py_DECREF(result); }
7927 Py_DECREF(obj);
8634 Py_DECREF(obj);
7928 return returnValue;
8635 return returnValue;
8636 } else {
8637 PyErr_Clear();
7929 }
8638 }
7930 }
8639 }
7931 return genericBinaryFileWidget::inputMethodQuery(arg__1);
8640 return genericBinaryFileWidget::inputMethodQuery(arg__1);
7932 }
8641 }
7933 void PythonQtShell_genericBinaryFileWidget::keyPressEvent(QKeyEvent* arg__1)
8642 void PythonQtShell_genericBinaryFileWidget::keyPressEvent(QKeyEvent* arg__1)
7934 {
8643 {
7935 if (_wrapper) {
8644 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7936 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
8645 static PyObject* name = PyString_FromString("keyPressEvent");
7937 PyErr_Clear();
8646 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7938 if (obj && !PythonQtSlotFunction_Check(obj)) {
8647 if (obj) {
7939 static const char* argumentList[] ={"" , "QKeyEvent*"};
8648 static const char* argumentList[] ={"" , "QKeyEvent*"};
7940 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8649 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7941 void* args[2] = {NULL, (void*)&arg__1};
8650 void* args[2] = {NULL, (void*)&arg__1};
@@ -7943,16 +8652,18 if (_wrapper) {
7943 if (result) { Py_DECREF(result); }
8652 if (result) { Py_DECREF(result); }
7944 Py_DECREF(obj);
8653 Py_DECREF(obj);
7945 return;
8654 return;
8655 } else {
8656 PyErr_Clear();
7946 }
8657 }
7947 }
8658 }
7948 genericBinaryFileWidget::keyPressEvent(arg__1);
8659 genericBinaryFileWidget::keyPressEvent(arg__1);
7949 }
8660 }
7950 void PythonQtShell_genericBinaryFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
8661 void PythonQtShell_genericBinaryFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
7951 {
8662 {
7952 if (_wrapper) {
8663 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7953 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
8664 static PyObject* name = PyString_FromString("keyReleaseEvent");
7954 PyErr_Clear();
8665 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7955 if (obj && !PythonQtSlotFunction_Check(obj)) {
8666 if (obj) {
7956 static const char* argumentList[] ={"" , "QKeyEvent*"};
8667 static const char* argumentList[] ={"" , "QKeyEvent*"};
7957 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8668 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7958 void* args[2] = {NULL, (void*)&arg__1};
8669 void* args[2] = {NULL, (void*)&arg__1};
@@ -7960,16 +8671,18 if (_wrapper) {
7960 if (result) { Py_DECREF(result); }
8671 if (result) { Py_DECREF(result); }
7961 Py_DECREF(obj);
8672 Py_DECREF(obj);
7962 return;
8673 return;
8674 } else {
8675 PyErr_Clear();
7963 }
8676 }
7964 }
8677 }
7965 genericBinaryFileWidget::keyReleaseEvent(arg__1);
8678 genericBinaryFileWidget::keyReleaseEvent(arg__1);
7966 }
8679 }
7967 void PythonQtShell_genericBinaryFileWidget::leaveEvent(QEvent* arg__1)
8680 void PythonQtShell_genericBinaryFileWidget::leaveEvent(QEvent* arg__1)
7968 {
8681 {
7969 if (_wrapper) {
8682 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7970 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
8683 static PyObject* name = PyString_FromString("leaveEvent");
7971 PyErr_Clear();
8684 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7972 if (obj && !PythonQtSlotFunction_Check(obj)) {
8685 if (obj) {
7973 static const char* argumentList[] ={"" , "QEvent*"};
8686 static const char* argumentList[] ={"" , "QEvent*"};
7974 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8687 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7975 void* args[2] = {NULL, (void*)&arg__1};
8688 void* args[2] = {NULL, (void*)&arg__1};
@@ -7977,16 +8690,18 if (_wrapper) {
7977 if (result) { Py_DECREF(result); }
8690 if (result) { Py_DECREF(result); }
7978 Py_DECREF(obj);
8691 Py_DECREF(obj);
7979 return;
8692 return;
8693 } else {
8694 PyErr_Clear();
7980 }
8695 }
7981 }
8696 }
7982 genericBinaryFileWidget::leaveEvent(arg__1);
8697 genericBinaryFileWidget::leaveEvent(arg__1);
7983 }
8698 }
7984 int PythonQtShell_genericBinaryFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
8699 int PythonQtShell_genericBinaryFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
7985 {
8700 {
7986 if (_wrapper) {
8701 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7987 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
8702 static PyObject* name = PyString_FromString("metric");
7988 PyErr_Clear();
8703 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7989 if (obj && !PythonQtSlotFunction_Check(obj)) {
8704 if (obj) {
7990 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
8705 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
7991 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8706 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7992 int returnValue;
8707 int returnValue;
@@ -8005,16 +8720,18 if (_wrapper) {
8005 if (result) { Py_DECREF(result); }
8720 if (result) { Py_DECREF(result); }
8006 Py_DECREF(obj);
8721 Py_DECREF(obj);
8007 return returnValue;
8722 return returnValue;
8723 } else {
8724 PyErr_Clear();
8008 }
8725 }
8009 }
8726 }
8010 return genericBinaryFileWidget::metric(arg__1);
8727 return genericBinaryFileWidget::metric(arg__1);
8011 }
8728 }
8012 QSize PythonQtShell_genericBinaryFileWidget::minimumSizeHint() const
8729 QSize PythonQtShell_genericBinaryFileWidget::minimumSizeHint() const
8013 {
8730 {
8014 if (_wrapper) {
8731 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8015 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
8732 static PyObject* name = PyString_FromString("getMinimumSizeHint");
8016 PyErr_Clear();
8733 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8017 if (obj && !PythonQtSlotFunction_Check(obj)) {
8734 if (obj) {
8018 static const char* argumentList[] ={"QSize"};
8735 static const char* argumentList[] ={"QSize"};
8019 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8736 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8020 QSize returnValue;
8737 QSize returnValue;
@@ -8033,16 +8750,18 if (_wrapper) {
8033 if (result) { Py_DECREF(result); }
8750 if (result) { Py_DECREF(result); }
8034 Py_DECREF(obj);
8751 Py_DECREF(obj);
8035 return returnValue;
8752 return returnValue;
8753 } else {
8754 PyErr_Clear();
8036 }
8755 }
8037 }
8756 }
8038 return genericBinaryFileWidget::minimumSizeHint();
8757 return genericBinaryFileWidget::minimumSizeHint();
8039 }
8758 }
8040 void PythonQtShell_genericBinaryFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
8759 void PythonQtShell_genericBinaryFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
8041 {
8760 {
8042 if (_wrapper) {
8761 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8043 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
8762 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
8044 PyErr_Clear();
8763 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8045 if (obj && !PythonQtSlotFunction_Check(obj)) {
8764 if (obj) {
8046 static const char* argumentList[] ={"" , "QMouseEvent*"};
8765 static const char* argumentList[] ={"" , "QMouseEvent*"};
8047 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8766 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8048 void* args[2] = {NULL, (void*)&arg__1};
8767 void* args[2] = {NULL, (void*)&arg__1};
@@ -8050,16 +8769,18 if (_wrapper) {
8050 if (result) { Py_DECREF(result); }
8769 if (result) { Py_DECREF(result); }
8051 Py_DECREF(obj);
8770 Py_DECREF(obj);
8052 return;
8771 return;
8772 } else {
8773 PyErr_Clear();
8053 }
8774 }
8054 }
8775 }
8055 genericBinaryFileWidget::mouseDoubleClickEvent(arg__1);
8776 genericBinaryFileWidget::mouseDoubleClickEvent(arg__1);
8056 }
8777 }
8057 void PythonQtShell_genericBinaryFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
8778 void PythonQtShell_genericBinaryFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
8058 {
8779 {
8059 if (_wrapper) {
8780 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8060 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
8781 static PyObject* name = PyString_FromString("mouseMoveEvent");
8061 PyErr_Clear();
8782 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8062 if (obj && !PythonQtSlotFunction_Check(obj)) {
8783 if (obj) {
8063 static const char* argumentList[] ={"" , "QMouseEvent*"};
8784 static const char* argumentList[] ={"" , "QMouseEvent*"};
8064 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8785 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8065 void* args[2] = {NULL, (void*)&arg__1};
8786 void* args[2] = {NULL, (void*)&arg__1};
@@ -8067,16 +8788,18 if (_wrapper) {
8067 if (result) { Py_DECREF(result); }
8788 if (result) { Py_DECREF(result); }
8068 Py_DECREF(obj);
8789 Py_DECREF(obj);
8069 return;
8790 return;
8791 } else {
8792 PyErr_Clear();
8070 }
8793 }
8071 }
8794 }
8072 genericBinaryFileWidget::mouseMoveEvent(arg__1);
8795 genericBinaryFileWidget::mouseMoveEvent(arg__1);
8073 }
8796 }
8074 void PythonQtShell_genericBinaryFileWidget::mousePressEvent(QMouseEvent* arg__1)
8797 void PythonQtShell_genericBinaryFileWidget::mousePressEvent(QMouseEvent* arg__1)
8075 {
8798 {
8076 if (_wrapper) {
8799 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8077 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
8800 static PyObject* name = PyString_FromString("mousePressEvent");
8078 PyErr_Clear();
8801 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8079 if (obj && !PythonQtSlotFunction_Check(obj)) {
8802 if (obj) {
8080 static const char* argumentList[] ={"" , "QMouseEvent*"};
8803 static const char* argumentList[] ={"" , "QMouseEvent*"};
8081 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8804 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8082 void* args[2] = {NULL, (void*)&arg__1};
8805 void* args[2] = {NULL, (void*)&arg__1};
@@ -8084,16 +8807,18 if (_wrapper) {
8084 if (result) { Py_DECREF(result); }
8807 if (result) { Py_DECREF(result); }
8085 Py_DECREF(obj);
8808 Py_DECREF(obj);
8086 return;
8809 return;
8810 } else {
8811 PyErr_Clear();
8087 }
8812 }
8088 }
8813 }
8089 genericBinaryFileWidget::mousePressEvent(arg__1);
8814 genericBinaryFileWidget::mousePressEvent(arg__1);
8090 }
8815 }
8091 void PythonQtShell_genericBinaryFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
8816 void PythonQtShell_genericBinaryFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
8092 {
8817 {
8093 if (_wrapper) {
8818 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8094 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
8819 static PyObject* name = PyString_FromString("mouseReleaseEvent");
8095 PyErr_Clear();
8820 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8096 if (obj && !PythonQtSlotFunction_Check(obj)) {
8821 if (obj) {
8097 static const char* argumentList[] ={"" , "QMouseEvent*"};
8822 static const char* argumentList[] ={"" , "QMouseEvent*"};
8098 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8823 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8099 void* args[2] = {NULL, (void*)&arg__1};
8824 void* args[2] = {NULL, (void*)&arg__1};
@@ -8101,16 +8826,18 if (_wrapper) {
8101 if (result) { Py_DECREF(result); }
8826 if (result) { Py_DECREF(result); }
8102 Py_DECREF(obj);
8827 Py_DECREF(obj);
8103 return;
8828 return;
8829 } else {
8830 PyErr_Clear();
8104 }
8831 }
8105 }
8832 }
8106 genericBinaryFileWidget::mouseReleaseEvent(arg__1);
8833 genericBinaryFileWidget::mouseReleaseEvent(arg__1);
8107 }
8834 }
8108 void PythonQtShell_genericBinaryFileWidget::moveEvent(QMoveEvent* arg__1)
8835 void PythonQtShell_genericBinaryFileWidget::moveEvent(QMoveEvent* arg__1)
8109 {
8836 {
8110 if (_wrapper) {
8837 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8111 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
8838 static PyObject* name = PyString_FromString("moveEvent");
8112 PyErr_Clear();
8839 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8113 if (obj && !PythonQtSlotFunction_Check(obj)) {
8840 if (obj) {
8114 static const char* argumentList[] ={"" , "QMoveEvent*"};
8841 static const char* argumentList[] ={"" , "QMoveEvent*"};
8115 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8842 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8116 void* args[2] = {NULL, (void*)&arg__1};
8843 void* args[2] = {NULL, (void*)&arg__1};
@@ -8118,20 +8845,22 if (_wrapper) {
8118 if (result) { Py_DECREF(result); }
8845 if (result) { Py_DECREF(result); }
8119 Py_DECREF(obj);
8846 Py_DECREF(obj);
8120 return;
8847 return;
8848 } else {
8849 PyErr_Clear();
8121 }
8850 }
8122 }
8851 }
8123 genericBinaryFileWidget::moveEvent(arg__1);
8852 genericBinaryFileWidget::moveEvent(arg__1);
8124 }
8853 }
8125 bool PythonQtShell_genericBinaryFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result)
8854 bool PythonQtShell_genericBinaryFileWidget::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
8126 {
8855 {
8127 if (_wrapper) {
8856 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8128 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
8857 static PyObject* name = PyString_FromString("nativeEvent");
8129 PyErr_Clear();
8858 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8130 if (obj && !PythonQtSlotFunction_Check(obj)) {
8859 if (obj) {
8131 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
8860 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
8132 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
8861 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
8133 bool returnValue;
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 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8864 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8136 if (result) {
8865 if (result) {
8137 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8866 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -8146,16 +8875,18 if (_wrapper) {
8146 if (result) { Py_DECREF(result); }
8875 if (result) { Py_DECREF(result); }
8147 Py_DECREF(obj);
8876 Py_DECREF(obj);
8148 return returnValue;
8877 return returnValue;
8149 }
8878 } else {
8150 }
8879 PyErr_Clear();
8151 return genericBinaryFileWidget::nativeEvent(eventType, message, result);
8880 }
8881 }
8882 return genericBinaryFileWidget::nativeEvent(eventType0, message1, result2);
8152 }
8883 }
8153 QPaintEngine* PythonQtShell_genericBinaryFileWidget::paintEngine() const
8884 QPaintEngine* PythonQtShell_genericBinaryFileWidget::paintEngine() const
8154 {
8885 {
8155 if (_wrapper) {
8886 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8156 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
8887 static PyObject* name = PyString_FromString("paintEngine");
8157 PyErr_Clear();
8888 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8158 if (obj && !PythonQtSlotFunction_Check(obj)) {
8889 if (obj) {
8159 static const char* argumentList[] ={"QPaintEngine*"};
8890 static const char* argumentList[] ={"QPaintEngine*"};
8160 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8891 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8161 QPaintEngine* returnValue;
8892 QPaintEngine* returnValue;
@@ -8174,16 +8905,18 if (_wrapper) {
8174 if (result) { Py_DECREF(result); }
8905 if (result) { Py_DECREF(result); }
8175 Py_DECREF(obj);
8906 Py_DECREF(obj);
8176 return returnValue;
8907 return returnValue;
8908 } else {
8909 PyErr_Clear();
8177 }
8910 }
8178 }
8911 }
8179 return genericBinaryFileWidget::paintEngine();
8912 return genericBinaryFileWidget::paintEngine();
8180 }
8913 }
8181 void PythonQtShell_genericBinaryFileWidget::paintEvent(QPaintEvent* arg__1)
8914 void PythonQtShell_genericBinaryFileWidget::paintEvent(QPaintEvent* arg__1)
8182 {
8915 {
8183 if (_wrapper) {
8916 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8184 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
8917 static PyObject* name = PyString_FromString("paintEvent");
8185 PyErr_Clear();
8918 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8186 if (obj && !PythonQtSlotFunction_Check(obj)) {
8919 if (obj) {
8187 static const char* argumentList[] ={"" , "QPaintEvent*"};
8920 static const char* argumentList[] ={"" , "QPaintEvent*"};
8188 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8921 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8189 void* args[2] = {NULL, (void*)&arg__1};
8922 void* args[2] = {NULL, (void*)&arg__1};
@@ -8191,20 +8924,22 if (_wrapper) {
8191 if (result) { Py_DECREF(result); }
8924 if (result) { Py_DECREF(result); }
8192 Py_DECREF(obj);
8925 Py_DECREF(obj);
8193 return;
8926 return;
8927 } else {
8928 PyErr_Clear();
8194 }
8929 }
8195 }
8930 }
8196 genericBinaryFileWidget::paintEvent(arg__1);
8931 genericBinaryFileWidget::paintEvent(arg__1);
8197 }
8932 }
8198 QPaintDevice* PythonQtShell_genericBinaryFileWidget::redirected(QPoint* offset) const
8933 QPaintDevice* PythonQtShell_genericBinaryFileWidget::redirected(QPoint* offset0) const
8199 {
8934 {
8200 if (_wrapper) {
8935 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8201 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
8936 static PyObject* name = PyString_FromString("redirected");
8202 PyErr_Clear();
8937 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8203 if (obj && !PythonQtSlotFunction_Check(obj)) {
8938 if (obj) {
8204 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
8939 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
8205 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8940 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8206 QPaintDevice* returnValue;
8941 QPaintDevice* returnValue;
8207 void* args[2] = {NULL, (void*)&offset};
8942 void* args[2] = {NULL, (void*)&offset0};
8208 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8943 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8209 if (result) {
8944 if (result) {
8210 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8945 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -8219,16 +8954,18 if (_wrapper) {
8219 if (result) { Py_DECREF(result); }
8954 if (result) { Py_DECREF(result); }
8220 Py_DECREF(obj);
8955 Py_DECREF(obj);
8221 return returnValue;
8956 return returnValue;
8222 }
8957 } else {
8223 }
8958 PyErr_Clear();
8224 return genericBinaryFileWidget::redirected(offset);
8959 }
8960 }
8961 return genericBinaryFileWidget::redirected(offset0);
8225 }
8962 }
8226 void PythonQtShell_genericBinaryFileWidget::resizeEvent(QResizeEvent* arg__1)
8963 void PythonQtShell_genericBinaryFileWidget::resizeEvent(QResizeEvent* arg__1)
8227 {
8964 {
8228 if (_wrapper) {
8965 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8229 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
8966 static PyObject* name = PyString_FromString("resizeEvent");
8230 PyErr_Clear();
8967 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8231 if (obj && !PythonQtSlotFunction_Check(obj)) {
8968 if (obj) {
8232 static const char* argumentList[] ={"" , "QResizeEvent*"};
8969 static const char* argumentList[] ={"" , "QResizeEvent*"};
8233 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8970 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8234 void* args[2] = {NULL, (void*)&arg__1};
8971 void* args[2] = {NULL, (void*)&arg__1};
@@ -8236,16 +8973,18 if (_wrapper) {
8236 if (result) { Py_DECREF(result); }
8973 if (result) { Py_DECREF(result); }
8237 Py_DECREF(obj);
8974 Py_DECREF(obj);
8238 return;
8975 return;
8976 } else {
8977 PyErr_Clear();
8239 }
8978 }
8240 }
8979 }
8241 genericBinaryFileWidget::resizeEvent(arg__1);
8980 genericBinaryFileWidget::resizeEvent(arg__1);
8242 }
8981 }
8243 QPainter* PythonQtShell_genericBinaryFileWidget::sharedPainter() const
8982 QPainter* PythonQtShell_genericBinaryFileWidget::sharedPainter() const
8244 {
8983 {
8245 if (_wrapper) {
8984 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8246 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
8985 static PyObject* name = PyString_FromString("sharedPainter");
8247 PyErr_Clear();
8986 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8248 if (obj && !PythonQtSlotFunction_Check(obj)) {
8987 if (obj) {
8249 static const char* argumentList[] ={"QPainter*"};
8988 static const char* argumentList[] ={"QPainter*"};
8250 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8989 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8251 QPainter* returnValue;
8990 QPainter* returnValue;
@@ -8264,16 +9003,18 if (_wrapper) {
8264 if (result) { Py_DECREF(result); }
9003 if (result) { Py_DECREF(result); }
8265 Py_DECREF(obj);
9004 Py_DECREF(obj);
8266 return returnValue;
9005 return returnValue;
9006 } else {
9007 PyErr_Clear();
8267 }
9008 }
8268 }
9009 }
8269 return genericBinaryFileWidget::sharedPainter();
9010 return genericBinaryFileWidget::sharedPainter();
8270 }
9011 }
8271 void PythonQtShell_genericBinaryFileWidget::showEvent(QShowEvent* arg__1)
9012 void PythonQtShell_genericBinaryFileWidget::showEvent(QShowEvent* arg__1)
8272 {
9013 {
8273 if (_wrapper) {
9014 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8274 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
9015 static PyObject* name = PyString_FromString("showEvent");
8275 PyErr_Clear();
9016 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8276 if (obj && !PythonQtSlotFunction_Check(obj)) {
9017 if (obj) {
8277 static const char* argumentList[] ={"" , "QShowEvent*"};
9018 static const char* argumentList[] ={"" , "QShowEvent*"};
8278 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9019 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8279 void* args[2] = {NULL, (void*)&arg__1};
9020 void* args[2] = {NULL, (void*)&arg__1};
@@ -8281,16 +9022,18 if (_wrapper) {
8281 if (result) { Py_DECREF(result); }
9022 if (result) { Py_DECREF(result); }
8282 Py_DECREF(obj);
9023 Py_DECREF(obj);
8283 return;
9024 return;
9025 } else {
9026 PyErr_Clear();
8284 }
9027 }
8285 }
9028 }
8286 genericBinaryFileWidget::showEvent(arg__1);
9029 genericBinaryFileWidget::showEvent(arg__1);
8287 }
9030 }
8288 QSize PythonQtShell_genericBinaryFileWidget::sizeHint() const
9031 QSize PythonQtShell_genericBinaryFileWidget::sizeHint() const
8289 {
9032 {
8290 if (_wrapper) {
9033 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8291 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
9034 static PyObject* name = PyString_FromString("getSizeHint");
8292 PyErr_Clear();
9035 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8293 if (obj && !PythonQtSlotFunction_Check(obj)) {
9036 if (obj) {
8294 static const char* argumentList[] ={"QSize"};
9037 static const char* argumentList[] ={"QSize"};
8295 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9038 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8296 QSize returnValue;
9039 QSize returnValue;
@@ -8309,16 +9052,18 if (_wrapper) {
8309 if (result) { Py_DECREF(result); }
9052 if (result) { Py_DECREF(result); }
8310 Py_DECREF(obj);
9053 Py_DECREF(obj);
8311 return returnValue;
9054 return returnValue;
9055 } else {
9056 PyErr_Clear();
8312 }
9057 }
8313 }
9058 }
8314 return genericBinaryFileWidget::sizeHint();
9059 return genericBinaryFileWidget::sizeHint();
8315 }
9060 }
8316 void PythonQtShell_genericBinaryFileWidget::tabletEvent(QTabletEvent* arg__1)
9061 void PythonQtShell_genericBinaryFileWidget::tabletEvent(QTabletEvent* arg__1)
8317 {
9062 {
8318 if (_wrapper) {
9063 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8319 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
9064 static PyObject* name = PyString_FromString("tabletEvent");
8320 PyErr_Clear();
9065 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8321 if (obj && !PythonQtSlotFunction_Check(obj)) {
9066 if (obj) {
8322 static const char* argumentList[] ={"" , "QTabletEvent*"};
9067 static const char* argumentList[] ={"" , "QTabletEvent*"};
8323 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9068 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8324 void* args[2] = {NULL, (void*)&arg__1};
9069 void* args[2] = {NULL, (void*)&arg__1};
@@ -8326,16 +9071,18 if (_wrapper) {
8326 if (result) { Py_DECREF(result); }
9071 if (result) { Py_DECREF(result); }
8327 Py_DECREF(obj);
9072 Py_DECREF(obj);
8328 return;
9073 return;
9074 } else {
9075 PyErr_Clear();
8329 }
9076 }
8330 }
9077 }
8331 genericBinaryFileWidget::tabletEvent(arg__1);
9078 genericBinaryFileWidget::tabletEvent(arg__1);
8332 }
9079 }
8333 void PythonQtShell_genericBinaryFileWidget::timerEvent(QTimerEvent* arg__1)
9080 void PythonQtShell_genericBinaryFileWidget::timerEvent(QTimerEvent* arg__1)
8334 {
9081 {
8335 if (_wrapper) {
9082 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8336 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
9083 static PyObject* name = PyString_FromString("timerEvent");
8337 PyErr_Clear();
9084 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8338 if (obj && !PythonQtSlotFunction_Check(obj)) {
9085 if (obj) {
8339 static const char* argumentList[] ={"" , "QTimerEvent*"};
9086 static const char* argumentList[] ={"" , "QTimerEvent*"};
8340 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9087 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8341 void* args[2] = {NULL, (void*)&arg__1};
9088 void* args[2] = {NULL, (void*)&arg__1};
@@ -8343,16 +9090,18 if (_wrapper) {
8343 if (result) { Py_DECREF(result); }
9090 if (result) { Py_DECREF(result); }
8344 Py_DECREF(obj);
9091 Py_DECREF(obj);
8345 return;
9092 return;
9093 } else {
9094 PyErr_Clear();
8346 }
9095 }
8347 }
9096 }
8348 genericBinaryFileWidget::timerEvent(arg__1);
9097 genericBinaryFileWidget::timerEvent(arg__1);
8349 }
9098 }
8350 void PythonQtShell_genericBinaryFileWidget::wheelEvent(QWheelEvent* arg__1)
9099 void PythonQtShell_genericBinaryFileWidget::wheelEvent(QWheelEvent* arg__1)
8351 {
9100 {
8352 if (_wrapper) {
9101 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8353 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
9102 static PyObject* name = PyString_FromString("wheelEvent");
8354 PyErr_Clear();
9103 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8355 if (obj && !PythonQtSlotFunction_Check(obj)) {
9104 if (obj) {
8356 static const char* argumentList[] ={"" , "QWheelEvent*"};
9105 static const char* argumentList[] ={"" , "QWheelEvent*"};
8357 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9106 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8358 void* args[2] = {NULL, (void*)&arg__1};
9107 void* args[2] = {NULL, (void*)&arg__1};
@@ -8360,6 +9109,8 if (_wrapper) {
8360 if (result) { Py_DECREF(result); }
9109 if (result) { Py_DECREF(result); }
8361 Py_DECREF(obj);
9110 Py_DECREF(obj);
8362 return;
9111 return;
9112 } else {
9113 PyErr_Clear();
8363 }
9114 }
8364 }
9115 }
8365 genericBinaryFileWidget::wheelEvent(arg__1);
9116 genericBinaryFileWidget::wheelEvent(arg__1);
@@ -8376,10 +9127,10 PythonQtShell_srecFile::~PythonQtShell_s
8376 }
9127 }
8377 int PythonQtShell_srecFile::closeFile()
9128 int PythonQtShell_srecFile::closeFile()
8378 {
9129 {
8379 if (_wrapper) {
9130 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8380 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
9131 static PyObject* name = PyString_FromString("closeFile");
8381 PyErr_Clear();
9132 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8382 if (obj && !PythonQtSlotFunction_Check(obj)) {
9133 if (obj) {
8383 static const char* argumentList[] ={"int"};
9134 static const char* argumentList[] ={"int"};
8384 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9135 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8385 int returnValue;
9136 int returnValue;
@@ -8398,16 +9149,18 if (_wrapper) {
8398 if (result) { Py_DECREF(result); }
9149 if (result) { Py_DECREF(result); }
8399 Py_DECREF(obj);
9150 Py_DECREF(obj);
8400 return returnValue;
9151 return returnValue;
9152 } else {
9153 PyErr_Clear();
8401 }
9154 }
8402 }
9155 }
8403 return srecFile::closeFile();
9156 return srecFile::closeFile();
8404 }
9157 }
8405 QList<codeFragment* > PythonQtShell_srecFile::getFragments()
9158 QList<codeFragment* > PythonQtShell_srecFile::getFragments()
8406 {
9159 {
8407 if (_wrapper) {
9160 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8408 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
9161 static PyObject* name = PyString_FromString("getFragments");
8409 PyErr_Clear();
9162 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8410 if (obj && !PythonQtSlotFunction_Check(obj)) {
9163 if (obj) {
8411 static const char* argumentList[] ={"QList<codeFragment* >"};
9164 static const char* argumentList[] ={"QList<codeFragment* >"};
8412 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9165 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8413 QList<codeFragment* > returnValue;
9166 QList<codeFragment* > returnValue;
@@ -8426,16 +9179,18 if (_wrapper) {
8426 if (result) { Py_DECREF(result); }
9179 if (result) { Py_DECREF(result); }
8427 Py_DECREF(obj);
9180 Py_DECREF(obj);
8428 return returnValue;
9181 return returnValue;
9182 } else {
9183 PyErr_Clear();
8429 }
9184 }
8430 }
9185 }
8431 return srecFile::getFragments();
9186 return srecFile::getFragments();
8432 }
9187 }
8433 bool PythonQtShell_srecFile::isopened()
9188 bool PythonQtShell_srecFile::isopened()
8434 {
9189 {
8435 if (_wrapper) {
9190 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8436 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
9191 static PyObject* name = PyString_FromString("isopened");
8437 PyErr_Clear();
9192 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8438 if (obj && !PythonQtSlotFunction_Check(obj)) {
9193 if (obj) {
8439 static const char* argumentList[] ={"bool"};
9194 static const char* argumentList[] ={"bool"};
8440 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9195 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8441 bool returnValue;
9196 bool returnValue;
@@ -8454,20 +9209,22 if (_wrapper) {
8454 if (result) { Py_DECREF(result); }
9209 if (result) { Py_DECREF(result); }
8455 Py_DECREF(obj);
9210 Py_DECREF(obj);
8456 return returnValue;
9211 return returnValue;
9212 } else {
9213 PyErr_Clear();
8457 }
9214 }
8458 }
9215 }
8459 return srecFile::isopened();
9216 return srecFile::isopened();
8460 }
9217 }
8461 bool PythonQtShell_srecFile::openFile(const QString& File)
9218 bool PythonQtShell_srecFile::openFile(const QString& File0)
8462 {
9219 {
8463 if (_wrapper) {
9220 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8464 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
9221 static PyObject* name = PyString_FromString("openFile");
8465 PyErr_Clear();
9222 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8466 if (obj && !PythonQtSlotFunction_Check(obj)) {
9223 if (obj) {
8467 static const char* argumentList[] ={"bool" , "const QString&"};
9224 static const char* argumentList[] ={"bool" , "const QString&"};
8468 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9225 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8469 bool returnValue;
9226 bool returnValue;
8470 void* args[2] = {NULL, (void*)&File};
9227 void* args[2] = {NULL, (void*)&File0};
8471 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9228 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8472 if (result) {
9229 if (result) {
8473 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9230 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -8482,20 +9239,22 if (_wrapper) {
8482 if (result) { Py_DECREF(result); }
9239 if (result) { Py_DECREF(result); }
8483 Py_DECREF(obj);
9240 Py_DECREF(obj);
8484 return returnValue;
9241 return returnValue;
8485 }
9242 } else {
8486 }
9243 PyErr_Clear();
8487 return srecFile::openFile(File);
9244 }
8488 }
9245 }
8489 bool PythonQtShell_srecFile::toBinary(const QString& File)
9246 return srecFile::openFile(File0);
8490 {
9247 }
8491 if (_wrapper) {
9248 bool PythonQtShell_srecFile::toBinary(const QString& File0)
8492 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
9249 {
8493 PyErr_Clear();
9250 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8494 if (obj && !PythonQtSlotFunction_Check(obj)) {
9251 static PyObject* name = PyString_FromString("toBinary");
9252 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9253 if (obj) {
8495 static const char* argumentList[] ={"bool" , "const QString&"};
9254 static const char* argumentList[] ={"bool" , "const QString&"};
8496 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9255 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8497 bool returnValue;
9256 bool returnValue;
8498 void* args[2] = {NULL, (void*)&File};
9257 void* args[2] = {NULL, (void*)&File0};
8499 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9258 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8500 if (result) {
9259 if (result) {
8501 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9260 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -8510,20 +9269,22 if (_wrapper) {
8510 if (result) { Py_DECREF(result); }
9269 if (result) { Py_DECREF(result); }
8511 Py_DECREF(obj);
9270 Py_DECREF(obj);
8512 return returnValue;
9271 return returnValue;
8513 }
9272 } else {
8514 }
9273 PyErr_Clear();
8515 return srecFile::toBinary(File);
9274 }
8516 }
9275 }
8517 bool PythonQtShell_srecFile::toSrec(const QString& File)
9276 return srecFile::toBinary(File0);
8518 {
9277 }
8519 if (_wrapper) {
9278 bool PythonQtShell_srecFile::toSrec(const QString& File0)
8520 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
9279 {
8521 PyErr_Clear();
9280 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8522 if (obj && !PythonQtSlotFunction_Check(obj)) {
9281 static PyObject* name = PyString_FromString("toSrec");
9282 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9283 if (obj) {
8523 static const char* argumentList[] ={"bool" , "const QString&"};
9284 static const char* argumentList[] ={"bool" , "const QString&"};
8524 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9285 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8525 bool returnValue;
9286 bool returnValue;
8526 void* args[2] = {NULL, (void*)&File};
9287 void* args[2] = {NULL, (void*)&File0};
8527 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9288 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8528 if (result) {
9289 if (result) {
8529 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9290 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
@@ -8538,9 +9299,11 if (_wrapper) {
8538 if (result) { Py_DECREF(result); }
9299 if (result) { Py_DECREF(result); }
8539 Py_DECREF(obj);
9300 Py_DECREF(obj);
8540 return returnValue;
9301 return returnValue;
8541 }
9302 } else {
8542 }
9303 PyErr_Clear();
8543 return srecFile::toSrec(File);
9304 }
9305 }
9306 return srecFile::toSrec(File0);
8544 }
9307 }
8545 srecFile* PythonQtWrapper_srecFile::new_srecFile()
9308 srecFile* PythonQtWrapper_srecFile::new_srecFile()
8546 {
9309 {
@@ -8662,10 +9425,10 PythonQtShell_srecFileWidget::~PythonQtS
8662 }
9425 }
8663 void PythonQtShell_srecFileWidget::reloadFile()
9426 void PythonQtShell_srecFileWidget::reloadFile()
8664 {
9427 {
8665 if (_wrapper) {
9428 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8666 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
9429 static PyObject* name = PyString_FromString("reloadFile");
8667 PyErr_Clear();
9430 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8668 if (obj && !PythonQtSlotFunction_Check(obj)) {
9431 if (obj) {
8669 static const char* argumentList[] ={""};
9432 static const char* argumentList[] ={""};
8670 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9433 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8671 void* args[1] = {NULL};
9434 void* args[1] = {NULL};
@@ -8673,26 +9436,30 if (_wrapper) {
8673 if (result) { Py_DECREF(result); }
9436 if (result) { Py_DECREF(result); }
8674 Py_DECREF(obj);
9437 Py_DECREF(obj);
8675 return;
9438 return;
9439 } else {
9440 PyErr_Clear();
8676 }
9441 }
8677 }
9442 }
8678 srecFileWidget::reloadFile();
9443 srecFileWidget::reloadFile();
8679 }
9444 }
8680 void PythonQtShell_srecFileWidget::setFile(abstractBinFile* file)
9445 void PythonQtShell_srecFileWidget::setFile(abstractBinFile* file0)
8681 {
9446 {
8682 if (_wrapper) {
9447 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8683 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
9448 static PyObject* name = PyString_FromString("setFile");
8684 PyErr_Clear();
9449 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8685 if (obj && !PythonQtSlotFunction_Check(obj)) {
9450 if (obj) {
8686 static const char* argumentList[] ={"" , "abstractBinFile*"};
9451 static const char* argumentList[] ={"" , "abstractBinFile*"};
8687 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9452 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8688 void* args[2] = {NULL, (void*)&file};
9453 void* args[2] = {NULL, (void*)&file0};
8689 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9454 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8690 if (result) { Py_DECREF(result); }
9455 if (result) { Py_DECREF(result); }
8691 Py_DECREF(obj);
9456 Py_DECREF(obj);
8692 return;
9457 return;
8693 }
9458 } else {
8694 }
9459 PyErr_Clear();
8695 srecFileWidget::setFile(file);
9460 }
9461 }
9462 srecFileWidget::setFile(file0);
8696 }
9463 }
8697 srecFileWidget* PythonQtWrapper_srecFileWidget::new_srecFileWidget(QWidget* parent)
9464 srecFileWidget* PythonQtWrapper_srecFileWidget::new_srecFileWidget(QWidget* parent)
8698 {
9465 {
Show file before | Show file after | Hide comments
@@ -1,5 +1,4
1 #include <PythonQt.h>
1 #include <PythonQt.h>
2 #include <QIconEngine>
3 #include <QObject>
2 #include <QObject>
4 #include <QVariant>
3 #include <QVariant>
5 #include <SocExplorerPlot.h>
4 #include <SocExplorerPlot.h>
@@ -13,6 +12,7
13 #include <genericbinaryfilewidget.h>
12 #include <genericbinaryfilewidget.h>
14 #include <memsizewdgt.h>
13 #include <memsizewdgt.h>
15 #include <qaction.h>
14 #include <qaction.h>
15 #include <qbackingstore.h>
16 #include <qbitmap.h>
16 #include <qbitmap.h>
17 #include <qbytearray.h>
17 #include <qbytearray.h>
18 #include <qcolor.h>
18 #include <qcolor.h>
@@ -25,12 +25,14
25 #include <qgraphicsproxywidget.h>
25 #include <qgraphicsproxywidget.h>
26 #include <qhexedit.h>
26 #include <qhexedit.h>
27 #include <qhexspinbox.h>
27 #include <qhexspinbox.h>
28 #include <qicon.h>
28 #include <qkeysequence.h>
29 #include <qkeysequence.h>
29 #include <qlayout.h>
30 #include <qlayout.h>
30 #include <qlineedit.h>
31 #include <qlineedit.h>
31 #include <qlist.h>
32 #include <qlist.h>
32 #include <qlocale.h>
33 #include <qlocale.h>
33 #include <qmargins.h>
34 #include <qmargins.h>
35 #include <qmetaobject.h>
34 #include <qobject.h>
36 #include <qobject.h>
35 #include <qpaintdevice.h>
37 #include <qpaintdevice.h>
36 #include <qpaintengine.h>
38 #include <qpaintengine.h>
@@ -50,6 +52,7
50 #include <qstyle.h>
52 #include <qstyle.h>
51 #include <qstyleoption.h>
53 #include <qstyleoption.h>
52 #include <qwidget.h>
54 #include <qwidget.h>
55 #include <qwindow.h>
53 #include <srecfile.h>
56 #include <srecfile.h>
54 #include <srecfilewidget.h>
57 #include <srecfilewidget.h>
55 #include <tcp_terminal_client.h>
58 #include <tcp_terminal_client.h>
@@ -60,8 +63,8
60 class PythonQtShell_ElfFile : public ElfFile
63 class PythonQtShell_ElfFile : public ElfFile
61 {
64 {
62 public:
65 public:
63 PythonQtShell_ElfFile():ElfFile(),_wrapper(NULL) {};
66 PythonQtShell_ElfFile():ElfFile(),_wrapper(NULL) { };
64 PythonQtShell_ElfFile(const QString& File):ElfFile(File),_wrapper(NULL) {};
67 PythonQtShell_ElfFile(const QString& File):ElfFile(File),_wrapper(NULL) { };
65
68
66 ~PythonQtShell_ElfFile();
69 ~PythonQtShell_ElfFile();
67
70
@@ -126,7 +129,9 void delete_ElfFile(ElfFile* obj) { dele
126 QString getSymbolType(ElfFile* theWrappedObject, int index);
129 QString getSymbolType(ElfFile* theWrappedObject, int index);
127 QString getType(ElfFile* theWrappedObject);
130 QString getType(ElfFile* theWrappedObject);
128 qint64 getVersion(ElfFile* theWrappedObject);
131 qint64 getVersion(ElfFile* theWrappedObject);
132 bool isBigEndian(ElfFile* theWrappedObject);
129 bool static_ElfFile_isElf(const QString& File);
133 bool static_ElfFile_isElf(const QString& File);
134 bool isLitleEndian(ElfFile* theWrappedObject);
130 bool iself(ElfFile* theWrappedObject);
135 bool iself(ElfFile* theWrappedObject);
131 bool isopened(ElfFile* theWrappedObject);
136 bool isopened(ElfFile* theWrappedObject);
132 bool openFile(ElfFile* theWrappedObject, const QString& File);
137 bool openFile(ElfFile* theWrappedObject, const QString& File);
@@ -142,8 +147,8 void delete_ElfFile(ElfFile* obj) { dele
142 class PythonQtShell_MemSizeWdgt : public MemSizeWdgt
147 class PythonQtShell_MemSizeWdgt : public MemSizeWdgt
143 {
148 {
144 public:
149 public:
145 PythonQtShell_MemSizeWdgt(QWidget* parent = 0):MemSizeWdgt(parent),_wrapper(NULL) {};
150 PythonQtShell_MemSizeWdgt(QWidget* parent = 0):MemSizeWdgt(parent),_wrapper(NULL) { };
146 PythonQtShell_MemSizeWdgt(int defaultSize, QWidget* parent = 0):MemSizeWdgt(defaultSize, parent),_wrapper(NULL) {};
151 PythonQtShell_MemSizeWdgt(int defaultSize, QWidget* parent = 0):MemSizeWdgt(defaultSize, parent),_wrapper(NULL) { };
147
152
148 ~PythonQtShell_MemSizeWdgt();
153 ~PythonQtShell_MemSizeWdgt();
149
154
@@ -215,7 +220,7 void delete_MemSizeWdgt(MemSizeWdgt* obj
215 class PythonQtShell_QHexEdit : public QHexEdit
220 class PythonQtShell_QHexEdit : public QHexEdit
216 {
221 {
217 public:
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 ~PythonQtShell_QHexEdit();
225 ~PythonQtShell_QHexEdit();
221
226
@@ -315,7 +320,7 void delete_QHexEdit(QHexEdit* obj) { de
315 class PythonQtShell_QHexSpinBox : public QHexSpinBox
320 class PythonQtShell_QHexSpinBox : public QHexSpinBox
316 {
321 {
317 public:
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 ~PythonQtShell_QHexSpinBox();
325 ~PythonQtShell_QHexSpinBox();
321
326
@@ -398,7 +403,7 void delete_QHexSpinBox(QHexSpinBox* obj
398 class PythonQtShell_SocExplorerPlot : public SocExplorerPlot
403 class PythonQtShell_SocExplorerPlot : public SocExplorerPlot
399 {
404 {
400 public:
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 ~PythonQtShell_SocExplorerPlot();
408 ~PythonQtShell_SocExplorerPlot();
404
409
@@ -500,7 +505,7 void delete_SocExplorerPlot(SocExplorerP
500 class PythonQtShell_TCP_Terminal_Client : public TCP_Terminal_Client
505 class PythonQtShell_TCP_Terminal_Client : public TCP_Terminal_Client
501 {
506 {
502 public:
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 ~PythonQtShell_TCP_Terminal_Client();
510 ~PythonQtShell_TCP_Terminal_Client();
506
511
@@ -566,7 +571,7 void delete_XByteArray(XByteArray* obj)
566 class PythonQtShell_abstractBinFile : public abstractBinFile
571 class PythonQtShell_abstractBinFile : public abstractBinFile
567 {
572 {
568 public:
573 public:
569 PythonQtShell_abstractBinFile():abstractBinFile(),_wrapper(NULL) {};
574 PythonQtShell_abstractBinFile():abstractBinFile(),_wrapper(NULL) { };
570
575
571 ~PythonQtShell_abstractBinFile();
576 ~PythonQtShell_abstractBinFile();
572
577
@@ -585,12 +590,30 virtual bool toSrec(const QString& Fil
585 PythonQtInstanceWrapper* _wrapper;
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 class PythonQtWrapper_abstractBinFile : public QObject
603 class PythonQtWrapper_abstractBinFile : public QObject
589 { Q_OBJECT
604 { Q_OBJECT
590 public:
605 public:
591 public slots:
606 public slots:
592 abstractBinFile* new_abstractBinFile();
607 abstractBinFile* new_abstractBinFile();
593 void delete_abstractBinFile(abstractBinFile* obj) { delete obj; }
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 class PythonQtShell_abstractBinFileWidget : public abstractBinFileWidget
623 class PythonQtShell_abstractBinFileWidget : public abstractBinFileWidget
601 {
624 {
602 public:
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 ~PythonQtShell_abstractBinFileWidget();
628 ~PythonQtShell_abstractBinFileWidget();
606
629
@@ -654,12 +677,20 virtual void wheelEvent(QWheelEvent* ar
654 PythonQtInstanceWrapper* _wrapper;
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 class PythonQtWrapper_abstractBinFileWidget : public QObject
686 class PythonQtWrapper_abstractBinFileWidget : public QObject
658 { Q_OBJECT
687 { Q_OBJECT
659 public:
688 public:
660 public slots:
689 public slots:
661 abstractBinFileWidget* new_abstractBinFileWidget(QWidget* parent = 0);
690 abstractBinFileWidget* new_abstractBinFileWidget(QWidget* parent = 0);
662 void delete_abstractBinFileWidget(abstractBinFileWidget* obj) { delete obj; }
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 class PythonQtShell_binaryFile : public binaryFile
700 class PythonQtShell_binaryFile : public binaryFile
670 {
701 {
671 public:
702 public:
672 PythonQtShell_binaryFile():binaryFile(),_wrapper(NULL) {};
703 PythonQtShell_binaryFile():binaryFile(),_wrapper(NULL) { };
673 PythonQtShell_binaryFile(const QString& File):binaryFile(File),_wrapper(NULL) {};
704 PythonQtShell_binaryFile(const QString& File):binaryFile(File),_wrapper(NULL) { };
674 PythonQtShell_binaryFile(const QStringList& Files):binaryFile(Files),_wrapper(NULL) {};
705 PythonQtShell_binaryFile(const QStringList& Files):binaryFile(Files),_wrapper(NULL) { };
675
706
676 ~PythonQtShell_binaryFile();
707 ~PythonQtShell_binaryFile();
677
708
@@ -726,7 +757,7 void delete_binaryFile(binaryFile* obj)
726 class PythonQtShell_binaryFileWidget : public binaryFileWidget
757 class PythonQtShell_binaryFileWidget : public binaryFileWidget
727 {
758 {
728 public:
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 ~PythonQtShell_binaryFileWidget();
762 ~PythonQtShell_binaryFileWidget();
732
763
@@ -759,8 +790,8 void delete_binaryFileWidget(binaryFileW
759 class PythonQtShell_codeFragment : public codeFragment
790 class PythonQtShell_codeFragment : public codeFragment
760 {
791 {
761 public:
792 public:
762 PythonQtShell_codeFragment():codeFragment(),_wrapper(NULL) {};
793 PythonQtShell_codeFragment():codeFragment(),_wrapper(NULL) { };
763 PythonQtShell_codeFragment(char* data, quint64 size, quint64 address):codeFragment(data, size, address),_wrapper(NULL) {};
794 PythonQtShell_codeFragment(char* data, quint64 size, quint64 address):codeFragment(data, size, address),_wrapper(NULL) { };
764
795
765 ~PythonQtShell_codeFragment();
796 ~PythonQtShell_codeFragment();
766
797
@@ -775,14 +806,14 public slots:
775 codeFragment* new_codeFragment();
806 codeFragment* new_codeFragment();
776 codeFragment* new_codeFragment(char* data, quint64 size, quint64 address);
807 codeFragment* new_codeFragment(char* data, quint64 size, quint64 address);
777 void delete_codeFragment(codeFragment* obj) { delete obj; }
808 void delete_codeFragment(codeFragment* obj) { delete obj; }
778 void py_set_size(codeFragment* theWrappedObject, quint64 size){ theWrappedObject->size = size; }
809 void py_set_address(codeFragment* theWrappedObject, quint64 address){ theWrappedObject->address = address; }
779 quint64 py_get_size(codeFragment* theWrappedObject){ return theWrappedObject->size; }
810 quint64 py_get_address(codeFragment* theWrappedObject){ return theWrappedObject->address; }
780 void py_set_data(codeFragment* theWrappedObject, char* data){ theWrappedObject->data = data; }
811 void py_set_data(codeFragment* theWrappedObject, char* data){ theWrappedObject->data = data; }
781 char* py_get_data(codeFragment* theWrappedObject){ return theWrappedObject->data; }
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 void py_set_header(codeFragment* theWrappedObject, QString header){ theWrappedObject->header = header; }
813 void py_set_header(codeFragment* theWrappedObject, QString header){ theWrappedObject->header = header; }
785 QString py_get_header(codeFragment* theWrappedObject){ return theWrappedObject->header; }
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 class PythonQtShell_elfFileWidget : public elfFileWidget
823 class PythonQtShell_elfFileWidget : public elfFileWidget
793 {
824 {
794 public:
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 ~PythonQtShell_elfFileWidget();
828 ~PythonQtShell_elfFileWidget();
798
829
@@ -825,7 +856,7 void delete_elfFileWidget(elfFileWidget*
825 class PythonQtShell_elfInfoWdgt : public elfInfoWdgt
856 class PythonQtShell_elfInfoWdgt : public elfInfoWdgt
826 {
857 {
827 public:
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 ~PythonQtShell_elfInfoWdgt();
861 ~PythonQtShell_elfInfoWdgt();
831
862
@@ -931,7 +962,7 void delete_elfparser(elfparser* obj) {
931 class PythonQtShell_genericBinaryFileWidget : public genericBinaryFileWidget
962 class PythonQtShell_genericBinaryFileWidget : public genericBinaryFileWidget
932 {
963 {
933 public:
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 ~PythonQtShell_genericBinaryFileWidget();
967 ~PythonQtShell_genericBinaryFileWidget();
937
968
@@ -998,9 +1029,9 void delete_genericBinaryFileWidget(gene
998 class PythonQtShell_srecFile : public srecFile
1029 class PythonQtShell_srecFile : public srecFile
999 {
1030 {
1000 public:
1031 public:
1001 PythonQtShell_srecFile():srecFile(),_wrapper(NULL) {};
1032 PythonQtShell_srecFile():srecFile(),_wrapper(NULL) { };
1002 PythonQtShell_srecFile(const QString& File):srecFile(File),_wrapper(NULL) {};
1033 PythonQtShell_srecFile(const QString& File):srecFile(File),_wrapper(NULL) { };
1003 PythonQtShell_srecFile(const QStringList& Files):srecFile(Files),_wrapper(NULL) {};
1034 PythonQtShell_srecFile(const QStringList& Files):srecFile(Files),_wrapper(NULL) { };
1004
1035
1005 ~PythonQtShell_srecFile();
1036 ~PythonQtShell_srecFile();
1006
1037
@@ -1061,7 +1092,7 void delete_srecFile(srecFile* obj) { de
1061 class PythonQtShell_srecFileWidget : public srecFileWidget
1092 class PythonQtShell_srecFileWidget : public srecFileWidget
1062 {
1093 {
1063 public:
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 ~PythonQtShell_srecFileWidget();
1097 ~PythonQtShell_srecFileWidget();
1067
1098
Show file before | Show file after | Hide comments
@@ -1,7 +1,9
1 #include <PythonQt.h>
1 #include <PythonQt.h>
2 #include <PythonQtConversion.h>
2 #include "PySocExplorer0.h"
3 #include "PySocExplorer0.h"
3
4
4
5
6
5 void PythonQt_init_PySocExplorer(PyObject* module) {
7 void PythonQt_init_PySocExplorer(PyObject* module) {
6 PythonQt::priv()->registerClass(&ElfFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_ElfFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_ElfFile>, module, 0);
8 PythonQt::priv()->registerClass(&ElfFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_ElfFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_ElfFile>, module, 0);
7 PythonQt::self()->addParentClass("ElfFile", "abstractBinFile",PythonQtUpcastingOffset<ElfFile,abstractBinFile>());
9 PythonQt::self()->addParentClass("ElfFile", "abstractBinFile",PythonQtUpcastingOffset<ElfFile,abstractBinFile>());
@@ -28,4 +30,5 PythonQt::self()->addParentClass("srecFi
28 PythonQt::priv()->registerClass(&srecFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_srecFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_srecFileWidget>, module, 0);
30 PythonQt::priv()->registerClass(&srecFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_srecFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_srecFileWidget>, module, 0);
29 PythonQt::self()->addParentClass("srecFileWidget", "abstractBinFileWidget",PythonQtUpcastingOffset<srecFileWidget,abstractBinFileWidget>());
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 #include <QStringList>
30 #include <QStringList>
31 #include <QFile>
31 #include <QFile>
32
32
33 void usage();
33
34
34 int main(int argc, char *argv[])
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 QApplication a(argc, argv);
37 QApplication a(argc, argv);
41 QString scriptToEval;
38 QString scriptToEval;
42 QStringList args= a.arguments();
39 QStringList args= a.arguments();
@@ -69,3 +66,10 int main(int argc, char *argv[])
69 w.show();
66 w.show();
70 return a.exec();
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 this->makeLayout();
32 this->makeLayout();
33 this->makeMenu();
33 this->makeMenu();
34 this->makeConnections();
34 this->makeConnections();
35 this->setWindowIcon(QIcon(tr(":/images/icon.png")));
35 this->setWindowIcon(QIcon(":/images/icon.png"));
36 this->setAcceptDrops(true);
36 this->setAcceptDrops(true);
37 this->pluginManager->setRootLoadable(true);
37 this->pluginManager->setRootLoadable(true);
38 this->PythonConsoleInst->pyConsoleRunFile(ScriptToEval);
38 this->PythonConsoleInst->pyConsoleRunFile(ScriptToEval);
General Comments 0
You need to be logged in to leave comments. Login now