##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » SocExplorer
RSS
Some fixes on python plugin interface.
jeandet -
r85:d64b77b3d5df default
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,10 +1,36
1 1 #!/usr/bin/lppmon -e
2 2
3 3 class test(PySocExplorerEngine.socexplorerplugin):
4 m_Layout = QtGui.QGridLayout()
5 m_CenterWidget = QtGui.QWidget()
6 m_hexviewer = PySocExplorer.QHexEdit()
7 m_addressQSPB = PySocExplorer.QHexSpinBox()
8 m_readQPB = QtGui.QPushButton("read")
9 m_writeQPB = QtGui.QPushButton("write")
10
11 def postInstantiationTrigger(self):
12 print "building GUI"
13 self.setWidget(self.m_CenterWidget)
14 self.m_CenterWidget.setLayout(self.m_Layout)
15 self.m_Layout.addWidget(self.m_addressQSPB,0,0,1,1)
16 self.m_Layout.addWidget(self.m_readQPB,0,1,1,1)
17 self.m_Layout.addWidget(self.m_writeQPB,0,2,1,1)
18 self.m_Layout.addWidget(self.m_hexviewer,1,0,1,-1)
4 19 def hello(self):
5 20 print "hello"
6 21 def VID(self):
7 22 return 10
8 23 def PID(self):
9 24 return 100
25 def readData(self):
26 bufferQBA = QtCore.QByteArray()
27 buffer = self.parentPlugin().Read(self.m_addressQSPB.value,16*1024)
28 for i in range(0,16*1024):
29 bufferQBA.append(int(buffer[i]))
30 bufferQBA.append(int(buffer[i]))
31 bufferQBA.append(int(buffer[i]))
32 bufferQBA.append(int(buffer[i]))
33 self.m_hexviewer.setData(bufferQBA)
10 34
35
36
Show file before | Show file after | Hide comments
@@ -1,179 +1,181
1 1 /*------------------------------------------------------------------------------
2 2 ███████╗ ██████╗ ██████╗ ███████╗██╗ ██╗██████╗ ██╗ ██████╗ ██████╗ ███████╗██████╗
3 3 ██╔════╝██╔═══██╗██╔════╝ ██╔════╝╚██╗██╔╝██╔══██╗██║ ██╔═══██╗██╔══██╗██╔════╝██╔══██╗
4 4 ███████╗██║ ██║██║ █████╗ ╚███╔╝ ██████╔╝██║ ██║ ██║██████╔╝█████╗ ██████╔╝
5 5 ╚════██║██║ ██║██║ ██╔══╝ ██╔██╗ ██╔═══╝ ██║ ██║ ██║██╔══██╗██╔══╝ ██╔══██╗
6 6 ███████║╚██████╔╝╚██████╗ ███████╗██╔╝ ██╗██║ ███████╗╚██████╔╝██║ ██║███████╗██║ ██║
7 7 ╚══════╝ ╚═════╝ ╚═════╝ ╚══════╝╚═╝ ╚═╝╚═╝ ╚══════╝ ╚═════╝ ╚═╝ ╚═╝╚══════╝╚═╝ ╚═╝
8 8
9 9 -- This file is a part of the SOC Explorer Software
10 10 -- Copyright (C) 2011, Plasma Physics Laboratory - CNRS
11 11 --
12 12 -- This program is free software; you can redistribute it and/or modify
13 13 -- it under the terms of the GNU General Public License as published by
14 14 -- the Free Software Foundation; either version 2 of the License, or
15 15 -- (at your option) any later version.
16 16 --
17 17 -- This program is distributed in the hope that it will be useful,
18 18 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
19 19 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 20 -- GNU General Public License for more details.
21 21 --
22 22 -- You should have received a copy of the GNU General Public License
23 23 -- along with this program; if not, write to the Free Software
24 24 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 -------------------------------------------------------------------------------*/
26 26 /*-- Author : Alexis Jeandet
27 27 -- Mail : alexis.jeandet@lpp.polytechnique.fr
28 28 ----------------------------------------------------------------------------*/
29 29 #ifndef SOCEXPLORERPLUGIN_H
30 30 #define SOCEXPLORERPLUGIN_H
31 31 #include <QWidget>
32 32 #include <QAction>
33 33 #include <QDockWidget>
34 34 #include <QMainWindow>
35 35 #include <QList>
36 36 #include <QMenu>
37 37 #include <socexplorer.h>
38 38 #include <QObject>
39 39 #include <QVariant>
40 40 #include <QVariantList>
41 41 #include <malloc.h>
42 42 #include <QFile>
43 43 #include <stdint.h>
44 44 #include <QTextStream>
45 45 #include <abstractbinfile.h>
46 46 #ifndef driver_Name
47 47 #define driver_Name "Plugin"
48 48 #endif
49 49 #ifndef driver_Author
50 50 #define driver_Author "No Author"
51 51 #endif
52 52 #ifndef driver_Version
53 53 #define driver_Version "0.0.0"
54 54 #endif
55 55 #ifndef driver_Description
56 56 #define driver_Description "No description."
57 57 #endif
58 58 #ifndef driver_can_be_root
59 59 #define driver_can_be_root 0
60 60 #endif
61 61 #ifndef driver_can_be_child
62 62 #define driver_can_be_child 0
63 63 #endif
64 64 #ifndef driver_VID
65 65 #define driver_VID 0
66 66 #endif
67 67 #ifndef driver_PID
68 68 #define driver_PID 0
69 69 #endif
70 70
71 71 #if defined(SOCEXPLORER_SDK_BUILD)
72 72 # define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
73 73 #else
74 74 # define SOCEXPLORER_SDK_EXPORT Q_DECL_IMPORT
75 75 #endif
76 76
77 77
78 78 //! socexplorerplugin is the base class for any SocExplorer plugin, it gives a standard interface to communicate
79 79 //! between each plugins and to interact with SocExplorer software.
80 80
81 81 class SOCEXPLORER_SDK_EXPORT socexplorerplugin : public QDockWidget
82 82 {
83 83 Q_OBJECT
84 84 public:
85 85 //! Default plugin constructor, any plugin should call this constructor.
86 86 socexplorerplugin(QWidget *parent = 0,bool createPyObject=true):QDockWidget(parent)
87 87 {
88 88 closeAction=NULL;
89 89 menu=NULL;
90 90 ChildsMenu=NULL;
91 91 this->Connected = false;
92 92 this->setFeatures(QDockWidget::DockWidgetMovable|QDockWidget::DockWidgetFloatable|QDockWidget::DockWidgetVerticalTitleBar);
93 93 _Name = new QString(driver_Name);
94 94 _Author = new QString(driver_Author);
95 95 _Version = new QString(driver_Version);
96 96 _Description = new QString(driver_Description);
97 97 _canBeChild = driver_can_be_child;
98 98 _canBeRoot = driver_can_be_root;
99 99 _VID = driver_VID;
100 100 _PID = driver_PID;
101 101 }
102 102 //! Tells if the plugin is connected, it is used to enable or disable all childrens interfaces.
103 103 virtual int isConnected();
104 104 //! Gives the associated Vendor IDentifier, usefull to automatically associate plugins with found
105 105 //! hardware while board enumeration.
106 106 virtual int VID(){return _PID;}
107 107 //! Gives the associated Product IDentifier, usefull to automatically associate plugins with found
108 108 //! hardware while board enumeration.
109 109 virtual int PID(){return _VID;}
110 110 //! Gives the plugin's base name, usefull to automatically generate instance name.
111 111 virtual QString baseName();
112 112 //! Gives the base address of the current instance, for example if your plugin is supposed to drive
113 113 //! an UART it will correspond to the address of it's first register. This address have at least to
114 114 //! be set by SocExplorer and it can be user accessible if you want.
115 115 virtual int baseAddress();
116 116 //! Sets the base address of the current instance, for example if your plugin is supposed to drive
117 117 //! an UART it will correspond to the address of it's first register. This address have at least to
118 118 //! be set by SocExplorer and it can be user accessible if you want.
119 119 virtual void setBaseAddress(unsigned int baseAddress);
120 120
121 121 QList<socexplorerplugin*> childs;
122 122 socexplorerplugin* parent;
123 123 QAction* closeAction;
124 124 QString instanceName();
125 125 QString instance(){return instanceName();}
126 126 QMenu* menu;
127 127 QMenu* ChildsMenu;
128 128
129 129 signals:
130 130 //! Signal emited each time the plugin is about to be closed.
131 131 void closePlugin(socexplorerplugin* driver);
132 132 void activateSig(bool flag);
133 133 void registerObject(QObject* object,const QString& instanceName);
134 134
135 135 public slots:
136 136 virtual int registermenu(QMenu* menu);
137 137 virtual void postInstantiationTrigger();
138 138 //! Write slot this is the way your children plugins ask you for writing data.
139 139 //! If your plugin is supposed to have childern drivers you should implement this methode.
140 140 //! By default this methode forward the write request to the parent plugin.
141 141 //! \param Value Pointer the data buffer.
142 142 //! \param count Number of 32 bits words you should to write.
143 143 //! \param address Address from where you should to start to write.
144 144 //! \return Quantity of 32 bits words writtens.
145 145 virtual unsigned int Write(unsigned int* Value, unsigned int count,unsigned int address);
146 146 //! Read slot this is the way your children plugins ask you for reading data.
147 147 //! If your plugin is supposed to have childern drivers you should implement this methode.
148 148 //! By default this methode forward the write request to the parent plugin.
149 149 //! \param Value Pointer the data buffer.
150 150 //! \param count Number of 32 bits words you should to read.
151 151 //! \param address Address from where you should to start to read.
152 152 //! \return Quantity of 32 bits words read.
153 153 virtual unsigned int Read(unsigned int* Value, unsigned int count,unsigned int address);
154 154 virtual void closeMe();
155 155 virtual void activate(bool flag);
156 156 virtual void setInstanceName(const QString& newName);
157 157
158 158 virtual bool dumpMemory(unsigned int address,unsigned int count,QString file);
159 159 virtual bool memSet(unsigned int address,int value, unsigned int count);
160 160 virtual bool loadbin(unsigned int address,QString file);
161 161 virtual bool loadfile(abstractBinFile* file);
162 162 virtual bool dumpMemory(unsigned int address,unsigned int count,QString file,const QString& format);
163 163 QVariantList Read(unsigned int address, unsigned int count);
164 164 void Write(unsigned int address, QList<QVariant> dataList);
165 socexplorerplugin* parentPlugin(){return this->parent;}
166 socexplorerplugin* toPlugin(){return (socexplorerplugin*)this;}
165 167 protected:
166 168 int BaseAddress;
167 169 bool Connected;
168 170 QString* _Name;
169 171 QString* _Author;
170 172 QString* _Version;
171 173 QString* _Description;
172 174 QString _instanceName;
173 175 int _canBeChild;
174 176 int _canBeRoot;
175 177 int _VID;
176 178 int _PID;
177 179 };
178 180
179 181 #endif // SOCEXPLORERPLUGIN_H
Show file before | Show file after | Hide comments
@@ -1,16 +1,15
1 1 <typesystem package="PySocExplorerEngine" default-superclass="com.trolltech.qt.QtJambiObject">
2 2 <load-typesystem name=":/trolltech/generator/typesystem_core.txt" generate="no" />
3 3 <load-typesystem name=":/trolltech/generator/typesystem_gui.txt" generate="no" />
4 4 <load-typesystem name=":/trolltech/generator/typesystem_network.txt" generate="no" />
5 5
6 6 <interface-type name="socexplorerplugin"/>
7
8 7 </typesystem>
9 8
10 9
11 10
12 11
13 12
14 13
15 14
16 15
Show file before | Show file after | Hide comments
@@ -1,9478 +1,9498
1 1 #include "PySocExplorer0.h"
2 2 #include <PythonQtConversion.h>
3 3 #include <PythonQtMethodInfo.h>
4 4 #include <PythonQtSignalReceiver.h>
5 5 #include <QVariant>
6 6 #include <abstractbinfile.h>
7 7 #include <elfparser.h>
8 8 #include <qaction.h>
9 9 #include <qbackingstore.h>
10 10 #include <qbitmap.h>
11 11 #include <qbytearray.h>
12 12 #include <qcolor.h>
13 13 #include <qcoreevent.h>
14 14 #include <qcursor.h>
15 15 #include <qevent.h>
16 16 #include <qfile.h>
17 17 #include <qfont.h>
18 18 #include <qgraphicseffect.h>
19 19 #include <qgraphicsproxywidget.h>
20 20 #include <qicon.h>
21 21 #include <qkeysequence.h>
22 22 #include <qlayout.h>
23 23 #include <qlineedit.h>
24 24 #include <qlist.h>
25 25 #include <qlocale.h>
26 26 #include <qmargins.h>
27 27 #include <qmetaobject.h>
28 28 #include <qobject.h>
29 29 #include <qpaintdevice.h>
30 30 #include <qpaintengine.h>
31 31 #include <qpainter.h>
32 32 #include <qpalette.h>
33 33 #include <qpen.h>
34 34 #include <qpixmap.h>
35 35 #include <qpoint.h>
36 36 #include <qrect.h>
37 37 #include <qregion.h>
38 38 #include <qscrollarea.h>
39 39 #include <qscrollbar.h>
40 40 #include <qsize.h>
41 41 #include <qsizepolicy.h>
42 42 #include <qspinbox.h>
43 43 #include <qstringlist.h>
44 44 #include <qstyle.h>
45 45 #include <qstyleoption.h>
46 46 #include <qwidget.h>
47 47 #include <qwindow.h>
48 48
49 49 PythonQtShell_ElfFile::~PythonQtShell_ElfFile() {
50 50 PythonQtPrivate* priv = PythonQt::priv();
51 51 if (priv) { priv->shellClassDeleted(this); }
52 52 }
53 53 int PythonQtShell_ElfFile::closeFile()
54 54 {
55 55 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
56 56 static PyObject* name = PyString_FromString("closeFile");
57 57 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
58 58 if (obj) {
59 59 static const char* argumentList[] ={"int"};
60 60 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
61 61 int returnValue;
62 62 void* args[1] = {NULL};
63 63 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
64 64 if (result) {
65 65 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
66 66 if (args[0]!=&returnValue) {
67 67 if (args[0]==NULL) {
68 68 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
69 69 } else {
70 70 returnValue = *((int*)args[0]);
71 71 }
72 72 }
73 73 }
74 74 if (result) { Py_DECREF(result); }
75 75 Py_DECREF(obj);
76 76 return returnValue;
77 77 } else {
78 78 PyErr_Clear();
79 79 }
80 80 }
81 81 return ElfFile::closeFile();
82 82 }
83 83 QList<codeFragment* > PythonQtShell_ElfFile::getFragments()
84 84 {
85 85 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
86 86 static PyObject* name = PyString_FromString("getFragments");
87 87 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
88 88 if (obj) {
89 89 static const char* argumentList[] ={"QList<codeFragment* >"};
90 90 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
91 91 QList<codeFragment* > returnValue;
92 92 void* args[1] = {NULL};
93 93 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
94 94 if (result) {
95 95 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
96 96 if (args[0]!=&returnValue) {
97 97 if (args[0]==NULL) {
98 98 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
99 99 } else {
100 100 returnValue = *((QList<codeFragment* >*)args[0]);
101 101 }
102 102 }
103 103 }
104 104 if (result) { Py_DECREF(result); }
105 105 Py_DECREF(obj);
106 106 return returnValue;
107 107 } else {
108 108 PyErr_Clear();
109 109 }
110 110 }
111 111 return ElfFile::getFragments();
112 112 }
113 113 bool PythonQtShell_ElfFile::isopened()
114 114 {
115 115 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
116 116 static PyObject* name = PyString_FromString("isopened");
117 117 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
118 118 if (obj) {
119 119 static const char* argumentList[] ={"bool"};
120 120 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
121 121 bool returnValue;
122 122 void* args[1] = {NULL};
123 123 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
124 124 if (result) {
125 125 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
126 126 if (args[0]!=&returnValue) {
127 127 if (args[0]==NULL) {
128 128 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
129 129 } else {
130 130 returnValue = *((bool*)args[0]);
131 131 }
132 132 }
133 133 }
134 134 if (result) { Py_DECREF(result); }
135 135 Py_DECREF(obj);
136 136 return returnValue;
137 137 } else {
138 138 PyErr_Clear();
139 139 }
140 140 }
141 141 return ElfFile::isopened();
142 142 }
143 143 bool PythonQtShell_ElfFile::openFile(const QString& File0)
144 144 {
145 145 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
146 146 static PyObject* name = PyString_FromString("openFile");
147 147 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
148 148 if (obj) {
149 149 static const char* argumentList[] ={"bool" , "const QString&"};
150 150 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
151 151 bool returnValue;
152 152 void* args[2] = {NULL, (void*)&File0};
153 153 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
154 154 if (result) {
155 155 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
156 156 if (args[0]!=&returnValue) {
157 157 if (args[0]==NULL) {
158 158 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
159 159 } else {
160 160 returnValue = *((bool*)args[0]);
161 161 }
162 162 }
163 163 }
164 164 if (result) { Py_DECREF(result); }
165 165 Py_DECREF(obj);
166 166 return returnValue;
167 167 } else {
168 168 PyErr_Clear();
169 169 }
170 170 }
171 171 return ElfFile::openFile(File0);
172 172 }
173 173 bool PythonQtShell_ElfFile::toBinary(const QString& File0)
174 174 {
175 175 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
176 176 static PyObject* name = PyString_FromString("toBinary");
177 177 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
178 178 if (obj) {
179 179 static const char* argumentList[] ={"bool" , "const QString&"};
180 180 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
181 181 bool returnValue;
182 182 void* args[2] = {NULL, (void*)&File0};
183 183 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
184 184 if (result) {
185 185 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
186 186 if (args[0]!=&returnValue) {
187 187 if (args[0]==NULL) {
188 188 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
189 189 } else {
190 190 returnValue = *((bool*)args[0]);
191 191 }
192 192 }
193 193 }
194 194 if (result) { Py_DECREF(result); }
195 195 Py_DECREF(obj);
196 196 return returnValue;
197 197 } else {
198 198 PyErr_Clear();
199 199 }
200 200 }
201 201 return ElfFile::toBinary(File0);
202 202 }
203 203 bool PythonQtShell_ElfFile::toSrec(const QString& File0)
204 204 {
205 205 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
206 206 static PyObject* name = PyString_FromString("toSrec");
207 207 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
208 208 if (obj) {
209 209 static const char* argumentList[] ={"bool" , "const QString&"};
210 210 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
211 211 bool returnValue;
212 212 void* args[2] = {NULL, (void*)&File0};
213 213 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
214 214 if (result) {
215 215 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
216 216 if (args[0]!=&returnValue) {
217 217 if (args[0]==NULL) {
218 218 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
219 219 } else {
220 220 returnValue = *((bool*)args[0]);
221 221 }
222 222 }
223 223 }
224 224 if (result) { Py_DECREF(result); }
225 225 Py_DECREF(obj);
226 226 return returnValue;
227 227 } else {
228 228 PyErr_Clear();
229 229 }
230 230 }
231 231 return ElfFile::toSrec(File0);
232 232 }
233 233 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile()
234 234 {
235 235 return new PythonQtShell_ElfFile(); }
236 236
237 237 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile(const QString& File)
238 238 {
239 239 return new PythonQtShell_ElfFile(File); }
240 240
241 241 int PythonQtWrapper_ElfFile::closeFile(ElfFile* theWrappedObject)
242 242 {
243 243 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_closeFile());
244 244 }
245 245
246 246 QString PythonQtWrapper_ElfFile::getABI(ElfFile* theWrappedObject)
247 247 {
248 248 return ( theWrappedObject->getABI());
249 249 }
250 250
251 251 QString PythonQtWrapper_ElfFile::getArchitecture(ElfFile* theWrappedObject)
252 252 {
253 253 return ( theWrappedObject->getArchitecture());
254 254 }
255 255
256 256 QString PythonQtWrapper_ElfFile::getClass(ElfFile* theWrappedObject)
257 257 {
258 258 return ( theWrappedObject->getClass());
259 259 }
260 260
261 261 QString PythonQtWrapper_ElfFile::getEndianness(ElfFile* theWrappedObject)
262 262 {
263 263 return ( theWrappedObject->getEndianness());
264 264 }
265 265
266 266 qint64 PythonQtWrapper_ElfFile::getEntryPointAddress(ElfFile* theWrappedObject)
267 267 {
268 268 return ( theWrappedObject->getEntryPointAddress());
269 269 }
270 270
271 271 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject)
272 272 {
273 273 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_getFragments());
274 274 }
275 275
276 276 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject, QStringList fragmentList)
277 277 {
278 278 return ( theWrappedObject->getFragments(fragmentList));
279 279 }
280 280
281 281 int PythonQtWrapper_ElfFile::getSectionCount(ElfFile* theWrappedObject)
282 282 {
283 283 return ( theWrappedObject->getSectionCount());
284 284 }
285 285
286 286 bool PythonQtWrapper_ElfFile::getSectionData(ElfFile* theWrappedObject, int index, char** buffer)
287 287 {
288 288 return ( theWrappedObject->getSectionData(index, buffer));
289 289 }
290 290
291 291 qint64 PythonQtWrapper_ElfFile::getSectionDatasz(ElfFile* theWrappedObject, int index)
292 292 {
293 293 return ( theWrappedObject->getSectionDatasz(index));
294 294 }
295 295
296 296 int PythonQtWrapper_ElfFile::getSectionIndex(ElfFile* theWrappedObject, QString name)
297 297 {
298 298 return ( theWrappedObject->getSectionIndex(name));
299 299 }
300 300
301 301 qint64 PythonQtWrapper_ElfFile::getSectionMemsz(ElfFile* theWrappedObject, int index)
302 302 {
303 303 return ( theWrappedObject->getSectionMemsz(index));
304 304 }
305 305
306 306 QString PythonQtWrapper_ElfFile::getSectionName(ElfFile* theWrappedObject, int index)
307 307 {
308 308 return ( theWrappedObject->getSectionName(index));
309 309 }
310 310
311 311 qint64 PythonQtWrapper_ElfFile::getSectionPaddr(ElfFile* theWrappedObject, int index)
312 312 {
313 313 return ( theWrappedObject->getSectionPaddr(index));
314 314 }
315 315
316 316 QString PythonQtWrapper_ElfFile::getSectionType(ElfFile* theWrappedObject, int index)
317 317 {
318 318 return ( theWrappedObject->getSectionType(index));
319 319 }
320 320
321 321 int PythonQtWrapper_ElfFile::getSegmentCount(ElfFile* theWrappedObject)
322 322 {
323 323 return ( theWrappedObject->getSegmentCount());
324 324 }
325 325
326 326 qint64 PythonQtWrapper_ElfFile::getSegmentFilesz(ElfFile* theWrappedObject, int index)
327 327 {
328 328 return ( theWrappedObject->getSegmentFilesz(index));
329 329 }
330 330
331 331 QString PythonQtWrapper_ElfFile::getSegmentFlags(ElfFile* theWrappedObject, int index)
332 332 {
333 333 return ( theWrappedObject->getSegmentFlags(index));
334 334 }
335 335
336 336 qint64 PythonQtWrapper_ElfFile::getSegmentMemsz(ElfFile* theWrappedObject, int index)
337 337 {
338 338 return ( theWrappedObject->getSegmentMemsz(index));
339 339 }
340 340
341 341 qint64 PythonQtWrapper_ElfFile::getSegmentOffset(ElfFile* theWrappedObject, int index)
342 342 {
343 343 return ( theWrappedObject->getSegmentOffset(index));
344 344 }
345 345
346 346 qint64 PythonQtWrapper_ElfFile::getSegmentPaddr(ElfFile* theWrappedObject, int index)
347 347 {
348 348 return ( theWrappedObject->getSegmentPaddr(index));
349 349 }
350 350
351 351 QString PythonQtWrapper_ElfFile::getSegmentType(ElfFile* theWrappedObject, int index)
352 352 {
353 353 return ( theWrappedObject->getSegmentType(index));
354 354 }
355 355
356 356 qint64 PythonQtWrapper_ElfFile::getSegmentVaddr(ElfFile* theWrappedObject, int index)
357 357 {
358 358 return ( theWrappedObject->getSegmentVaddr(index));
359 359 }
360 360
361 361 quint64 PythonQtWrapper_ElfFile::getSymbolAddress(ElfFile* theWrappedObject, int index)
362 362 {
363 363 return ( theWrappedObject->getSymbolAddress(index));
364 364 }
365 365
366 366 int PythonQtWrapper_ElfFile::getSymbolCount(ElfFile* theWrappedObject)
367 367 {
368 368 return ( theWrappedObject->getSymbolCount());
369 369 }
370 370
371 371 QString PythonQtWrapper_ElfFile::getSymbolLinkType(ElfFile* theWrappedObject, int index)
372 372 {
373 373 return ( theWrappedObject->getSymbolLinkType(index));
374 374 }
375 375
376 376 QString PythonQtWrapper_ElfFile::getSymbolName(ElfFile* theWrappedObject, int index)
377 377 {
378 378 return ( theWrappedObject->getSymbolName(index));
379 379 }
380 380
381 381 int PythonQtWrapper_ElfFile::getSymbolSectionIndex(ElfFile* theWrappedObject, int index)
382 382 {
383 383 return ( theWrappedObject->getSymbolSectionIndex(index));
384 384 }
385 385
386 386 QString PythonQtWrapper_ElfFile::getSymbolSectionName(ElfFile* theWrappedObject, int index)
387 387 {
388 388 return ( theWrappedObject->getSymbolSectionName(index));
389 389 }
390 390
391 391 quint64 PythonQtWrapper_ElfFile::getSymbolSize(ElfFile* theWrappedObject, int index)
392 392 {
393 393 return ( theWrappedObject->getSymbolSize(index));
394 394 }
395 395
396 396 QString PythonQtWrapper_ElfFile::getSymbolType(ElfFile* theWrappedObject, int index)
397 397 {
398 398 return ( theWrappedObject->getSymbolType(index));
399 399 }
400 400
401 401 QString PythonQtWrapper_ElfFile::getType(ElfFile* theWrappedObject)
402 402 {
403 403 return ( theWrappedObject->getType());
404 404 }
405 405
406 406 qint64 PythonQtWrapper_ElfFile::getVersion(ElfFile* theWrappedObject)
407 407 {
408 408 return ( theWrappedObject->getVersion());
409 409 }
410 410
411 411 bool PythonQtWrapper_ElfFile::isBigEndian(ElfFile* theWrappedObject)
412 412 {
413 413 return ( theWrappedObject->isBigEndian());
414 414 }
415 415
416 416 bool PythonQtWrapper_ElfFile::static_ElfFile_isElf(const QString& File)
417 417 {
418 418 return (ElfFile::isElf(File));
419 419 }
420 420
421 421 bool PythonQtWrapper_ElfFile::isLitleEndian(ElfFile* theWrappedObject)
422 422 {
423 423 return ( theWrappedObject->isLitleEndian());
424 424 }
425 425
426 426 bool PythonQtWrapper_ElfFile::iself(ElfFile* theWrappedObject)
427 427 {
428 428 return ( theWrappedObject->iself());
429 429 }
430 430
431 431 bool PythonQtWrapper_ElfFile::isopened(ElfFile* theWrappedObject)
432 432 {
433 433 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_isopened());
434 434 }
435 435
436 436 bool PythonQtWrapper_ElfFile::openFile(ElfFile* theWrappedObject, const QString& File)
437 437 {
438 438 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_openFile(File));
439 439 }
440 440
441 441 bool PythonQtWrapper_ElfFile::sectionIsNobits(ElfFile* theWrappedObject, int index)
442 442 {
443 443 return ( theWrappedObject->sectionIsNobits(index));
444 444 }
445 445
446 446 bool PythonQtWrapper_ElfFile::toBinary(ElfFile* theWrappedObject, const QString& File)
447 447 {
448 448 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_toBinary(File));
449 449 }
450 450
451 451 bool PythonQtWrapper_ElfFile::toSrec(ElfFile* theWrappedObject, const QString& File)
452 452 {
453 453 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_toSrec(File));
454 454 }
455 455
456 456
457 457
458 458 PythonQtShell_MemSizeWdgt::~PythonQtShell_MemSizeWdgt() {
459 459 PythonQtPrivate* priv = PythonQt::priv();
460 460 if (priv) { priv->shellClassDeleted(this); }
461 461 }
462 462 void PythonQtShell_MemSizeWdgt::actionEvent(QActionEvent* arg__1)
463 463 {
464 464 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
465 465 static PyObject* name = PyString_FromString("actionEvent");
466 466 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
467 467 if (obj) {
468 468 static const char* argumentList[] ={"" , "QActionEvent*"};
469 469 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
470 470 void* args[2] = {NULL, (void*)&arg__1};
471 471 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
472 472 if (result) { Py_DECREF(result); }
473 473 Py_DECREF(obj);
474 474 return;
475 475 } else {
476 476 PyErr_Clear();
477 477 }
478 478 }
479 479 MemSizeWdgt::actionEvent(arg__1);
480 480 }
481 481 void PythonQtShell_MemSizeWdgt::changeEvent(QEvent* arg__1)
482 482 {
483 483 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
484 484 static PyObject* name = PyString_FromString("changeEvent");
485 485 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
486 486 if (obj) {
487 487 static const char* argumentList[] ={"" , "QEvent*"};
488 488 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
489 489 void* args[2] = {NULL, (void*)&arg__1};
490 490 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
491 491 if (result) { Py_DECREF(result); }
492 492 Py_DECREF(obj);
493 493 return;
494 494 } else {
495 495 PyErr_Clear();
496 496 }
497 497 }
498 498 MemSizeWdgt::changeEvent(arg__1);
499 499 }
500 500 void PythonQtShell_MemSizeWdgt::childEvent(QChildEvent* arg__1)
501 501 {
502 502 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
503 503 static PyObject* name = PyString_FromString("childEvent");
504 504 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
505 505 if (obj) {
506 506 static const char* argumentList[] ={"" , "QChildEvent*"};
507 507 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
508 508 void* args[2] = {NULL, (void*)&arg__1};
509 509 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
510 510 if (result) { Py_DECREF(result); }
511 511 Py_DECREF(obj);
512 512 return;
513 513 } else {
514 514 PyErr_Clear();
515 515 }
516 516 }
517 517 MemSizeWdgt::childEvent(arg__1);
518 518 }
519 519 void PythonQtShell_MemSizeWdgt::closeEvent(QCloseEvent* arg__1)
520 520 {
521 521 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
522 522 static PyObject* name = PyString_FromString("closeEvent");
523 523 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
524 524 if (obj) {
525 525 static const char* argumentList[] ={"" , "QCloseEvent*"};
526 526 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
527 527 void* args[2] = {NULL, (void*)&arg__1};
528 528 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
529 529 if (result) { Py_DECREF(result); }
530 530 Py_DECREF(obj);
531 531 return;
532 532 } else {
533 533 PyErr_Clear();
534 534 }
535 535 }
536 536 MemSizeWdgt::closeEvent(arg__1);
537 537 }
538 538 void PythonQtShell_MemSizeWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
539 539 {
540 540 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
541 541 static PyObject* name = PyString_FromString("contextMenuEvent");
542 542 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
543 543 if (obj) {
544 544 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
545 545 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
546 546 void* args[2] = {NULL, (void*)&arg__1};
547 547 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
548 548 if (result) { Py_DECREF(result); }
549 549 Py_DECREF(obj);
550 550 return;
551 551 } else {
552 552 PyErr_Clear();
553 553 }
554 554 }
555 555 MemSizeWdgt::contextMenuEvent(arg__1);
556 556 }
557 557 void PythonQtShell_MemSizeWdgt::customEvent(QEvent* arg__1)
558 558 {
559 559 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
560 560 static PyObject* name = PyString_FromString("customEvent");
561 561 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
562 562 if (obj) {
563 563 static const char* argumentList[] ={"" , "QEvent*"};
564 564 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
565 565 void* args[2] = {NULL, (void*)&arg__1};
566 566 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
567 567 if (result) { Py_DECREF(result); }
568 568 Py_DECREF(obj);
569 569 return;
570 570 } else {
571 571 PyErr_Clear();
572 572 }
573 573 }
574 574 MemSizeWdgt::customEvent(arg__1);
575 575 }
576 576 int PythonQtShell_MemSizeWdgt::devType() const
577 577 {
578 578 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
579 579 static PyObject* name = PyString_FromString("devType");
580 580 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
581 581 if (obj) {
582 582 static const char* argumentList[] ={"int"};
583 583 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
584 584 int returnValue;
585 585 void* args[1] = {NULL};
586 586 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
587 587 if (result) {
588 588 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
589 589 if (args[0]!=&returnValue) {
590 590 if (args[0]==NULL) {
591 591 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
592 592 } else {
593 593 returnValue = *((int*)args[0]);
594 594 }
595 595 }
596 596 }
597 597 if (result) { Py_DECREF(result); }
598 598 Py_DECREF(obj);
599 599 return returnValue;
600 600 } else {
601 601 PyErr_Clear();
602 602 }
603 603 }
604 604 return MemSizeWdgt::devType();
605 605 }
606 606 void PythonQtShell_MemSizeWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
607 607 {
608 608 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
609 609 static PyObject* name = PyString_FromString("dragEnterEvent");
610 610 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
611 611 if (obj) {
612 612 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
613 613 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
614 614 void* args[2] = {NULL, (void*)&arg__1};
615 615 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
616 616 if (result) { Py_DECREF(result); }
617 617 Py_DECREF(obj);
618 618 return;
619 619 } else {
620 620 PyErr_Clear();
621 621 }
622 622 }
623 623 MemSizeWdgt::dragEnterEvent(arg__1);
624 624 }
625 625 void PythonQtShell_MemSizeWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
626 626 {
627 627 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
628 628 static PyObject* name = PyString_FromString("dragLeaveEvent");
629 629 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
630 630 if (obj) {
631 631 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
632 632 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
633 633 void* args[2] = {NULL, (void*)&arg__1};
634 634 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
635 635 if (result) { Py_DECREF(result); }
636 636 Py_DECREF(obj);
637 637 return;
638 638 } else {
639 639 PyErr_Clear();
640 640 }
641 641 }
642 642 MemSizeWdgt::dragLeaveEvent(arg__1);
643 643 }
644 644 void PythonQtShell_MemSizeWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
645 645 {
646 646 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
647 647 static PyObject* name = PyString_FromString("dragMoveEvent");
648 648 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
649 649 if (obj) {
650 650 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
651 651 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
652 652 void* args[2] = {NULL, (void*)&arg__1};
653 653 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
654 654 if (result) { Py_DECREF(result); }
655 655 Py_DECREF(obj);
656 656 return;
657 657 } else {
658 658 PyErr_Clear();
659 659 }
660 660 }
661 661 MemSizeWdgt::dragMoveEvent(arg__1);
662 662 }
663 663 void PythonQtShell_MemSizeWdgt::dropEvent(QDropEvent* arg__1)
664 664 {
665 665 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
666 666 static PyObject* name = PyString_FromString("dropEvent");
667 667 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
668 668 if (obj) {
669 669 static const char* argumentList[] ={"" , "QDropEvent*"};
670 670 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
671 671 void* args[2] = {NULL, (void*)&arg__1};
672 672 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
673 673 if (result) { Py_DECREF(result); }
674 674 Py_DECREF(obj);
675 675 return;
676 676 } else {
677 677 PyErr_Clear();
678 678 }
679 679 }
680 680 MemSizeWdgt::dropEvent(arg__1);
681 681 }
682 682 void PythonQtShell_MemSizeWdgt::enterEvent(QEvent* arg__1)
683 683 {
684 684 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
685 685 static PyObject* name = PyString_FromString("enterEvent");
686 686 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
687 687 if (obj) {
688 688 static const char* argumentList[] ={"" , "QEvent*"};
689 689 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
690 690 void* args[2] = {NULL, (void*)&arg__1};
691 691 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
692 692 if (result) { Py_DECREF(result); }
693 693 Py_DECREF(obj);
694 694 return;
695 695 } else {
696 696 PyErr_Clear();
697 697 }
698 698 }
699 699 MemSizeWdgt::enterEvent(arg__1);
700 700 }
701 701 bool PythonQtShell_MemSizeWdgt::event(QEvent* arg__1)
702 702 {
703 703 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
704 704 static PyObject* name = PyString_FromString("event");
705 705 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
706 706 if (obj) {
707 707 static const char* argumentList[] ={"bool" , "QEvent*"};
708 708 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
709 709 bool returnValue;
710 710 void* args[2] = {NULL, (void*)&arg__1};
711 711 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
712 712 if (result) {
713 713 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
714 714 if (args[0]!=&returnValue) {
715 715 if (args[0]==NULL) {
716 716 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
717 717 } else {
718 718 returnValue = *((bool*)args[0]);
719 719 }
720 720 }
721 721 }
722 722 if (result) { Py_DECREF(result); }
723 723 Py_DECREF(obj);
724 724 return returnValue;
725 725 } else {
726 726 PyErr_Clear();
727 727 }
728 728 }
729 729 return MemSizeWdgt::event(arg__1);
730 730 }
731 731 bool PythonQtShell_MemSizeWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
732 732 {
733 733 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
734 734 static PyObject* name = PyString_FromString("eventFilter");
735 735 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
736 736 if (obj) {
737 737 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
738 738 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
739 739 bool returnValue;
740 740 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
741 741 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
742 742 if (result) {
743 743 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
744 744 if (args[0]!=&returnValue) {
745 745 if (args[0]==NULL) {
746 746 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
747 747 } else {
748 748 returnValue = *((bool*)args[0]);
749 749 }
750 750 }
751 751 }
752 752 if (result) { Py_DECREF(result); }
753 753 Py_DECREF(obj);
754 754 return returnValue;
755 755 } else {
756 756 PyErr_Clear();
757 757 }
758 758 }
759 759 return MemSizeWdgt::eventFilter(arg__1, arg__2);
760 760 }
761 761 void PythonQtShell_MemSizeWdgt::focusInEvent(QFocusEvent* arg__1)
762 762 {
763 763 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
764 764 static PyObject* name = PyString_FromString("focusInEvent");
765 765 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
766 766 if (obj) {
767 767 static const char* argumentList[] ={"" , "QFocusEvent*"};
768 768 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
769 769 void* args[2] = {NULL, (void*)&arg__1};
770 770 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
771 771 if (result) { Py_DECREF(result); }
772 772 Py_DECREF(obj);
773 773 return;
774 774 } else {
775 775 PyErr_Clear();
776 776 }
777 777 }
778 778 MemSizeWdgt::focusInEvent(arg__1);
779 779 }
780 780 bool PythonQtShell_MemSizeWdgt::focusNextPrevChild(bool next0)
781 781 {
782 782 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
783 783 static PyObject* name = PyString_FromString("focusNextPrevChild");
784 784 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
785 785 if (obj) {
786 786 static const char* argumentList[] ={"bool" , "bool"};
787 787 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
788 788 bool returnValue;
789 789 void* args[2] = {NULL, (void*)&next0};
790 790 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
791 791 if (result) {
792 792 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
793 793 if (args[0]!=&returnValue) {
794 794 if (args[0]==NULL) {
795 795 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
796 796 } else {
797 797 returnValue = *((bool*)args[0]);
798 798 }
799 799 }
800 800 }
801 801 if (result) { Py_DECREF(result); }
802 802 Py_DECREF(obj);
803 803 return returnValue;
804 804 } else {
805 805 PyErr_Clear();
806 806 }
807 807 }
808 808 return MemSizeWdgt::focusNextPrevChild(next0);
809 809 }
810 810 void PythonQtShell_MemSizeWdgt::focusOutEvent(QFocusEvent* arg__1)
811 811 {
812 812 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
813 813 static PyObject* name = PyString_FromString("focusOutEvent");
814 814 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
815 815 if (obj) {
816 816 static const char* argumentList[] ={"" , "QFocusEvent*"};
817 817 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
818 818 void* args[2] = {NULL, (void*)&arg__1};
819 819 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
820 820 if (result) { Py_DECREF(result); }
821 821 Py_DECREF(obj);
822 822 return;
823 823 } else {
824 824 PyErr_Clear();
825 825 }
826 826 }
827 827 MemSizeWdgt::focusOutEvent(arg__1);
828 828 }
829 829 bool PythonQtShell_MemSizeWdgt::hasHeightForWidth() const
830 830 {
831 831 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
832 832 static PyObject* name = PyString_FromString("hasHeightForWidth");
833 833 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
834 834 if (obj) {
835 835 static const char* argumentList[] ={"bool"};
836 836 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
837 837 bool returnValue;
838 838 void* args[1] = {NULL};
839 839 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
840 840 if (result) {
841 841 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
842 842 if (args[0]!=&returnValue) {
843 843 if (args[0]==NULL) {
844 844 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
845 845 } else {
846 846 returnValue = *((bool*)args[0]);
847 847 }
848 848 }
849 849 }
850 850 if (result) { Py_DECREF(result); }
851 851 Py_DECREF(obj);
852 852 return returnValue;
853 853 } else {
854 854 PyErr_Clear();
855 855 }
856 856 }
857 857 return MemSizeWdgt::hasHeightForWidth();
858 858 }
859 859 int PythonQtShell_MemSizeWdgt::heightForWidth(int arg__1) const
860 860 {
861 861 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
862 862 static PyObject* name = PyString_FromString("heightForWidth");
863 863 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
864 864 if (obj) {
865 865 static const char* argumentList[] ={"int" , "int"};
866 866 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
867 867 int returnValue;
868 868 void* args[2] = {NULL, (void*)&arg__1};
869 869 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
870 870 if (result) {
871 871 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
872 872 if (args[0]!=&returnValue) {
873 873 if (args[0]==NULL) {
874 874 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
875 875 } else {
876 876 returnValue = *((int*)args[0]);
877 877 }
878 878 }
879 879 }
880 880 if (result) { Py_DECREF(result); }
881 881 Py_DECREF(obj);
882 882 return returnValue;
883 883 } else {
884 884 PyErr_Clear();
885 885 }
886 886 }
887 887 return MemSizeWdgt::heightForWidth(arg__1);
888 888 }
889 889 void PythonQtShell_MemSizeWdgt::hideEvent(QHideEvent* arg__1)
890 890 {
891 891 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
892 892 static PyObject* name = PyString_FromString("hideEvent");
893 893 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
894 894 if (obj) {
895 895 static const char* argumentList[] ={"" , "QHideEvent*"};
896 896 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
897 897 void* args[2] = {NULL, (void*)&arg__1};
898 898 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
899 899 if (result) { Py_DECREF(result); }
900 900 Py_DECREF(obj);
901 901 return;
902 902 } else {
903 903 PyErr_Clear();
904 904 }
905 905 }
906 906 MemSizeWdgt::hideEvent(arg__1);
907 907 }
908 908 void PythonQtShell_MemSizeWdgt::initPainter(QPainter* painter0) const
909 909 {
910 910 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
911 911 static PyObject* name = PyString_FromString("initPainter");
912 912 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
913 913 if (obj) {
914 914 static const char* argumentList[] ={"" , "QPainter*"};
915 915 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
916 916 void* args[2] = {NULL, (void*)&painter0};
917 917 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
918 918 if (result) { Py_DECREF(result); }
919 919 Py_DECREF(obj);
920 920 return;
921 921 } else {
922 922 PyErr_Clear();
923 923 }
924 924 }
925 925 MemSizeWdgt::initPainter(painter0);
926 926 }
927 927 void PythonQtShell_MemSizeWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
928 928 {
929 929 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
930 930 static PyObject* name = PyString_FromString("inputMethodEvent");
931 931 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
932 932 if (obj) {
933 933 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
934 934 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
935 935 void* args[2] = {NULL, (void*)&arg__1};
936 936 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
937 937 if (result) { Py_DECREF(result); }
938 938 Py_DECREF(obj);
939 939 return;
940 940 } else {
941 941 PyErr_Clear();
942 942 }
943 943 }
944 944 MemSizeWdgt::inputMethodEvent(arg__1);
945 945 }
946 946 QVariant PythonQtShell_MemSizeWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
947 947 {
948 948 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
949 949 static PyObject* name = PyString_FromString("inputMethodQuery");
950 950 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
951 951 if (obj) {
952 952 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
953 953 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
954 954 QVariant returnValue;
955 955 void* args[2] = {NULL, (void*)&arg__1};
956 956 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
957 957 if (result) {
958 958 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
959 959 if (args[0]!=&returnValue) {
960 960 if (args[0]==NULL) {
961 961 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
962 962 } else {
963 963 returnValue = *((QVariant*)args[0]);
964 964 }
965 965 }
966 966 }
967 967 if (result) { Py_DECREF(result); }
968 968 Py_DECREF(obj);
969 969 return returnValue;
970 970 } else {
971 971 PyErr_Clear();
972 972 }
973 973 }
974 974 return MemSizeWdgt::inputMethodQuery(arg__1);
975 975 }
976 976 void PythonQtShell_MemSizeWdgt::keyPressEvent(QKeyEvent* arg__1)
977 977 {
978 978 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
979 979 static PyObject* name = PyString_FromString("keyPressEvent");
980 980 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
981 981 if (obj) {
982 982 static const char* argumentList[] ={"" , "QKeyEvent*"};
983 983 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
984 984 void* args[2] = {NULL, (void*)&arg__1};
985 985 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
986 986 if (result) { Py_DECREF(result); }
987 987 Py_DECREF(obj);
988 988 return;
989 989 } else {
990 990 PyErr_Clear();
991 991 }
992 992 }
993 993 MemSizeWdgt::keyPressEvent(arg__1);
994 994 }
995 995 void PythonQtShell_MemSizeWdgt::keyReleaseEvent(QKeyEvent* arg__1)
996 996 {
997 997 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
998 998 static PyObject* name = PyString_FromString("keyReleaseEvent");
999 999 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1000 1000 if (obj) {
1001 1001 static const char* argumentList[] ={"" , "QKeyEvent*"};
1002 1002 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1003 1003 void* args[2] = {NULL, (void*)&arg__1};
1004 1004 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1005 1005 if (result) { Py_DECREF(result); }
1006 1006 Py_DECREF(obj);
1007 1007 return;
1008 1008 } else {
1009 1009 PyErr_Clear();
1010 1010 }
1011 1011 }
1012 1012 MemSizeWdgt::keyReleaseEvent(arg__1);
1013 1013 }
1014 1014 void PythonQtShell_MemSizeWdgt::leaveEvent(QEvent* arg__1)
1015 1015 {
1016 1016 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1017 1017 static PyObject* name = PyString_FromString("leaveEvent");
1018 1018 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1019 1019 if (obj) {
1020 1020 static const char* argumentList[] ={"" , "QEvent*"};
1021 1021 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1022 1022 void* args[2] = {NULL, (void*)&arg__1};
1023 1023 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1024 1024 if (result) { Py_DECREF(result); }
1025 1025 Py_DECREF(obj);
1026 1026 return;
1027 1027 } else {
1028 1028 PyErr_Clear();
1029 1029 }
1030 1030 }
1031 1031 MemSizeWdgt::leaveEvent(arg__1);
1032 1032 }
1033 1033 int PythonQtShell_MemSizeWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
1034 1034 {
1035 1035 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1036 1036 static PyObject* name = PyString_FromString("metric");
1037 1037 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1038 1038 if (obj) {
1039 1039 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
1040 1040 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1041 1041 int returnValue;
1042 1042 void* args[2] = {NULL, (void*)&arg__1};
1043 1043 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1044 1044 if (result) {
1045 1045 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1046 1046 if (args[0]!=&returnValue) {
1047 1047 if (args[0]==NULL) {
1048 1048 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
1049 1049 } else {
1050 1050 returnValue = *((int*)args[0]);
1051 1051 }
1052 1052 }
1053 1053 }
1054 1054 if (result) { Py_DECREF(result); }
1055 1055 Py_DECREF(obj);
1056 1056 return returnValue;
1057 1057 } else {
1058 1058 PyErr_Clear();
1059 1059 }
1060 1060 }
1061 1061 return MemSizeWdgt::metric(arg__1);
1062 1062 }
1063 1063 QSize PythonQtShell_MemSizeWdgt::minimumSizeHint() const
1064 1064 {
1065 1065 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1066 1066 static PyObject* name = PyString_FromString("getMinimumSizeHint");
1067 1067 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1068 1068 if (obj) {
1069 1069 static const char* argumentList[] ={"QSize"};
1070 1070 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1071 1071 QSize returnValue;
1072 1072 void* args[1] = {NULL};
1073 1073 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1074 1074 if (result) {
1075 1075 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1076 1076 if (args[0]!=&returnValue) {
1077 1077 if (args[0]==NULL) {
1078 1078 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
1079 1079 } else {
1080 1080 returnValue = *((QSize*)args[0]);
1081 1081 }
1082 1082 }
1083 1083 }
1084 1084 if (result) { Py_DECREF(result); }
1085 1085 Py_DECREF(obj);
1086 1086 return returnValue;
1087 1087 } else {
1088 1088 PyErr_Clear();
1089 1089 }
1090 1090 }
1091 1091 return MemSizeWdgt::minimumSizeHint();
1092 1092 }
1093 1093 void PythonQtShell_MemSizeWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
1094 1094 {
1095 1095 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1096 1096 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
1097 1097 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1098 1098 if (obj) {
1099 1099 static const char* argumentList[] ={"" , "QMouseEvent*"};
1100 1100 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1101 1101 void* args[2] = {NULL, (void*)&arg__1};
1102 1102 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1103 1103 if (result) { Py_DECREF(result); }
1104 1104 Py_DECREF(obj);
1105 1105 return;
1106 1106 } else {
1107 1107 PyErr_Clear();
1108 1108 }
1109 1109 }
1110 1110 MemSizeWdgt::mouseDoubleClickEvent(arg__1);
1111 1111 }
1112 1112 void PythonQtShell_MemSizeWdgt::mouseMoveEvent(QMouseEvent* arg__1)
1113 1113 {
1114 1114 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1115 1115 static PyObject* name = PyString_FromString("mouseMoveEvent");
1116 1116 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1117 1117 if (obj) {
1118 1118 static const char* argumentList[] ={"" , "QMouseEvent*"};
1119 1119 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1120 1120 void* args[2] = {NULL, (void*)&arg__1};
1121 1121 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1122 1122 if (result) { Py_DECREF(result); }
1123 1123 Py_DECREF(obj);
1124 1124 return;
1125 1125 } else {
1126 1126 PyErr_Clear();
1127 1127 }
1128 1128 }
1129 1129 MemSizeWdgt::mouseMoveEvent(arg__1);
1130 1130 }
1131 1131 void PythonQtShell_MemSizeWdgt::mousePressEvent(QMouseEvent* arg__1)
1132 1132 {
1133 1133 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1134 1134 static PyObject* name = PyString_FromString("mousePressEvent");
1135 1135 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1136 1136 if (obj) {
1137 1137 static const char* argumentList[] ={"" , "QMouseEvent*"};
1138 1138 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1139 1139 void* args[2] = {NULL, (void*)&arg__1};
1140 1140 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1141 1141 if (result) { Py_DECREF(result); }
1142 1142 Py_DECREF(obj);
1143 1143 return;
1144 1144 } else {
1145 1145 PyErr_Clear();
1146 1146 }
1147 1147 }
1148 1148 MemSizeWdgt::mousePressEvent(arg__1);
1149 1149 }
1150 1150 void PythonQtShell_MemSizeWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
1151 1151 {
1152 1152 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1153 1153 static PyObject* name = PyString_FromString("mouseReleaseEvent");
1154 1154 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1155 1155 if (obj) {
1156 1156 static const char* argumentList[] ={"" , "QMouseEvent*"};
1157 1157 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1158 1158 void* args[2] = {NULL, (void*)&arg__1};
1159 1159 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1160 1160 if (result) { Py_DECREF(result); }
1161 1161 Py_DECREF(obj);
1162 1162 return;
1163 1163 } else {
1164 1164 PyErr_Clear();
1165 1165 }
1166 1166 }
1167 1167 MemSizeWdgt::mouseReleaseEvent(arg__1);
1168 1168 }
1169 1169 void PythonQtShell_MemSizeWdgt::moveEvent(QMoveEvent* arg__1)
1170 1170 {
1171 1171 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1172 1172 static PyObject* name = PyString_FromString("moveEvent");
1173 1173 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1174 1174 if (obj) {
1175 1175 static const char* argumentList[] ={"" , "QMoveEvent*"};
1176 1176 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1177 1177 void* args[2] = {NULL, (void*)&arg__1};
1178 1178 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1179 1179 if (result) { Py_DECREF(result); }
1180 1180 Py_DECREF(obj);
1181 1181 return;
1182 1182 } else {
1183 1183 PyErr_Clear();
1184 1184 }
1185 1185 }
1186 1186 MemSizeWdgt::moveEvent(arg__1);
1187 1187 }
1188 1188 bool PythonQtShell_MemSizeWdgt::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
1189 1189 {
1190 1190 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1191 1191 static PyObject* name = PyString_FromString("nativeEvent");
1192 1192 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1193 1193 if (obj) {
1194 1194 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
1195 1195 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
1196 1196 bool returnValue;
1197 1197 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
1198 1198 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1199 1199 if (result) {
1200 1200 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1201 1201 if (args[0]!=&returnValue) {
1202 1202 if (args[0]==NULL) {
1203 1203 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
1204 1204 } else {
1205 1205 returnValue = *((bool*)args[0]);
1206 1206 }
1207 1207 }
1208 1208 }
1209 1209 if (result) { Py_DECREF(result); }
1210 1210 Py_DECREF(obj);
1211 1211 return returnValue;
1212 1212 } else {
1213 1213 PyErr_Clear();
1214 1214 }
1215 1215 }
1216 1216 return MemSizeWdgt::nativeEvent(eventType0, message1, result2);
1217 1217 }
1218 1218 QPaintEngine* PythonQtShell_MemSizeWdgt::paintEngine() const
1219 1219 {
1220 1220 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1221 1221 static PyObject* name = PyString_FromString("paintEngine");
1222 1222 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1223 1223 if (obj) {
1224 1224 static const char* argumentList[] ={"QPaintEngine*"};
1225 1225 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1226 1226 QPaintEngine* returnValue;
1227 1227 void* args[1] = {NULL};
1228 1228 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1229 1229 if (result) {
1230 1230 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1231 1231 if (args[0]!=&returnValue) {
1232 1232 if (args[0]==NULL) {
1233 1233 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
1234 1234 } else {
1235 1235 returnValue = *((QPaintEngine**)args[0]);
1236 1236 }
1237 1237 }
1238 1238 }
1239 1239 if (result) { Py_DECREF(result); }
1240 1240 Py_DECREF(obj);
1241 1241 return returnValue;
1242 1242 } else {
1243 1243 PyErr_Clear();
1244 1244 }
1245 1245 }
1246 1246 return MemSizeWdgt::paintEngine();
1247 1247 }
1248 1248 void PythonQtShell_MemSizeWdgt::paintEvent(QPaintEvent* arg__1)
1249 1249 {
1250 1250 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1251 1251 static PyObject* name = PyString_FromString("paintEvent");
1252 1252 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1253 1253 if (obj) {
1254 1254 static const char* argumentList[] ={"" , "QPaintEvent*"};
1255 1255 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1256 1256 void* args[2] = {NULL, (void*)&arg__1};
1257 1257 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1258 1258 if (result) { Py_DECREF(result); }
1259 1259 Py_DECREF(obj);
1260 1260 return;
1261 1261 } else {
1262 1262 PyErr_Clear();
1263 1263 }
1264 1264 }
1265 1265 MemSizeWdgt::paintEvent(arg__1);
1266 1266 }
1267 1267 QPaintDevice* PythonQtShell_MemSizeWdgt::redirected(QPoint* offset0) const
1268 1268 {
1269 1269 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1270 1270 static PyObject* name = PyString_FromString("redirected");
1271 1271 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1272 1272 if (obj) {
1273 1273 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
1274 1274 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1275 1275 QPaintDevice* returnValue;
1276 1276 void* args[2] = {NULL, (void*)&offset0};
1277 1277 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1278 1278 if (result) {
1279 1279 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1280 1280 if (args[0]!=&returnValue) {
1281 1281 if (args[0]==NULL) {
1282 1282 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
1283 1283 } else {
1284 1284 returnValue = *((QPaintDevice**)args[0]);
1285 1285 }
1286 1286 }
1287 1287 }
1288 1288 if (result) { Py_DECREF(result); }
1289 1289 Py_DECREF(obj);
1290 1290 return returnValue;
1291 1291 } else {
1292 1292 PyErr_Clear();
1293 1293 }
1294 1294 }
1295 1295 return MemSizeWdgt::redirected(offset0);
1296 1296 }
1297 1297 void PythonQtShell_MemSizeWdgt::resizeEvent(QResizeEvent* arg__1)
1298 1298 {
1299 1299 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1300 1300 static PyObject* name = PyString_FromString("resizeEvent");
1301 1301 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1302 1302 if (obj) {
1303 1303 static const char* argumentList[] ={"" , "QResizeEvent*"};
1304 1304 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1305 1305 void* args[2] = {NULL, (void*)&arg__1};
1306 1306 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1307 1307 if (result) { Py_DECREF(result); }
1308 1308 Py_DECREF(obj);
1309 1309 return;
1310 1310 } else {
1311 1311 PyErr_Clear();
1312 1312 }
1313 1313 }
1314 1314 MemSizeWdgt::resizeEvent(arg__1);
1315 1315 }
1316 1316 QPainter* PythonQtShell_MemSizeWdgt::sharedPainter() const
1317 1317 {
1318 1318 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1319 1319 static PyObject* name = PyString_FromString("sharedPainter");
1320 1320 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1321 1321 if (obj) {
1322 1322 static const char* argumentList[] ={"QPainter*"};
1323 1323 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1324 1324 QPainter* returnValue;
1325 1325 void* args[1] = {NULL};
1326 1326 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1327 1327 if (result) {
1328 1328 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1329 1329 if (args[0]!=&returnValue) {
1330 1330 if (args[0]==NULL) {
1331 1331 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
1332 1332 } else {
1333 1333 returnValue = *((QPainter**)args[0]);
1334 1334 }
1335 1335 }
1336 1336 }
1337 1337 if (result) { Py_DECREF(result); }
1338 1338 Py_DECREF(obj);
1339 1339 return returnValue;
1340 1340 } else {
1341 1341 PyErr_Clear();
1342 1342 }
1343 1343 }
1344 1344 return MemSizeWdgt::sharedPainter();
1345 1345 }
1346 1346 void PythonQtShell_MemSizeWdgt::showEvent(QShowEvent* arg__1)
1347 1347 {
1348 1348 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1349 1349 static PyObject* name = PyString_FromString("showEvent");
1350 1350 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1351 1351 if (obj) {
1352 1352 static const char* argumentList[] ={"" , "QShowEvent*"};
1353 1353 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1354 1354 void* args[2] = {NULL, (void*)&arg__1};
1355 1355 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1356 1356 if (result) { Py_DECREF(result); }
1357 1357 Py_DECREF(obj);
1358 1358 return;
1359 1359 } else {
1360 1360 PyErr_Clear();
1361 1361 }
1362 1362 }
1363 1363 MemSizeWdgt::showEvent(arg__1);
1364 1364 }
1365 1365 QSize PythonQtShell_MemSizeWdgt::sizeHint() const
1366 1366 {
1367 1367 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1368 1368 static PyObject* name = PyString_FromString("getSizeHint");
1369 1369 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1370 1370 if (obj) {
1371 1371 static const char* argumentList[] ={"QSize"};
1372 1372 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1373 1373 QSize returnValue;
1374 1374 void* args[1] = {NULL};
1375 1375 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1376 1376 if (result) {
1377 1377 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1378 1378 if (args[0]!=&returnValue) {
1379 1379 if (args[0]==NULL) {
1380 1380 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
1381 1381 } else {
1382 1382 returnValue = *((QSize*)args[0]);
1383 1383 }
1384 1384 }
1385 1385 }
1386 1386 if (result) { Py_DECREF(result); }
1387 1387 Py_DECREF(obj);
1388 1388 return returnValue;
1389 1389 } else {
1390 1390 PyErr_Clear();
1391 1391 }
1392 1392 }
1393 1393 return MemSizeWdgt::sizeHint();
1394 1394 }
1395 1395 void PythonQtShell_MemSizeWdgt::tabletEvent(QTabletEvent* arg__1)
1396 1396 {
1397 1397 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1398 1398 static PyObject* name = PyString_FromString("tabletEvent");
1399 1399 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1400 1400 if (obj) {
1401 1401 static const char* argumentList[] ={"" , "QTabletEvent*"};
1402 1402 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1403 1403 void* args[2] = {NULL, (void*)&arg__1};
1404 1404 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1405 1405 if (result) { Py_DECREF(result); }
1406 1406 Py_DECREF(obj);
1407 1407 return;
1408 1408 } else {
1409 1409 PyErr_Clear();
1410 1410 }
1411 1411 }
1412 1412 MemSizeWdgt::tabletEvent(arg__1);
1413 1413 }
1414 1414 void PythonQtShell_MemSizeWdgt::timerEvent(QTimerEvent* arg__1)
1415 1415 {
1416 1416 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1417 1417 static PyObject* name = PyString_FromString("timerEvent");
1418 1418 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1419 1419 if (obj) {
1420 1420 static const char* argumentList[] ={"" , "QTimerEvent*"};
1421 1421 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1422 1422 void* args[2] = {NULL, (void*)&arg__1};
1423 1423 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1424 1424 if (result) { Py_DECREF(result); }
1425 1425 Py_DECREF(obj);
1426 1426 return;
1427 1427 } else {
1428 1428 PyErr_Clear();
1429 1429 }
1430 1430 }
1431 1431 MemSizeWdgt::timerEvent(arg__1);
1432 1432 }
1433 1433 void PythonQtShell_MemSizeWdgt::wheelEvent(QWheelEvent* arg__1)
1434 1434 {
1435 1435 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1436 1436 static PyObject* name = PyString_FromString("wheelEvent");
1437 1437 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1438 1438 if (obj) {
1439 1439 static const char* argumentList[] ={"" , "QWheelEvent*"};
1440 1440 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1441 1441 void* args[2] = {NULL, (void*)&arg__1};
1442 1442 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1443 1443 if (result) { Py_DECREF(result); }
1444 1444 Py_DECREF(obj);
1445 1445 return;
1446 1446 } else {
1447 1447 PyErr_Clear();
1448 1448 }
1449 1449 }
1450 1450 MemSizeWdgt::wheelEvent(arg__1);
1451 1451 }
1452 1452 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(QWidget* parent)
1453 1453 {
1454 1454 return new PythonQtShell_MemSizeWdgt(parent); }
1455 1455
1456 1456 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(int defaultSize, QWidget* parent)
1457 1457 {
1458 1458 return new PythonQtShell_MemSizeWdgt(defaultSize, parent); }
1459 1459
1460 1460 int PythonQtWrapper_MemSizeWdgt::getsize(MemSizeWdgt* theWrappedObject)
1461 1461 {
1462 1462 return ( theWrappedObject->getsize());
1463 1463 }
1464 1464
1465 1465 void PythonQtWrapper_MemSizeWdgt::setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max)
1466 1466 {
1467 1467 ( theWrappedObject->setMaximum(max));
1468 1468 }
1469 1469
1470 1470 void PythonQtWrapper_MemSizeWdgt::show(MemSizeWdgt* theWrappedObject)
1471 1471 {
1472 1472 ( theWrappedObject->show());
1473 1473 }
1474 1474
1475 1475 void PythonQtWrapper_MemSizeWdgt::updateSizeValue(MemSizeWdgt* theWrappedObject)
1476 1476 {
1477 1477 ( theWrappedObject->updateSizeValue());
1478 1478 }
1479 1479
1480 1480
1481 1481
1482 1482 PythonQtShell_QHexEdit::~PythonQtShell_QHexEdit() {
1483 1483 PythonQtPrivate* priv = PythonQt::priv();
1484 1484 if (priv) { priv->shellClassDeleted(this); }
1485 1485 }
1486 1486 void PythonQtShell_QHexEdit::actionEvent(QActionEvent* arg__1)
1487 1487 {
1488 1488 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1489 1489 static PyObject* name = PyString_FromString("actionEvent");
1490 1490 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1491 1491 if (obj) {
1492 1492 static const char* argumentList[] ={"" , "QActionEvent*"};
1493 1493 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1494 1494 void* args[2] = {NULL, (void*)&arg__1};
1495 1495 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1496 1496 if (result) { Py_DECREF(result); }
1497 1497 Py_DECREF(obj);
1498 1498 return;
1499 1499 } else {
1500 1500 PyErr_Clear();
1501 1501 }
1502 1502 }
1503 1503 QHexEdit::actionEvent(arg__1);
1504 1504 }
1505 1505 void PythonQtShell_QHexEdit::changeEvent(QEvent* arg__1)
1506 1506 {
1507 1507 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1508 1508 static PyObject* name = PyString_FromString("changeEvent");
1509 1509 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1510 1510 if (obj) {
1511 1511 static const char* argumentList[] ={"" , "QEvent*"};
1512 1512 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1513 1513 void* args[2] = {NULL, (void*)&arg__1};
1514 1514 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1515 1515 if (result) { Py_DECREF(result); }
1516 1516 Py_DECREF(obj);
1517 1517 return;
1518 1518 } else {
1519 1519 PyErr_Clear();
1520 1520 }
1521 1521 }
1522 1522 QHexEdit::changeEvent(arg__1);
1523 1523 }
1524 1524 void PythonQtShell_QHexEdit::childEvent(QChildEvent* arg__1)
1525 1525 {
1526 1526 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1527 1527 static PyObject* name = PyString_FromString("childEvent");
1528 1528 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1529 1529 if (obj) {
1530 1530 static const char* argumentList[] ={"" , "QChildEvent*"};
1531 1531 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1532 1532 void* args[2] = {NULL, (void*)&arg__1};
1533 1533 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1534 1534 if (result) { Py_DECREF(result); }
1535 1535 Py_DECREF(obj);
1536 1536 return;
1537 1537 } else {
1538 1538 PyErr_Clear();
1539 1539 }
1540 1540 }
1541 1541 QHexEdit::childEvent(arg__1);
1542 1542 }
1543 1543 void PythonQtShell_QHexEdit::closeEvent(QCloseEvent* arg__1)
1544 1544 {
1545 1545 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1546 1546 static PyObject* name = PyString_FromString("closeEvent");
1547 1547 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1548 1548 if (obj) {
1549 1549 static const char* argumentList[] ={"" , "QCloseEvent*"};
1550 1550 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1551 1551 void* args[2] = {NULL, (void*)&arg__1};
1552 1552 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1553 1553 if (result) { Py_DECREF(result); }
1554 1554 Py_DECREF(obj);
1555 1555 return;
1556 1556 } else {
1557 1557 PyErr_Clear();
1558 1558 }
1559 1559 }
1560 1560 QHexEdit::closeEvent(arg__1);
1561 1561 }
1562 1562 void PythonQtShell_QHexEdit::contextMenuEvent(QContextMenuEvent* arg__1)
1563 1563 {
1564 1564 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1565 1565 static PyObject* name = PyString_FromString("contextMenuEvent");
1566 1566 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1567 1567 if (obj) {
1568 1568 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
1569 1569 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1570 1570 void* args[2] = {NULL, (void*)&arg__1};
1571 1571 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1572 1572 if (result) { Py_DECREF(result); }
1573 1573 Py_DECREF(obj);
1574 1574 return;
1575 1575 } else {
1576 1576 PyErr_Clear();
1577 1577 }
1578 1578 }
1579 1579 QHexEdit::contextMenuEvent(arg__1);
1580 1580 }
1581 1581 void PythonQtShell_QHexEdit::customEvent(QEvent* arg__1)
1582 1582 {
1583 1583 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1584 1584 static PyObject* name = PyString_FromString("customEvent");
1585 1585 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1586 1586 if (obj) {
1587 1587 static const char* argumentList[] ={"" , "QEvent*"};
1588 1588 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1589 1589 void* args[2] = {NULL, (void*)&arg__1};
1590 1590 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1591 1591 if (result) { Py_DECREF(result); }
1592 1592 Py_DECREF(obj);
1593 1593 return;
1594 1594 } else {
1595 1595 PyErr_Clear();
1596 1596 }
1597 1597 }
1598 1598 QHexEdit::customEvent(arg__1);
1599 1599 }
1600 1600 int PythonQtShell_QHexEdit::devType() const
1601 1601 {
1602 1602 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1603 1603 static PyObject* name = PyString_FromString("devType");
1604 1604 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1605 1605 if (obj) {
1606 1606 static const char* argumentList[] ={"int"};
1607 1607 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1608 1608 int returnValue;
1609 1609 void* args[1] = {NULL};
1610 1610 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1611 1611 if (result) {
1612 1612 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1613 1613 if (args[0]!=&returnValue) {
1614 1614 if (args[0]==NULL) {
1615 1615 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
1616 1616 } else {
1617 1617 returnValue = *((int*)args[0]);
1618 1618 }
1619 1619 }
1620 1620 }
1621 1621 if (result) { Py_DECREF(result); }
1622 1622 Py_DECREF(obj);
1623 1623 return returnValue;
1624 1624 } else {
1625 1625 PyErr_Clear();
1626 1626 }
1627 1627 }
1628 1628 return QHexEdit::devType();
1629 1629 }
1630 1630 void PythonQtShell_QHexEdit::dragEnterEvent(QDragEnterEvent* arg__1)
1631 1631 {
1632 1632 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1633 1633 static PyObject* name = PyString_FromString("dragEnterEvent");
1634 1634 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1635 1635 if (obj) {
1636 1636 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
1637 1637 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1638 1638 void* args[2] = {NULL, (void*)&arg__1};
1639 1639 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1640 1640 if (result) { Py_DECREF(result); }
1641 1641 Py_DECREF(obj);
1642 1642 return;
1643 1643 } else {
1644 1644 PyErr_Clear();
1645 1645 }
1646 1646 }
1647 1647 QHexEdit::dragEnterEvent(arg__1);
1648 1648 }
1649 1649 void PythonQtShell_QHexEdit::dragLeaveEvent(QDragLeaveEvent* arg__1)
1650 1650 {
1651 1651 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1652 1652 static PyObject* name = PyString_FromString("dragLeaveEvent");
1653 1653 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1654 1654 if (obj) {
1655 1655 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
1656 1656 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1657 1657 void* args[2] = {NULL, (void*)&arg__1};
1658 1658 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1659 1659 if (result) { Py_DECREF(result); }
1660 1660 Py_DECREF(obj);
1661 1661 return;
1662 1662 } else {
1663 1663 PyErr_Clear();
1664 1664 }
1665 1665 }
1666 1666 QHexEdit::dragLeaveEvent(arg__1);
1667 1667 }
1668 1668 void PythonQtShell_QHexEdit::dragMoveEvent(QDragMoveEvent* arg__1)
1669 1669 {
1670 1670 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1671 1671 static PyObject* name = PyString_FromString("dragMoveEvent");
1672 1672 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1673 1673 if (obj) {
1674 1674 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
1675 1675 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1676 1676 void* args[2] = {NULL, (void*)&arg__1};
1677 1677 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1678 1678 if (result) { Py_DECREF(result); }
1679 1679 Py_DECREF(obj);
1680 1680 return;
1681 1681 } else {
1682 1682 PyErr_Clear();
1683 1683 }
1684 1684 }
1685 1685 QHexEdit::dragMoveEvent(arg__1);
1686 1686 }
1687 1687 void PythonQtShell_QHexEdit::dropEvent(QDropEvent* arg__1)
1688 1688 {
1689 1689 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1690 1690 static PyObject* name = PyString_FromString("dropEvent");
1691 1691 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1692 1692 if (obj) {
1693 1693 static const char* argumentList[] ={"" , "QDropEvent*"};
1694 1694 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1695 1695 void* args[2] = {NULL, (void*)&arg__1};
1696 1696 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1697 1697 if (result) { Py_DECREF(result); }
1698 1698 Py_DECREF(obj);
1699 1699 return;
1700 1700 } else {
1701 1701 PyErr_Clear();
1702 1702 }
1703 1703 }
1704 1704 QHexEdit::dropEvent(arg__1);
1705 1705 }
1706 1706 void PythonQtShell_QHexEdit::enterEvent(QEvent* arg__1)
1707 1707 {
1708 1708 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1709 1709 static PyObject* name = PyString_FromString("enterEvent");
1710 1710 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1711 1711 if (obj) {
1712 1712 static const char* argumentList[] ={"" , "QEvent*"};
1713 1713 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1714 1714 void* args[2] = {NULL, (void*)&arg__1};
1715 1715 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1716 1716 if (result) { Py_DECREF(result); }
1717 1717 Py_DECREF(obj);
1718 1718 return;
1719 1719 } else {
1720 1720 PyErr_Clear();
1721 1721 }
1722 1722 }
1723 1723 QHexEdit::enterEvent(arg__1);
1724 1724 }
1725 1725 bool PythonQtShell_QHexEdit::event(QEvent* arg__1)
1726 1726 {
1727 1727 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1728 1728 static PyObject* name = PyString_FromString("event");
1729 1729 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1730 1730 if (obj) {
1731 1731 static const char* argumentList[] ={"bool" , "QEvent*"};
1732 1732 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1733 1733 bool returnValue;
1734 1734 void* args[2] = {NULL, (void*)&arg__1};
1735 1735 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1736 1736 if (result) {
1737 1737 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1738 1738 if (args[0]!=&returnValue) {
1739 1739 if (args[0]==NULL) {
1740 1740 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
1741 1741 } else {
1742 1742 returnValue = *((bool*)args[0]);
1743 1743 }
1744 1744 }
1745 1745 }
1746 1746 if (result) { Py_DECREF(result); }
1747 1747 Py_DECREF(obj);
1748 1748 return returnValue;
1749 1749 } else {
1750 1750 PyErr_Clear();
1751 1751 }
1752 1752 }
1753 1753 return QHexEdit::event(arg__1);
1754 1754 }
1755 1755 bool PythonQtShell_QHexEdit::eventFilter(QObject* arg__1, QEvent* arg__2)
1756 1756 {
1757 1757 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1758 1758 static PyObject* name = PyString_FromString("eventFilter");
1759 1759 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1760 1760 if (obj) {
1761 1761 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
1762 1762 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
1763 1763 bool returnValue;
1764 1764 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
1765 1765 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1766 1766 if (result) {
1767 1767 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1768 1768 if (args[0]!=&returnValue) {
1769 1769 if (args[0]==NULL) {
1770 1770 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
1771 1771 } else {
1772 1772 returnValue = *((bool*)args[0]);
1773 1773 }
1774 1774 }
1775 1775 }
1776 1776 if (result) { Py_DECREF(result); }
1777 1777 Py_DECREF(obj);
1778 1778 return returnValue;
1779 1779 } else {
1780 1780 PyErr_Clear();
1781 1781 }
1782 1782 }
1783 1783 return QHexEdit::eventFilter(arg__1, arg__2);
1784 1784 }
1785 1785 void PythonQtShell_QHexEdit::focusInEvent(QFocusEvent* arg__1)
1786 1786 {
1787 1787 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1788 1788 static PyObject* name = PyString_FromString("focusInEvent");
1789 1789 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1790 1790 if (obj) {
1791 1791 static const char* argumentList[] ={"" , "QFocusEvent*"};
1792 1792 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1793 1793 void* args[2] = {NULL, (void*)&arg__1};
1794 1794 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1795 1795 if (result) { Py_DECREF(result); }
1796 1796 Py_DECREF(obj);
1797 1797 return;
1798 1798 } else {
1799 1799 PyErr_Clear();
1800 1800 }
1801 1801 }
1802 1802 QHexEdit::focusInEvent(arg__1);
1803 1803 }
1804 1804 bool PythonQtShell_QHexEdit::focusNextPrevChild(bool next0)
1805 1805 {
1806 1806 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1807 1807 static PyObject* name = PyString_FromString("focusNextPrevChild");
1808 1808 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1809 1809 if (obj) {
1810 1810 static const char* argumentList[] ={"bool" , "bool"};
1811 1811 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1812 1812 bool returnValue;
1813 1813 void* args[2] = {NULL, (void*)&next0};
1814 1814 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1815 1815 if (result) {
1816 1816 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1817 1817 if (args[0]!=&returnValue) {
1818 1818 if (args[0]==NULL) {
1819 1819 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
1820 1820 } else {
1821 1821 returnValue = *((bool*)args[0]);
1822 1822 }
1823 1823 }
1824 1824 }
1825 1825 if (result) { Py_DECREF(result); }
1826 1826 Py_DECREF(obj);
1827 1827 return returnValue;
1828 1828 } else {
1829 1829 PyErr_Clear();
1830 1830 }
1831 1831 }
1832 1832 return QHexEdit::focusNextPrevChild(next0);
1833 1833 }
1834 1834 void PythonQtShell_QHexEdit::focusOutEvent(QFocusEvent* arg__1)
1835 1835 {
1836 1836 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1837 1837 static PyObject* name = PyString_FromString("focusOutEvent");
1838 1838 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1839 1839 if (obj) {
1840 1840 static const char* argumentList[] ={"" , "QFocusEvent*"};
1841 1841 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1842 1842 void* args[2] = {NULL, (void*)&arg__1};
1843 1843 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1844 1844 if (result) { Py_DECREF(result); }
1845 1845 Py_DECREF(obj);
1846 1846 return;
1847 1847 } else {
1848 1848 PyErr_Clear();
1849 1849 }
1850 1850 }
1851 1851 QHexEdit::focusOutEvent(arg__1);
1852 1852 }
1853 1853 bool PythonQtShell_QHexEdit::hasHeightForWidth() const
1854 1854 {
1855 1855 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1856 1856 static PyObject* name = PyString_FromString("hasHeightForWidth");
1857 1857 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1858 1858 if (obj) {
1859 1859 static const char* argumentList[] ={"bool"};
1860 1860 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1861 1861 bool returnValue;
1862 1862 void* args[1] = {NULL};
1863 1863 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1864 1864 if (result) {
1865 1865 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1866 1866 if (args[0]!=&returnValue) {
1867 1867 if (args[0]==NULL) {
1868 1868 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
1869 1869 } else {
1870 1870 returnValue = *((bool*)args[0]);
1871 1871 }
1872 1872 }
1873 1873 }
1874 1874 if (result) { Py_DECREF(result); }
1875 1875 Py_DECREF(obj);
1876 1876 return returnValue;
1877 1877 } else {
1878 1878 PyErr_Clear();
1879 1879 }
1880 1880 }
1881 1881 return QHexEdit::hasHeightForWidth();
1882 1882 }
1883 1883 int PythonQtShell_QHexEdit::heightForWidth(int arg__1) const
1884 1884 {
1885 1885 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1886 1886 static PyObject* name = PyString_FromString("heightForWidth");
1887 1887 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1888 1888 if (obj) {
1889 1889 static const char* argumentList[] ={"int" , "int"};
1890 1890 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1891 1891 int returnValue;
1892 1892 void* args[2] = {NULL, (void*)&arg__1};
1893 1893 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1894 1894 if (result) {
1895 1895 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1896 1896 if (args[0]!=&returnValue) {
1897 1897 if (args[0]==NULL) {
1898 1898 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
1899 1899 } else {
1900 1900 returnValue = *((int*)args[0]);
1901 1901 }
1902 1902 }
1903 1903 }
1904 1904 if (result) { Py_DECREF(result); }
1905 1905 Py_DECREF(obj);
1906 1906 return returnValue;
1907 1907 } else {
1908 1908 PyErr_Clear();
1909 1909 }
1910 1910 }
1911 1911 return QHexEdit::heightForWidth(arg__1);
1912 1912 }
1913 1913 void PythonQtShell_QHexEdit::hideEvent(QHideEvent* arg__1)
1914 1914 {
1915 1915 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1916 1916 static PyObject* name = PyString_FromString("hideEvent");
1917 1917 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1918 1918 if (obj) {
1919 1919 static const char* argumentList[] ={"" , "QHideEvent*"};
1920 1920 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1921 1921 void* args[2] = {NULL, (void*)&arg__1};
1922 1922 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1923 1923 if (result) { Py_DECREF(result); }
1924 1924 Py_DECREF(obj);
1925 1925 return;
1926 1926 } else {
1927 1927 PyErr_Clear();
1928 1928 }
1929 1929 }
1930 1930 QHexEdit::hideEvent(arg__1);
1931 1931 }
1932 1932 void PythonQtShell_QHexEdit::initPainter(QPainter* painter0) const
1933 1933 {
1934 1934 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1935 1935 static PyObject* name = PyString_FromString("initPainter");
1936 1936 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1937 1937 if (obj) {
1938 1938 static const char* argumentList[] ={"" , "QPainter*"};
1939 1939 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1940 1940 void* args[2] = {NULL, (void*)&painter0};
1941 1941 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1942 1942 if (result) { Py_DECREF(result); }
1943 1943 Py_DECREF(obj);
1944 1944 return;
1945 1945 } else {
1946 1946 PyErr_Clear();
1947 1947 }
1948 1948 }
1949 1949 QHexEdit::initPainter(painter0);
1950 1950 }
1951 1951 void PythonQtShell_QHexEdit::inputMethodEvent(QInputMethodEvent* arg__1)
1952 1952 {
1953 1953 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1954 1954 static PyObject* name = PyString_FromString("inputMethodEvent");
1955 1955 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1956 1956 if (obj) {
1957 1957 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
1958 1958 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1959 1959 void* args[2] = {NULL, (void*)&arg__1};
1960 1960 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1961 1961 if (result) { Py_DECREF(result); }
1962 1962 Py_DECREF(obj);
1963 1963 return;
1964 1964 } else {
1965 1965 PyErr_Clear();
1966 1966 }
1967 1967 }
1968 1968 QHexEdit::inputMethodEvent(arg__1);
1969 1969 }
1970 1970 QVariant PythonQtShell_QHexEdit::inputMethodQuery(Qt::InputMethodQuery arg__1) const
1971 1971 {
1972 1972 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1973 1973 static PyObject* name = PyString_FromString("inputMethodQuery");
1974 1974 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1975 1975 if (obj) {
1976 1976 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
1977 1977 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1978 1978 QVariant returnValue;
1979 1979 void* args[2] = {NULL, (void*)&arg__1};
1980 1980 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1981 1981 if (result) {
1982 1982 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1983 1983 if (args[0]!=&returnValue) {
1984 1984 if (args[0]==NULL) {
1985 1985 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
1986 1986 } else {
1987 1987 returnValue = *((QVariant*)args[0]);
1988 1988 }
1989 1989 }
1990 1990 }
1991 1991 if (result) { Py_DECREF(result); }
1992 1992 Py_DECREF(obj);
1993 1993 return returnValue;
1994 1994 } else {
1995 1995 PyErr_Clear();
1996 1996 }
1997 1997 }
1998 1998 return QHexEdit::inputMethodQuery(arg__1);
1999 1999 }
2000 2000 void PythonQtShell_QHexEdit::keyPressEvent(QKeyEvent* arg__1)
2001 2001 {
2002 2002 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2003 2003 static PyObject* name = PyString_FromString("keyPressEvent");
2004 2004 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2005 2005 if (obj) {
2006 2006 static const char* argumentList[] ={"" , "QKeyEvent*"};
2007 2007 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2008 2008 void* args[2] = {NULL, (void*)&arg__1};
2009 2009 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2010 2010 if (result) { Py_DECREF(result); }
2011 2011 Py_DECREF(obj);
2012 2012 return;
2013 2013 } else {
2014 2014 PyErr_Clear();
2015 2015 }
2016 2016 }
2017 2017 QHexEdit::keyPressEvent(arg__1);
2018 2018 }
2019 2019 void PythonQtShell_QHexEdit::keyReleaseEvent(QKeyEvent* arg__1)
2020 2020 {
2021 2021 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2022 2022 static PyObject* name = PyString_FromString("keyReleaseEvent");
2023 2023 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2024 2024 if (obj) {
2025 2025 static const char* argumentList[] ={"" , "QKeyEvent*"};
2026 2026 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2027 2027 void* args[2] = {NULL, (void*)&arg__1};
2028 2028 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2029 2029 if (result) { Py_DECREF(result); }
2030 2030 Py_DECREF(obj);
2031 2031 return;
2032 2032 } else {
2033 2033 PyErr_Clear();
2034 2034 }
2035 2035 }
2036 2036 QHexEdit::keyReleaseEvent(arg__1);
2037 2037 }
2038 2038 void PythonQtShell_QHexEdit::leaveEvent(QEvent* arg__1)
2039 2039 {
2040 2040 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2041 2041 static PyObject* name = PyString_FromString("leaveEvent");
2042 2042 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2043 2043 if (obj) {
2044 2044 static const char* argumentList[] ={"" , "QEvent*"};
2045 2045 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2046 2046 void* args[2] = {NULL, (void*)&arg__1};
2047 2047 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2048 2048 if (result) { Py_DECREF(result); }
2049 2049 Py_DECREF(obj);
2050 2050 return;
2051 2051 } else {
2052 2052 PyErr_Clear();
2053 2053 }
2054 2054 }
2055 2055 QHexEdit::leaveEvent(arg__1);
2056 2056 }
2057 2057 int PythonQtShell_QHexEdit::metric(QPaintDevice::PaintDeviceMetric arg__1) const
2058 2058 {
2059 2059 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2060 2060 static PyObject* name = PyString_FromString("metric");
2061 2061 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2062 2062 if (obj) {
2063 2063 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
2064 2064 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2065 2065 int returnValue;
2066 2066 void* args[2] = {NULL, (void*)&arg__1};
2067 2067 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2068 2068 if (result) {
2069 2069 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2070 2070 if (args[0]!=&returnValue) {
2071 2071 if (args[0]==NULL) {
2072 2072 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
2073 2073 } else {
2074 2074 returnValue = *((int*)args[0]);
2075 2075 }
2076 2076 }
2077 2077 }
2078 2078 if (result) { Py_DECREF(result); }
2079 2079 Py_DECREF(obj);
2080 2080 return returnValue;
2081 2081 } else {
2082 2082 PyErr_Clear();
2083 2083 }
2084 2084 }
2085 2085 return QHexEdit::metric(arg__1);
2086 2086 }
2087 2087 void PythonQtShell_QHexEdit::mouseDoubleClickEvent(QMouseEvent* arg__1)
2088 2088 {
2089 2089 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2090 2090 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
2091 2091 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2092 2092 if (obj) {
2093 2093 static const char* argumentList[] ={"" , "QMouseEvent*"};
2094 2094 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2095 2095 void* args[2] = {NULL, (void*)&arg__1};
2096 2096 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2097 2097 if (result) { Py_DECREF(result); }
2098 2098 Py_DECREF(obj);
2099 2099 return;
2100 2100 } else {
2101 2101 PyErr_Clear();
2102 2102 }
2103 2103 }
2104 2104 QHexEdit::mouseDoubleClickEvent(arg__1);
2105 2105 }
2106 2106 void PythonQtShell_QHexEdit::mouseMoveEvent(QMouseEvent* arg__1)
2107 2107 {
2108 2108 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2109 2109 static PyObject* name = PyString_FromString("mouseMoveEvent");
2110 2110 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2111 2111 if (obj) {
2112 2112 static const char* argumentList[] ={"" , "QMouseEvent*"};
2113 2113 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2114 2114 void* args[2] = {NULL, (void*)&arg__1};
2115 2115 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2116 2116 if (result) { Py_DECREF(result); }
2117 2117 Py_DECREF(obj);
2118 2118 return;
2119 2119 } else {
2120 2120 PyErr_Clear();
2121 2121 }
2122 2122 }
2123 2123 QHexEdit::mouseMoveEvent(arg__1);
2124 2124 }
2125 2125 void PythonQtShell_QHexEdit::mousePressEvent(QMouseEvent* arg__1)
2126 2126 {
2127 2127 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2128 2128 static PyObject* name = PyString_FromString("mousePressEvent");
2129 2129 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2130 2130 if (obj) {
2131 2131 static const char* argumentList[] ={"" , "QMouseEvent*"};
2132 2132 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2133 2133 void* args[2] = {NULL, (void*)&arg__1};
2134 2134 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2135 2135 if (result) { Py_DECREF(result); }
2136 2136 Py_DECREF(obj);
2137 2137 return;
2138 2138 } else {
2139 2139 PyErr_Clear();
2140 2140 }
2141 2141 }
2142 2142 QHexEdit::mousePressEvent(arg__1);
2143 2143 }
2144 2144 void PythonQtShell_QHexEdit::mouseReleaseEvent(QMouseEvent* arg__1)
2145 2145 {
2146 2146 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2147 2147 static PyObject* name = PyString_FromString("mouseReleaseEvent");
2148 2148 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2149 2149 if (obj) {
2150 2150 static const char* argumentList[] ={"" , "QMouseEvent*"};
2151 2151 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2152 2152 void* args[2] = {NULL, (void*)&arg__1};
2153 2153 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2154 2154 if (result) { Py_DECREF(result); }
2155 2155 Py_DECREF(obj);
2156 2156 return;
2157 2157 } else {
2158 2158 PyErr_Clear();
2159 2159 }
2160 2160 }
2161 2161 QHexEdit::mouseReleaseEvent(arg__1);
2162 2162 }
2163 2163 void PythonQtShell_QHexEdit::moveEvent(QMoveEvent* arg__1)
2164 2164 {
2165 2165 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2166 2166 static PyObject* name = PyString_FromString("moveEvent");
2167 2167 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2168 2168 if (obj) {
2169 2169 static const char* argumentList[] ={"" , "QMoveEvent*"};
2170 2170 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2171 2171 void* args[2] = {NULL, (void*)&arg__1};
2172 2172 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2173 2173 if (result) { Py_DECREF(result); }
2174 2174 Py_DECREF(obj);
2175 2175 return;
2176 2176 } else {
2177 2177 PyErr_Clear();
2178 2178 }
2179 2179 }
2180 2180 QHexEdit::moveEvent(arg__1);
2181 2181 }
2182 2182 bool PythonQtShell_QHexEdit::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
2183 2183 {
2184 2184 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2185 2185 static PyObject* name = PyString_FromString("nativeEvent");
2186 2186 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2187 2187 if (obj) {
2188 2188 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
2189 2189 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
2190 2190 bool returnValue;
2191 2191 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
2192 2192 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2193 2193 if (result) {
2194 2194 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2195 2195 if (args[0]!=&returnValue) {
2196 2196 if (args[0]==NULL) {
2197 2197 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
2198 2198 } else {
2199 2199 returnValue = *((bool*)args[0]);
2200 2200 }
2201 2201 }
2202 2202 }
2203 2203 if (result) { Py_DECREF(result); }
2204 2204 Py_DECREF(obj);
2205 2205 return returnValue;
2206 2206 } else {
2207 2207 PyErr_Clear();
2208 2208 }
2209 2209 }
2210 2210 return QHexEdit::nativeEvent(eventType0, message1, result2);
2211 2211 }
2212 2212 QPaintEngine* PythonQtShell_QHexEdit::paintEngine() const
2213 2213 {
2214 2214 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2215 2215 static PyObject* name = PyString_FromString("paintEngine");
2216 2216 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2217 2217 if (obj) {
2218 2218 static const char* argumentList[] ={"QPaintEngine*"};
2219 2219 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2220 2220 QPaintEngine* returnValue;
2221 2221 void* args[1] = {NULL};
2222 2222 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2223 2223 if (result) {
2224 2224 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2225 2225 if (args[0]!=&returnValue) {
2226 2226 if (args[0]==NULL) {
2227 2227 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
2228 2228 } else {
2229 2229 returnValue = *((QPaintEngine**)args[0]);
2230 2230 }
2231 2231 }
2232 2232 }
2233 2233 if (result) { Py_DECREF(result); }
2234 2234 Py_DECREF(obj);
2235 2235 return returnValue;
2236 2236 } else {
2237 2237 PyErr_Clear();
2238 2238 }
2239 2239 }
2240 2240 return QHexEdit::paintEngine();
2241 2241 }
2242 2242 void PythonQtShell_QHexEdit::paintEvent(QPaintEvent* arg__1)
2243 2243 {
2244 2244 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2245 2245 static PyObject* name = PyString_FromString("paintEvent");
2246 2246 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2247 2247 if (obj) {
2248 2248 static const char* argumentList[] ={"" , "QPaintEvent*"};
2249 2249 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2250 2250 void* args[2] = {NULL, (void*)&arg__1};
2251 2251 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2252 2252 if (result) { Py_DECREF(result); }
2253 2253 Py_DECREF(obj);
2254 2254 return;
2255 2255 } else {
2256 2256 PyErr_Clear();
2257 2257 }
2258 2258 }
2259 2259 QHexEdit::paintEvent(arg__1);
2260 2260 }
2261 2261 QPaintDevice* PythonQtShell_QHexEdit::redirected(QPoint* offset0) const
2262 2262 {
2263 2263 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2264 2264 static PyObject* name = PyString_FromString("redirected");
2265 2265 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2266 2266 if (obj) {
2267 2267 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
2268 2268 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2269 2269 QPaintDevice* returnValue;
2270 2270 void* args[2] = {NULL, (void*)&offset0};
2271 2271 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2272 2272 if (result) {
2273 2273 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2274 2274 if (args[0]!=&returnValue) {
2275 2275 if (args[0]==NULL) {
2276 2276 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
2277 2277 } else {
2278 2278 returnValue = *((QPaintDevice**)args[0]);
2279 2279 }
2280 2280 }
2281 2281 }
2282 2282 if (result) { Py_DECREF(result); }
2283 2283 Py_DECREF(obj);
2284 2284 return returnValue;
2285 2285 } else {
2286 2286 PyErr_Clear();
2287 2287 }
2288 2288 }
2289 2289 return QHexEdit::redirected(offset0);
2290 2290 }
2291 2291 void PythonQtShell_QHexEdit::resizeEvent(QResizeEvent* arg__1)
2292 2292 {
2293 2293 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2294 2294 static PyObject* name = PyString_FromString("resizeEvent");
2295 2295 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2296 2296 if (obj) {
2297 2297 static const char* argumentList[] ={"" , "QResizeEvent*"};
2298 2298 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2299 2299 void* args[2] = {NULL, (void*)&arg__1};
2300 2300 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2301 2301 if (result) { Py_DECREF(result); }
2302 2302 Py_DECREF(obj);
2303 2303 return;
2304 2304 } else {
2305 2305 PyErr_Clear();
2306 2306 }
2307 2307 }
2308 2308 QHexEdit::resizeEvent(arg__1);
2309 2309 }
2310 2310 void PythonQtShell_QHexEdit::scrollContentsBy(int dx0, int dy1)
2311 2311 {
2312 2312 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2313 2313 static PyObject* name = PyString_FromString("scrollContentsBy");
2314 2314 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2315 2315 if (obj) {
2316 2316 static const char* argumentList[] ={"" , "int" , "int"};
2317 2317 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2318 2318 void* args[3] = {NULL, (void*)&dx0, (void*)&dy1};
2319 2319 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2320 2320 if (result) { Py_DECREF(result); }
2321 2321 Py_DECREF(obj);
2322 2322 return;
2323 2323 } else {
2324 2324 PyErr_Clear();
2325 2325 }
2326 2326 }
2327 2327 QHexEdit::scrollContentsBy(dx0, dy1);
2328 2328 }
2329 2329 void PythonQtShell_QHexEdit::setupViewport(QWidget* viewport0)
2330 2330 {
2331 2331 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2332 2332 static PyObject* name = PyString_FromString("setupViewport");
2333 2333 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2334 2334 if (obj) {
2335 2335 static const char* argumentList[] ={"" , "QWidget*"};
2336 2336 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2337 2337 void* args[2] = {NULL, (void*)&viewport0};
2338 2338 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2339 2339 if (result) { Py_DECREF(result); }
2340 2340 Py_DECREF(obj);
2341 2341 return;
2342 2342 } else {
2343 2343 PyErr_Clear();
2344 2344 }
2345 2345 }
2346 2346 QHexEdit::setupViewport(viewport0);
2347 2347 }
2348 2348 QPainter* PythonQtShell_QHexEdit::sharedPainter() const
2349 2349 {
2350 2350 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2351 2351 static PyObject* name = PyString_FromString("sharedPainter");
2352 2352 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2353 2353 if (obj) {
2354 2354 static const char* argumentList[] ={"QPainter*"};
2355 2355 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2356 2356 QPainter* returnValue;
2357 2357 void* args[1] = {NULL};
2358 2358 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2359 2359 if (result) {
2360 2360 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2361 2361 if (args[0]!=&returnValue) {
2362 2362 if (args[0]==NULL) {
2363 2363 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
2364 2364 } else {
2365 2365 returnValue = *((QPainter**)args[0]);
2366 2366 }
2367 2367 }
2368 2368 }
2369 2369 if (result) { Py_DECREF(result); }
2370 2370 Py_DECREF(obj);
2371 2371 return returnValue;
2372 2372 } else {
2373 2373 PyErr_Clear();
2374 2374 }
2375 2375 }
2376 2376 return QHexEdit::sharedPainter();
2377 2377 }
2378 2378 void PythonQtShell_QHexEdit::showEvent(QShowEvent* arg__1)
2379 2379 {
2380 2380 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2381 2381 static PyObject* name = PyString_FromString("showEvent");
2382 2382 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2383 2383 if (obj) {
2384 2384 static const char* argumentList[] ={"" , "QShowEvent*"};
2385 2385 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2386 2386 void* args[2] = {NULL, (void*)&arg__1};
2387 2387 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2388 2388 if (result) { Py_DECREF(result); }
2389 2389 Py_DECREF(obj);
2390 2390 return;
2391 2391 } else {
2392 2392 PyErr_Clear();
2393 2393 }
2394 2394 }
2395 2395 QHexEdit::showEvent(arg__1);
2396 2396 }
2397 2397 void PythonQtShell_QHexEdit::tabletEvent(QTabletEvent* arg__1)
2398 2398 {
2399 2399 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2400 2400 static PyObject* name = PyString_FromString("tabletEvent");
2401 2401 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2402 2402 if (obj) {
2403 2403 static const char* argumentList[] ={"" , "QTabletEvent*"};
2404 2404 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2405 2405 void* args[2] = {NULL, (void*)&arg__1};
2406 2406 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2407 2407 if (result) { Py_DECREF(result); }
2408 2408 Py_DECREF(obj);
2409 2409 return;
2410 2410 } else {
2411 2411 PyErr_Clear();
2412 2412 }
2413 2413 }
2414 2414 QHexEdit::tabletEvent(arg__1);
2415 2415 }
2416 2416 void PythonQtShell_QHexEdit::timerEvent(QTimerEvent* arg__1)
2417 2417 {
2418 2418 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2419 2419 static PyObject* name = PyString_FromString("timerEvent");
2420 2420 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2421 2421 if (obj) {
2422 2422 static const char* argumentList[] ={"" , "QTimerEvent*"};
2423 2423 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2424 2424 void* args[2] = {NULL, (void*)&arg__1};
2425 2425 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2426 2426 if (result) { Py_DECREF(result); }
2427 2427 Py_DECREF(obj);
2428 2428 return;
2429 2429 } else {
2430 2430 PyErr_Clear();
2431 2431 }
2432 2432 }
2433 2433 QHexEdit::timerEvent(arg__1);
2434 2434 }
2435 2435 bool PythonQtShell_QHexEdit::viewportEvent(QEvent* arg__1)
2436 2436 {
2437 2437 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2438 2438 static PyObject* name = PyString_FromString("viewportEvent");
2439 2439 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2440 2440 if (obj) {
2441 2441 static const char* argumentList[] ={"bool" , "QEvent*"};
2442 2442 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2443 2443 bool returnValue;
2444 2444 void* args[2] = {NULL, (void*)&arg__1};
2445 2445 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2446 2446 if (result) {
2447 2447 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2448 2448 if (args[0]!=&returnValue) {
2449 2449 if (args[0]==NULL) {
2450 2450 PythonQt::priv()->handleVirtualOverloadReturnError("viewportEvent", methodInfo, result);
2451 2451 } else {
2452 2452 returnValue = *((bool*)args[0]);
2453 2453 }
2454 2454 }
2455 2455 }
2456 2456 if (result) { Py_DECREF(result); }
2457 2457 Py_DECREF(obj);
2458 2458 return returnValue;
2459 2459 } else {
2460 2460 PyErr_Clear();
2461 2461 }
2462 2462 }
2463 2463 return QHexEdit::viewportEvent(arg__1);
2464 2464 }
2465 2465 QSize PythonQtShell_QHexEdit::viewportSizeHint() const
2466 2466 {
2467 2467 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2468 2468 static PyObject* name = PyString_FromString("viewportSizeHint");
2469 2469 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2470 2470 if (obj) {
2471 2471 static const char* argumentList[] ={"QSize"};
2472 2472 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2473 2473 QSize returnValue;
2474 2474 void* args[1] = {NULL};
2475 2475 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2476 2476 if (result) {
2477 2477 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2478 2478 if (args[0]!=&returnValue) {
2479 2479 if (args[0]==NULL) {
2480 2480 PythonQt::priv()->handleVirtualOverloadReturnError("viewportSizeHint", methodInfo, result);
2481 2481 } else {
2482 2482 returnValue = *((QSize*)args[0]);
2483 2483 }
2484 2484 }
2485 2485 }
2486 2486 if (result) { Py_DECREF(result); }
2487 2487 Py_DECREF(obj);
2488 2488 return returnValue;
2489 2489 } else {
2490 2490 PyErr_Clear();
2491 2491 }
2492 2492 }
2493 2493 return QHexEdit::viewportSizeHint();
2494 2494 }
2495 2495 void PythonQtShell_QHexEdit::wheelEvent(QWheelEvent* arg__1)
2496 2496 {
2497 2497 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2498 2498 static PyObject* name = PyString_FromString("wheelEvent");
2499 2499 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2500 2500 if (obj) {
2501 2501 static const char* argumentList[] ={"" , "QWheelEvent*"};
2502 2502 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2503 2503 void* args[2] = {NULL, (void*)&arg__1};
2504 2504 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2505 2505 if (result) { Py_DECREF(result); }
2506 2506 Py_DECREF(obj);
2507 2507 return;
2508 2508 } else {
2509 2509 PyErr_Clear();
2510 2510 }
2511 2511 }
2512 2512 QHexEdit::wheelEvent(arg__1);
2513 2513 }
2514 2514 QHexEdit* PythonQtWrapper_QHexEdit::new_QHexEdit(QWidget* parent)
2515 2515 {
2516 2516 return new PythonQtShell_QHexEdit(parent); }
2517 2517
2518 2518 QColor PythonQtWrapper_QHexEdit::addressAreaColor(QHexEdit* theWrappedObject)
2519 2519 {
2520 2520 return ( theWrappedObject->addressAreaColor());
2521 2521 }
2522 2522
2523 2523 int PythonQtWrapper_QHexEdit::addressOffset(QHexEdit* theWrappedObject)
2524 2524 {
2525 2525 return ( theWrappedObject->addressOffset());
2526 2526 }
2527 2527
2528 2528 int PythonQtWrapper_QHexEdit::cursorPosition(QHexEdit* theWrappedObject)
2529 2529 {
2530 2530 return ( theWrappedObject->cursorPosition());
2531 2531 }
2532 2532
2533 2533 QByteArray PythonQtWrapper_QHexEdit::data(QHexEdit* theWrappedObject)
2534 2534 {
2535 2535 return ( theWrappedObject->data());
2536 2536 }
2537 2537
2538 2538 const QFont* PythonQtWrapper_QHexEdit::font(QHexEdit* theWrappedObject) const
2539 2539 {
2540 2540 return &( theWrappedObject->font());
2541 2541 }
2542 2542
2543 2543 int PythonQtWrapper_QHexEdit::getSelectionBegin(QHexEdit* theWrappedObject)
2544 2544 {
2545 2545 return ( theWrappedObject->getSelectionBegin());
2546 2546 }
2547 2547
2548 2548 int PythonQtWrapper_QHexEdit::getSelectionEnd(QHexEdit* theWrappedObject)
2549 2549 {
2550 2550 return ( theWrappedObject->getSelectionEnd());
2551 2551 }
2552 2552
2553 2553 QColor PythonQtWrapper_QHexEdit::highlightingColor(QHexEdit* theWrappedObject)
2554 2554 {
2555 2555 return ( theWrappedObject->highlightingColor());
2556 2556 }
2557 2557
2558 2558 int PythonQtWrapper_QHexEdit::indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2559 2559 {
2560 2560 return ( theWrappedObject->indexOf(ba, from));
2561 2561 }
2562 2562
2563 2563 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, char ch)
2564 2564 {
2565 2565 ( theWrappedObject->insert(i, ch));
2566 2566 }
2567 2567
2568 2568 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba)
2569 2569 {
2570 2570 ( theWrappedObject->insert(i, ba));
2571 2571 }
2572 2572
2573 2573 bool PythonQtWrapper_QHexEdit::isReadOnly(QHexEdit* theWrappedObject)
2574 2574 {
2575 2575 return ( theWrappedObject->isReadOnly());
2576 2576 }
2577 2577
2578 2578 int PythonQtWrapper_QHexEdit::lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2579 2579 {
2580 2580 return ( theWrappedObject->lastIndexOf(ba, from));
2581 2581 }
2582 2582
2583 2583 bool PythonQtWrapper_QHexEdit::overwriteMode(QHexEdit* theWrappedObject)
2584 2584 {
2585 2585 return ( theWrappedObject->overwriteMode());
2586 2586 }
2587 2587
2588 2588 void PythonQtWrapper_QHexEdit::remove(QHexEdit* theWrappedObject, int pos, int len)
2589 2589 {
2590 2590 ( theWrappedObject->remove(pos, len));
2591 2591 }
2592 2592
2593 2593 void PythonQtWrapper_QHexEdit::replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after)
2594 2594 {
2595 2595 ( theWrappedObject->replace(pos, len, after));
2596 2596 }
2597 2597
2598 2598 void PythonQtWrapper_QHexEdit::resetSelection(QHexEdit* theWrappedObject)
2599 2599 {
2600 2600 ( theWrappedObject->resetSelection());
2601 2601 }
2602 2602
2603 2603 void PythonQtWrapper_QHexEdit::resetSelection(QHexEdit* theWrappedObject, int pos)
2604 2604 {
2605 2605 ( theWrappedObject->resetSelection(pos));
2606 2606 }
2607 2607
2608 2608 QColor PythonQtWrapper_QHexEdit::selectionColor(QHexEdit* theWrappedObject)
2609 2609 {
2610 2610 return ( theWrappedObject->selectionColor());
2611 2611 }
2612 2612
2613 2613 QString PythonQtWrapper_QHexEdit::selectionToReadableString(QHexEdit* theWrappedObject)
2614 2614 {
2615 2615 return ( theWrappedObject->selectionToReadableString());
2616 2616 }
2617 2617
2618 2618 void PythonQtWrapper_QHexEdit::setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color)
2619 2619 {
2620 2620 ( theWrappedObject->setAddressAreaColor(color));
2621 2621 }
2622 2622
2623 2623 void PythonQtWrapper_QHexEdit::setAddressOffset(QHexEdit* theWrappedObject, int offset)
2624 2624 {
2625 2625 ( theWrappedObject->setAddressOffset(offset));
2626 2626 }
2627 2627
2628 2628 void PythonQtWrapper_QHexEdit::setCursorPosition(QHexEdit* theWrappedObject, int cusorPos)
2629 2629 {
2630 2630 ( theWrappedObject->setCursorPosition(cusorPos));
2631 2631 }
2632 2632
2633 2633 void PythonQtWrapper_QHexEdit::setData(QHexEdit* theWrappedObject, const QByteArray& data)
2634 2634 {
2635 2635 ( theWrappedObject->setData(data));
2636 2636 }
2637 2637
2638 2638 void PythonQtWrapper_QHexEdit::setFont(QHexEdit* theWrappedObject, const QFont& arg__1)
2639 2639 {
2640 2640 ( theWrappedObject->setFont(arg__1));
2641 2641 }
2642 2642
2643 2643 void PythonQtWrapper_QHexEdit::setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color)
2644 2644 {
2645 2645 ( theWrappedObject->setHighlightingColor(color));
2646 2646 }
2647 2647
2648 2648 void PythonQtWrapper_QHexEdit::setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1)
2649 2649 {
2650 2650 ( theWrappedObject->setOverwriteMode(arg__1));
2651 2651 }
2652 2652
2653 2653 void PythonQtWrapper_QHexEdit::setReadOnly(QHexEdit* theWrappedObject, bool arg__1)
2654 2654 {
2655 2655 ( theWrappedObject->setReadOnly(arg__1));
2656 2656 }
2657 2657
2658 2658 void PythonQtWrapper_QHexEdit::setSelection(QHexEdit* theWrappedObject, int pos)
2659 2659 {
2660 2660 ( theWrappedObject->setSelection(pos));
2661 2661 }
2662 2662
2663 2663 void PythonQtWrapper_QHexEdit::setSelectionColor(QHexEdit* theWrappedObject, const QColor& color)
2664 2664 {
2665 2665 ( theWrappedObject->setSelectionColor(color));
2666 2666 }
2667 2667
2668 2668 QString PythonQtWrapper_QHexEdit::toReadableString(QHexEdit* theWrappedObject)
2669 2669 {
2670 2670 return ( theWrappedObject->toReadableString());
2671 2671 }
2672 2672
2673 2673
2674 2674
2675 2675 PythonQtShell_QHexSpinBox::~PythonQtShell_QHexSpinBox() {
2676 2676 PythonQtPrivate* priv = PythonQt::priv();
2677 2677 if (priv) { priv->shellClassDeleted(this); }
2678 2678 }
2679 2679 void PythonQtShell_QHexSpinBox::actionEvent(QActionEvent* arg__1)
2680 2680 {
2681 2681 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2682 2682 static PyObject* name = PyString_FromString("actionEvent");
2683 2683 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2684 2684 if (obj) {
2685 2685 static const char* argumentList[] ={"" , "QActionEvent*"};
2686 2686 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2687 2687 void* args[2] = {NULL, (void*)&arg__1};
2688 2688 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2689 2689 if (result) { Py_DECREF(result); }
2690 2690 Py_DECREF(obj);
2691 2691 return;
2692 2692 } else {
2693 2693 PyErr_Clear();
2694 2694 }
2695 2695 }
2696 2696 QHexSpinBox::actionEvent(arg__1);
2697 2697 }
2698 2698 void PythonQtShell_QHexSpinBox::changeEvent(QEvent* event0)
2699 2699 {
2700 2700 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2701 2701 static PyObject* name = PyString_FromString("changeEvent");
2702 2702 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2703 2703 if (obj) {
2704 2704 static const char* argumentList[] ={"" , "QEvent*"};
2705 2705 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2706 2706 void* args[2] = {NULL, (void*)&event0};
2707 2707 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2708 2708 if (result) { Py_DECREF(result); }
2709 2709 Py_DECREF(obj);
2710 2710 return;
2711 2711 } else {
2712 2712 PyErr_Clear();
2713 2713 }
2714 2714 }
2715 2715 QHexSpinBox::changeEvent(event0);
2716 2716 }
2717 2717 void PythonQtShell_QHexSpinBox::childEvent(QChildEvent* arg__1)
2718 2718 {
2719 2719 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2720 2720 static PyObject* name = PyString_FromString("childEvent");
2721 2721 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2722 2722 if (obj) {
2723 2723 static const char* argumentList[] ={"" , "QChildEvent*"};
2724 2724 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2725 2725 void* args[2] = {NULL, (void*)&arg__1};
2726 2726 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2727 2727 if (result) { Py_DECREF(result); }
2728 2728 Py_DECREF(obj);
2729 2729 return;
2730 2730 } else {
2731 2731 PyErr_Clear();
2732 2732 }
2733 2733 }
2734 2734 QHexSpinBox::childEvent(arg__1);
2735 2735 }
2736 2736 void PythonQtShell_QHexSpinBox::clear()
2737 2737 {
2738 2738 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2739 2739 static PyObject* name = PyString_FromString("clear");
2740 2740 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2741 2741 if (obj) {
2742 2742 static const char* argumentList[] ={""};
2743 2743 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2744 2744 void* args[1] = {NULL};
2745 2745 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2746 2746 if (result) { Py_DECREF(result); }
2747 2747 Py_DECREF(obj);
2748 2748 return;
2749 2749 } else {
2750 2750 PyErr_Clear();
2751 2751 }
2752 2752 }
2753 2753 QHexSpinBox::clear();
2754 2754 }
2755 2755 void PythonQtShell_QHexSpinBox::closeEvent(QCloseEvent* event0)
2756 2756 {
2757 2757 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2758 2758 static PyObject* name = PyString_FromString("closeEvent");
2759 2759 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2760 2760 if (obj) {
2761 2761 static const char* argumentList[] ={"" , "QCloseEvent*"};
2762 2762 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2763 2763 void* args[2] = {NULL, (void*)&event0};
2764 2764 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2765 2765 if (result) { Py_DECREF(result); }
2766 2766 Py_DECREF(obj);
2767 2767 return;
2768 2768 } else {
2769 2769 PyErr_Clear();
2770 2770 }
2771 2771 }
2772 2772 QHexSpinBox::closeEvent(event0);
2773 2773 }
2774 2774 void PythonQtShell_QHexSpinBox::contextMenuEvent(QContextMenuEvent* event0)
2775 2775 {
2776 2776 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2777 2777 static PyObject* name = PyString_FromString("contextMenuEvent");
2778 2778 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2779 2779 if (obj) {
2780 2780 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
2781 2781 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2782 2782 void* args[2] = {NULL, (void*)&event0};
2783 2783 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2784 2784 if (result) { Py_DECREF(result); }
2785 2785 Py_DECREF(obj);
2786 2786 return;
2787 2787 } else {
2788 2788 PyErr_Clear();
2789 2789 }
2790 2790 }
2791 2791 QHexSpinBox::contextMenuEvent(event0);
2792 2792 }
2793 2793 void PythonQtShell_QHexSpinBox::customEvent(QEvent* arg__1)
2794 2794 {
2795 2795 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2796 2796 static PyObject* name = PyString_FromString("customEvent");
2797 2797 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2798 2798 if (obj) {
2799 2799 static const char* argumentList[] ={"" , "QEvent*"};
2800 2800 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2801 2801 void* args[2] = {NULL, (void*)&arg__1};
2802 2802 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2803 2803 if (result) { Py_DECREF(result); }
2804 2804 Py_DECREF(obj);
2805 2805 return;
2806 2806 } else {
2807 2807 PyErr_Clear();
2808 2808 }
2809 2809 }
2810 2810 QHexSpinBox::customEvent(arg__1);
2811 2811 }
2812 2812 int PythonQtShell_QHexSpinBox::devType() const
2813 2813 {
2814 2814 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2815 2815 static PyObject* name = PyString_FromString("devType");
2816 2816 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2817 2817 if (obj) {
2818 2818 static const char* argumentList[] ={"int"};
2819 2819 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2820 2820 int returnValue;
2821 2821 void* args[1] = {NULL};
2822 2822 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2823 2823 if (result) {
2824 2824 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2825 2825 if (args[0]!=&returnValue) {
2826 2826 if (args[0]==NULL) {
2827 2827 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
2828 2828 } else {
2829 2829 returnValue = *((int*)args[0]);
2830 2830 }
2831 2831 }
2832 2832 }
2833 2833 if (result) { Py_DECREF(result); }
2834 2834 Py_DECREF(obj);
2835 2835 return returnValue;
2836 2836 } else {
2837 2837 PyErr_Clear();
2838 2838 }
2839 2839 }
2840 2840 return QHexSpinBox::devType();
2841 2841 }
2842 2842 void PythonQtShell_QHexSpinBox::dragEnterEvent(QDragEnterEvent* arg__1)
2843 2843 {
2844 2844 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2845 2845 static PyObject* name = PyString_FromString("dragEnterEvent");
2846 2846 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2847 2847 if (obj) {
2848 2848 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
2849 2849 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2850 2850 void* args[2] = {NULL, (void*)&arg__1};
2851 2851 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2852 2852 if (result) { Py_DECREF(result); }
2853 2853 Py_DECREF(obj);
2854 2854 return;
2855 2855 } else {
2856 2856 PyErr_Clear();
2857 2857 }
2858 2858 }
2859 2859 QHexSpinBox::dragEnterEvent(arg__1);
2860 2860 }
2861 2861 void PythonQtShell_QHexSpinBox::dragLeaveEvent(QDragLeaveEvent* arg__1)
2862 2862 {
2863 2863 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2864 2864 static PyObject* name = PyString_FromString("dragLeaveEvent");
2865 2865 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2866 2866 if (obj) {
2867 2867 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
2868 2868 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2869 2869 void* args[2] = {NULL, (void*)&arg__1};
2870 2870 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2871 2871 if (result) { Py_DECREF(result); }
2872 2872 Py_DECREF(obj);
2873 2873 return;
2874 2874 } else {
2875 2875 PyErr_Clear();
2876 2876 }
2877 2877 }
2878 2878 QHexSpinBox::dragLeaveEvent(arg__1);
2879 2879 }
2880 2880 void PythonQtShell_QHexSpinBox::dragMoveEvent(QDragMoveEvent* arg__1)
2881 2881 {
2882 2882 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2883 2883 static PyObject* name = PyString_FromString("dragMoveEvent");
2884 2884 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2885 2885 if (obj) {
2886 2886 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
2887 2887 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2888 2888 void* args[2] = {NULL, (void*)&arg__1};
2889 2889 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2890 2890 if (result) { Py_DECREF(result); }
2891 2891 Py_DECREF(obj);
2892 2892 return;
2893 2893 } else {
2894 2894 PyErr_Clear();
2895 2895 }
2896 2896 }
2897 2897 QHexSpinBox::dragMoveEvent(arg__1);
2898 2898 }
2899 2899 void PythonQtShell_QHexSpinBox::dropEvent(QDropEvent* arg__1)
2900 2900 {
2901 2901 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2902 2902 static PyObject* name = PyString_FromString("dropEvent");
2903 2903 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2904 2904 if (obj) {
2905 2905 static const char* argumentList[] ={"" , "QDropEvent*"};
2906 2906 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2907 2907 void* args[2] = {NULL, (void*)&arg__1};
2908 2908 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2909 2909 if (result) { Py_DECREF(result); }
2910 2910 Py_DECREF(obj);
2911 2911 return;
2912 2912 } else {
2913 2913 PyErr_Clear();
2914 2914 }
2915 2915 }
2916 2916 QHexSpinBox::dropEvent(arg__1);
2917 2917 }
2918 2918 void PythonQtShell_QHexSpinBox::enterEvent(QEvent* arg__1)
2919 2919 {
2920 2920 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2921 2921 static PyObject* name = PyString_FromString("enterEvent");
2922 2922 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2923 2923 if (obj) {
2924 2924 static const char* argumentList[] ={"" , "QEvent*"};
2925 2925 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2926 2926 void* args[2] = {NULL, (void*)&arg__1};
2927 2927 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2928 2928 if (result) { Py_DECREF(result); }
2929 2929 Py_DECREF(obj);
2930 2930 return;
2931 2931 } else {
2932 2932 PyErr_Clear();
2933 2933 }
2934 2934 }
2935 2935 QHexSpinBox::enterEvent(arg__1);
2936 2936 }
2937 2937 bool PythonQtShell_QHexSpinBox::event(QEvent* event0)
2938 2938 {
2939 2939 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2940 2940 static PyObject* name = PyString_FromString("event");
2941 2941 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2942 2942 if (obj) {
2943 2943 static const char* argumentList[] ={"bool" , "QEvent*"};
2944 2944 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2945 2945 bool returnValue;
2946 2946 void* args[2] = {NULL, (void*)&event0};
2947 2947 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2948 2948 if (result) {
2949 2949 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2950 2950 if (args[0]!=&returnValue) {
2951 2951 if (args[0]==NULL) {
2952 2952 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
2953 2953 } else {
2954 2954 returnValue = *((bool*)args[0]);
2955 2955 }
2956 2956 }
2957 2957 }
2958 2958 if (result) { Py_DECREF(result); }
2959 2959 Py_DECREF(obj);
2960 2960 return returnValue;
2961 2961 } else {
2962 2962 PyErr_Clear();
2963 2963 }
2964 2964 }
2965 2965 return QHexSpinBox::event(event0);
2966 2966 }
2967 2967 bool PythonQtShell_QHexSpinBox::eventFilter(QObject* arg__1, QEvent* arg__2)
2968 2968 {
2969 2969 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2970 2970 static PyObject* name = PyString_FromString("eventFilter");
2971 2971 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2972 2972 if (obj) {
2973 2973 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
2974 2974 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2975 2975 bool returnValue;
2976 2976 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
2977 2977 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2978 2978 if (result) {
2979 2979 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2980 2980 if (args[0]!=&returnValue) {
2981 2981 if (args[0]==NULL) {
2982 2982 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
2983 2983 } else {
2984 2984 returnValue = *((bool*)args[0]);
2985 2985 }
2986 2986 }
2987 2987 }
2988 2988 if (result) { Py_DECREF(result); }
2989 2989 Py_DECREF(obj);
2990 2990 return returnValue;
2991 2991 } else {
2992 2992 PyErr_Clear();
2993 2993 }
2994 2994 }
2995 2995 return QHexSpinBox::eventFilter(arg__1, arg__2);
2996 2996 }
2997 2997 void PythonQtShell_QHexSpinBox::fixup(QString& str0) const
2998 2998 {
2999 2999 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3000 3000 static PyObject* name = PyString_FromString("fixup");
3001 3001 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3002 3002 if (obj) {
3003 3003 static const char* argumentList[] ={"" , "QString&"};
3004 3004 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3005 3005 void* args[2] = {NULL, (void*)&str0};
3006 3006 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3007 3007 if (result) { Py_DECREF(result); }
3008 3008 Py_DECREF(obj);
3009 3009 return;
3010 3010 } else {
3011 3011 PyErr_Clear();
3012 3012 }
3013 3013 }
3014 3014 QHexSpinBox::fixup(str0);
3015 3015 }
3016 3016 void PythonQtShell_QHexSpinBox::focusInEvent(QFocusEvent* event0)
3017 3017 {
3018 3018 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3019 3019 static PyObject* name = PyString_FromString("focusInEvent");
3020 3020 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3021 3021 if (obj) {
3022 3022 static const char* argumentList[] ={"" , "QFocusEvent*"};
3023 3023 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3024 3024 void* args[2] = {NULL, (void*)&event0};
3025 3025 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3026 3026 if (result) { Py_DECREF(result); }
3027 3027 Py_DECREF(obj);
3028 3028 return;
3029 3029 } else {
3030 3030 PyErr_Clear();
3031 3031 }
3032 3032 }
3033 3033 QHexSpinBox::focusInEvent(event0);
3034 3034 }
3035 3035 bool PythonQtShell_QHexSpinBox::focusNextPrevChild(bool next0)
3036 3036 {
3037 3037 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3038 3038 static PyObject* name = PyString_FromString("focusNextPrevChild");
3039 3039 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3040 3040 if (obj) {
3041 3041 static const char* argumentList[] ={"bool" , "bool"};
3042 3042 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3043 3043 bool returnValue;
3044 3044 void* args[2] = {NULL, (void*)&next0};
3045 3045 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3046 3046 if (result) {
3047 3047 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3048 3048 if (args[0]!=&returnValue) {
3049 3049 if (args[0]==NULL) {
3050 3050 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
3051 3051 } else {
3052 3052 returnValue = *((bool*)args[0]);
3053 3053 }
3054 3054 }
3055 3055 }
3056 3056 if (result) { Py_DECREF(result); }
3057 3057 Py_DECREF(obj);
3058 3058 return returnValue;
3059 3059 } else {
3060 3060 PyErr_Clear();
3061 3061 }
3062 3062 }
3063 3063 return QHexSpinBox::focusNextPrevChild(next0);
3064 3064 }
3065 3065 void PythonQtShell_QHexSpinBox::focusOutEvent(QFocusEvent* event0)
3066 3066 {
3067 3067 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3068 3068 static PyObject* name = PyString_FromString("focusOutEvent");
3069 3069 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3070 3070 if (obj) {
3071 3071 static const char* argumentList[] ={"" , "QFocusEvent*"};
3072 3072 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3073 3073 void* args[2] = {NULL, (void*)&event0};
3074 3074 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3075 3075 if (result) { Py_DECREF(result); }
3076 3076 Py_DECREF(obj);
3077 3077 return;
3078 3078 } else {
3079 3079 PyErr_Clear();
3080 3080 }
3081 3081 }
3082 3082 QHexSpinBox::focusOutEvent(event0);
3083 3083 }
3084 3084 bool PythonQtShell_QHexSpinBox::hasHeightForWidth() const
3085 3085 {
3086 3086 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3087 3087 static PyObject* name = PyString_FromString("hasHeightForWidth");
3088 3088 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3089 3089 if (obj) {
3090 3090 static const char* argumentList[] ={"bool"};
3091 3091 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3092 3092 bool returnValue;
3093 3093 void* args[1] = {NULL};
3094 3094 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3095 3095 if (result) {
3096 3096 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3097 3097 if (args[0]!=&returnValue) {
3098 3098 if (args[0]==NULL) {
3099 3099 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
3100 3100 } else {
3101 3101 returnValue = *((bool*)args[0]);
3102 3102 }
3103 3103 }
3104 3104 }
3105 3105 if (result) { Py_DECREF(result); }
3106 3106 Py_DECREF(obj);
3107 3107 return returnValue;
3108 3108 } else {
3109 3109 PyErr_Clear();
3110 3110 }
3111 3111 }
3112 3112 return QHexSpinBox::hasHeightForWidth();
3113 3113 }
3114 3114 int PythonQtShell_QHexSpinBox::heightForWidth(int arg__1) const
3115 3115 {
3116 3116 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3117 3117 static PyObject* name = PyString_FromString("heightForWidth");
3118 3118 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3119 3119 if (obj) {
3120 3120 static const char* argumentList[] ={"int" , "int"};
3121 3121 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3122 3122 int returnValue;
3123 3123 void* args[2] = {NULL, (void*)&arg__1};
3124 3124 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3125 3125 if (result) {
3126 3126 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3127 3127 if (args[0]!=&returnValue) {
3128 3128 if (args[0]==NULL) {
3129 3129 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
3130 3130 } else {
3131 3131 returnValue = *((int*)args[0]);
3132 3132 }
3133 3133 }
3134 3134 }
3135 3135 if (result) { Py_DECREF(result); }
3136 3136 Py_DECREF(obj);
3137 3137 return returnValue;
3138 3138 } else {
3139 3139 PyErr_Clear();
3140 3140 }
3141 3141 }
3142 3142 return QHexSpinBox::heightForWidth(arg__1);
3143 3143 }
3144 3144 void PythonQtShell_QHexSpinBox::hideEvent(QHideEvent* event0)
3145 3145 {
3146 3146 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3147 3147 static PyObject* name = PyString_FromString("hideEvent");
3148 3148 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3149 3149 if (obj) {
3150 3150 static const char* argumentList[] ={"" , "QHideEvent*"};
3151 3151 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3152 3152 void* args[2] = {NULL, (void*)&event0};
3153 3153 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3154 3154 if (result) { Py_DECREF(result); }
3155 3155 Py_DECREF(obj);
3156 3156 return;
3157 3157 } else {
3158 3158 PyErr_Clear();
3159 3159 }
3160 3160 }
3161 3161 QHexSpinBox::hideEvent(event0);
3162 3162 }
3163 3163 void PythonQtShell_QHexSpinBox::initPainter(QPainter* painter0) const
3164 3164 {
3165 3165 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3166 3166 static PyObject* name = PyString_FromString("initPainter");
3167 3167 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3168 3168 if (obj) {
3169 3169 static const char* argumentList[] ={"" , "QPainter*"};
3170 3170 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3171 3171 void* args[2] = {NULL, (void*)&painter0};
3172 3172 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3173 3173 if (result) { Py_DECREF(result); }
3174 3174 Py_DECREF(obj);
3175 3175 return;
3176 3176 } else {
3177 3177 PyErr_Clear();
3178 3178 }
3179 3179 }
3180 3180 QHexSpinBox::initPainter(painter0);
3181 3181 }
3182 3182 void PythonQtShell_QHexSpinBox::inputMethodEvent(QInputMethodEvent* arg__1)
3183 3183 {
3184 3184 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3185 3185 static PyObject* name = PyString_FromString("inputMethodEvent");
3186 3186 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3187 3187 if (obj) {
3188 3188 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
3189 3189 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3190 3190 void* args[2] = {NULL, (void*)&arg__1};
3191 3191 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3192 3192 if (result) { Py_DECREF(result); }
3193 3193 Py_DECREF(obj);
3194 3194 return;
3195 3195 } else {
3196 3196 PyErr_Clear();
3197 3197 }
3198 3198 }
3199 3199 QHexSpinBox::inputMethodEvent(arg__1);
3200 3200 }
3201 3201 QVariant PythonQtShell_QHexSpinBox::inputMethodQuery(Qt::InputMethodQuery arg__1) const
3202 3202 {
3203 3203 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3204 3204 static PyObject* name = PyString_FromString("inputMethodQuery");
3205 3205 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3206 3206 if (obj) {
3207 3207 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
3208 3208 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3209 3209 QVariant returnValue;
3210 3210 void* args[2] = {NULL, (void*)&arg__1};
3211 3211 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3212 3212 if (result) {
3213 3213 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3214 3214 if (args[0]!=&returnValue) {
3215 3215 if (args[0]==NULL) {
3216 3216 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
3217 3217 } else {
3218 3218 returnValue = *((QVariant*)args[0]);
3219 3219 }
3220 3220 }
3221 3221 }
3222 3222 if (result) { Py_DECREF(result); }
3223 3223 Py_DECREF(obj);
3224 3224 return returnValue;
3225 3225 } else {
3226 3226 PyErr_Clear();
3227 3227 }
3228 3228 }
3229 3229 return QHexSpinBox::inputMethodQuery(arg__1);
3230 3230 }
3231 3231 void PythonQtShell_QHexSpinBox::keyPressEvent(QKeyEvent* event0)
3232 3232 {
3233 3233 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3234 3234 static PyObject* name = PyString_FromString("keyPressEvent");
3235 3235 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3236 3236 if (obj) {
3237 3237 static const char* argumentList[] ={"" , "QKeyEvent*"};
3238 3238 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3239 3239 void* args[2] = {NULL, (void*)&event0};
3240 3240 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3241 3241 if (result) { Py_DECREF(result); }
3242 3242 Py_DECREF(obj);
3243 3243 return;
3244 3244 } else {
3245 3245 PyErr_Clear();
3246 3246 }
3247 3247 }
3248 3248 QHexSpinBox::keyPressEvent(event0);
3249 3249 }
3250 3250 void PythonQtShell_QHexSpinBox::keyReleaseEvent(QKeyEvent* event0)
3251 3251 {
3252 3252 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3253 3253 static PyObject* name = PyString_FromString("keyReleaseEvent");
3254 3254 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3255 3255 if (obj) {
3256 3256 static const char* argumentList[] ={"" , "QKeyEvent*"};
3257 3257 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3258 3258 void* args[2] = {NULL, (void*)&event0};
3259 3259 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3260 3260 if (result) { Py_DECREF(result); }
3261 3261 Py_DECREF(obj);
3262 3262 return;
3263 3263 } else {
3264 3264 PyErr_Clear();
3265 3265 }
3266 3266 }
3267 3267 QHexSpinBox::keyReleaseEvent(event0);
3268 3268 }
3269 3269 void PythonQtShell_QHexSpinBox::leaveEvent(QEvent* arg__1)
3270 3270 {
3271 3271 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3272 3272 static PyObject* name = PyString_FromString("leaveEvent");
3273 3273 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3274 3274 if (obj) {
3275 3275 static const char* argumentList[] ={"" , "QEvent*"};
3276 3276 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3277 3277 void* args[2] = {NULL, (void*)&arg__1};
3278 3278 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3279 3279 if (result) { Py_DECREF(result); }
3280 3280 Py_DECREF(obj);
3281 3281 return;
3282 3282 } else {
3283 3283 PyErr_Clear();
3284 3284 }
3285 3285 }
3286 3286 QHexSpinBox::leaveEvent(arg__1);
3287 3287 }
3288 3288 int PythonQtShell_QHexSpinBox::metric(QPaintDevice::PaintDeviceMetric arg__1) const
3289 3289 {
3290 3290 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3291 3291 static PyObject* name = PyString_FromString("metric");
3292 3292 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3293 3293 if (obj) {
3294 3294 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
3295 3295 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3296 3296 int returnValue;
3297 3297 void* args[2] = {NULL, (void*)&arg__1};
3298 3298 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3299 3299 if (result) {
3300 3300 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3301 3301 if (args[0]!=&returnValue) {
3302 3302 if (args[0]==NULL) {
3303 3303 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
3304 3304 } else {
3305 3305 returnValue = *((int*)args[0]);
3306 3306 }
3307 3307 }
3308 3308 }
3309 3309 if (result) { Py_DECREF(result); }
3310 3310 Py_DECREF(obj);
3311 3311 return returnValue;
3312 3312 } else {
3313 3313 PyErr_Clear();
3314 3314 }
3315 3315 }
3316 3316 return QHexSpinBox::metric(arg__1);
3317 3317 }
3318 3318 void PythonQtShell_QHexSpinBox::mouseDoubleClickEvent(QMouseEvent* arg__1)
3319 3319 {
3320 3320 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3321 3321 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
3322 3322 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3323 3323 if (obj) {
3324 3324 static const char* argumentList[] ={"" , "QMouseEvent*"};
3325 3325 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3326 3326 void* args[2] = {NULL, (void*)&arg__1};
3327 3327 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3328 3328 if (result) { Py_DECREF(result); }
3329 3329 Py_DECREF(obj);
3330 3330 return;
3331 3331 } else {
3332 3332 PyErr_Clear();
3333 3333 }
3334 3334 }
3335 3335 QHexSpinBox::mouseDoubleClickEvent(arg__1);
3336 3336 }
3337 3337 void PythonQtShell_QHexSpinBox::mouseMoveEvent(QMouseEvent* event0)
3338 3338 {
3339 3339 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3340 3340 static PyObject* name = PyString_FromString("mouseMoveEvent");
3341 3341 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3342 3342 if (obj) {
3343 3343 static const char* argumentList[] ={"" , "QMouseEvent*"};
3344 3344 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3345 3345 void* args[2] = {NULL, (void*)&event0};
3346 3346 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3347 3347 if (result) { Py_DECREF(result); }
3348 3348 Py_DECREF(obj);
3349 3349 return;
3350 3350 } else {
3351 3351 PyErr_Clear();
3352 3352 }
3353 3353 }
3354 3354 QHexSpinBox::mouseMoveEvent(event0);
3355 3355 }
3356 3356 void PythonQtShell_QHexSpinBox::mousePressEvent(QMouseEvent* event0)
3357 3357 {
3358 3358 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3359 3359 static PyObject* name = PyString_FromString("mousePressEvent");
3360 3360 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3361 3361 if (obj) {
3362 3362 static const char* argumentList[] ={"" , "QMouseEvent*"};
3363 3363 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3364 3364 void* args[2] = {NULL, (void*)&event0};
3365 3365 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3366 3366 if (result) { Py_DECREF(result); }
3367 3367 Py_DECREF(obj);
3368 3368 return;
3369 3369 } else {
3370 3370 PyErr_Clear();
3371 3371 }
3372 3372 }
3373 3373 QHexSpinBox::mousePressEvent(event0);
3374 3374 }
3375 3375 void PythonQtShell_QHexSpinBox::mouseReleaseEvent(QMouseEvent* event0)
3376 3376 {
3377 3377 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3378 3378 static PyObject* name = PyString_FromString("mouseReleaseEvent");
3379 3379 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3380 3380 if (obj) {
3381 3381 static const char* argumentList[] ={"" , "QMouseEvent*"};
3382 3382 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3383 3383 void* args[2] = {NULL, (void*)&event0};
3384 3384 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3385 3385 if (result) { Py_DECREF(result); }
3386 3386 Py_DECREF(obj);
3387 3387 return;
3388 3388 } else {
3389 3389 PyErr_Clear();
3390 3390 }
3391 3391 }
3392 3392 QHexSpinBox::mouseReleaseEvent(event0);
3393 3393 }
3394 3394 void PythonQtShell_QHexSpinBox::moveEvent(QMoveEvent* arg__1)
3395 3395 {
3396 3396 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3397 3397 static PyObject* name = PyString_FromString("moveEvent");
3398 3398 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3399 3399 if (obj) {
3400 3400 static const char* argumentList[] ={"" , "QMoveEvent*"};
3401 3401 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3402 3402 void* args[2] = {NULL, (void*)&arg__1};
3403 3403 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3404 3404 if (result) { Py_DECREF(result); }
3405 3405 Py_DECREF(obj);
3406 3406 return;
3407 3407 } else {
3408 3408 PyErr_Clear();
3409 3409 }
3410 3410 }
3411 3411 QHexSpinBox::moveEvent(arg__1);
3412 3412 }
3413 3413 bool PythonQtShell_QHexSpinBox::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
3414 3414 {
3415 3415 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3416 3416 static PyObject* name = PyString_FromString("nativeEvent");
3417 3417 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3418 3418 if (obj) {
3419 3419 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
3420 3420 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
3421 3421 bool returnValue;
3422 3422 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
3423 3423 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3424 3424 if (result) {
3425 3425 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3426 3426 if (args[0]!=&returnValue) {
3427 3427 if (args[0]==NULL) {
3428 3428 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
3429 3429 } else {
3430 3430 returnValue = *((bool*)args[0]);
3431 3431 }
3432 3432 }
3433 3433 }
3434 3434 if (result) { Py_DECREF(result); }
3435 3435 Py_DECREF(obj);
3436 3436 return returnValue;
3437 3437 } else {
3438 3438 PyErr_Clear();
3439 3439 }
3440 3440 }
3441 3441 return QHexSpinBox::nativeEvent(eventType0, message1, result2);
3442 3442 }
3443 3443 QPaintEngine* PythonQtShell_QHexSpinBox::paintEngine() const
3444 3444 {
3445 3445 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3446 3446 static PyObject* name = PyString_FromString("paintEngine");
3447 3447 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3448 3448 if (obj) {
3449 3449 static const char* argumentList[] ={"QPaintEngine*"};
3450 3450 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3451 3451 QPaintEngine* returnValue;
3452 3452 void* args[1] = {NULL};
3453 3453 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3454 3454 if (result) {
3455 3455 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3456 3456 if (args[0]!=&returnValue) {
3457 3457 if (args[0]==NULL) {
3458 3458 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
3459 3459 } else {
3460 3460 returnValue = *((QPaintEngine**)args[0]);
3461 3461 }
3462 3462 }
3463 3463 }
3464 3464 if (result) { Py_DECREF(result); }
3465 3465 Py_DECREF(obj);
3466 3466 return returnValue;
3467 3467 } else {
3468 3468 PyErr_Clear();
3469 3469 }
3470 3470 }
3471 3471 return QHexSpinBox::paintEngine();
3472 3472 }
3473 3473 void PythonQtShell_QHexSpinBox::paintEvent(QPaintEvent* event0)
3474 3474 {
3475 3475 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3476 3476 static PyObject* name = PyString_FromString("paintEvent");
3477 3477 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3478 3478 if (obj) {
3479 3479 static const char* argumentList[] ={"" , "QPaintEvent*"};
3480 3480 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3481 3481 void* args[2] = {NULL, (void*)&event0};
3482 3482 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3483 3483 if (result) { Py_DECREF(result); }
3484 3484 Py_DECREF(obj);
3485 3485 return;
3486 3486 } else {
3487 3487 PyErr_Clear();
3488 3488 }
3489 3489 }
3490 3490 QHexSpinBox::paintEvent(event0);
3491 3491 }
3492 3492 QPaintDevice* PythonQtShell_QHexSpinBox::redirected(QPoint* offset0) const
3493 3493 {
3494 3494 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3495 3495 static PyObject* name = PyString_FromString("redirected");
3496 3496 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3497 3497 if (obj) {
3498 3498 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
3499 3499 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3500 3500 QPaintDevice* returnValue;
3501 3501 void* args[2] = {NULL, (void*)&offset0};
3502 3502 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3503 3503 if (result) {
3504 3504 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3505 3505 if (args[0]!=&returnValue) {
3506 3506 if (args[0]==NULL) {
3507 3507 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
3508 3508 } else {
3509 3509 returnValue = *((QPaintDevice**)args[0]);
3510 3510 }
3511 3511 }
3512 3512 }
3513 3513 if (result) { Py_DECREF(result); }
3514 3514 Py_DECREF(obj);
3515 3515 return returnValue;
3516 3516 } else {
3517 3517 PyErr_Clear();
3518 3518 }
3519 3519 }
3520 3520 return QHexSpinBox::redirected(offset0);
3521 3521 }
3522 3522 void PythonQtShell_QHexSpinBox::resizeEvent(QResizeEvent* event0)
3523 3523 {
3524 3524 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3525 3525 static PyObject* name = PyString_FromString("resizeEvent");
3526 3526 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3527 3527 if (obj) {
3528 3528 static const char* argumentList[] ={"" , "QResizeEvent*"};
3529 3529 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3530 3530 void* args[2] = {NULL, (void*)&event0};
3531 3531 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3532 3532 if (result) { Py_DECREF(result); }
3533 3533 Py_DECREF(obj);
3534 3534 return;
3535 3535 } else {
3536 3536 PyErr_Clear();
3537 3537 }
3538 3538 }
3539 3539 QHexSpinBox::resizeEvent(event0);
3540 3540 }
3541 3541 QPainter* PythonQtShell_QHexSpinBox::sharedPainter() const
3542 3542 {
3543 3543 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3544 3544 static PyObject* name = PyString_FromString("sharedPainter");
3545 3545 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3546 3546 if (obj) {
3547 3547 static const char* argumentList[] ={"QPainter*"};
3548 3548 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3549 3549 QPainter* returnValue;
3550 3550 void* args[1] = {NULL};
3551 3551 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3552 3552 if (result) {
3553 3553 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3554 3554 if (args[0]!=&returnValue) {
3555 3555 if (args[0]==NULL) {
3556 3556 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
3557 3557 } else {
3558 3558 returnValue = *((QPainter**)args[0]);
3559 3559 }
3560 3560 }
3561 3561 }
3562 3562 if (result) { Py_DECREF(result); }
3563 3563 Py_DECREF(obj);
3564 3564 return returnValue;
3565 3565 } else {
3566 3566 PyErr_Clear();
3567 3567 }
3568 3568 }
3569 3569 return QHexSpinBox::sharedPainter();
3570 3570 }
3571 3571 void PythonQtShell_QHexSpinBox::showEvent(QShowEvent* event0)
3572 3572 {
3573 3573 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3574 3574 static PyObject* name = PyString_FromString("showEvent");
3575 3575 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3576 3576 if (obj) {
3577 3577 static const char* argumentList[] ={"" , "QShowEvent*"};
3578 3578 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3579 3579 void* args[2] = {NULL, (void*)&event0};
3580 3580 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3581 3581 if (result) { Py_DECREF(result); }
3582 3582 Py_DECREF(obj);
3583 3583 return;
3584 3584 } else {
3585 3585 PyErr_Clear();
3586 3586 }
3587 3587 }
3588 3588 QHexSpinBox::showEvent(event0);
3589 3589 }
3590 3590 void PythonQtShell_QHexSpinBox::stepBy(int steps0)
3591 3591 {
3592 3592 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3593 3593 static PyObject* name = PyString_FromString("stepBy");
3594 3594 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3595 3595 if (obj) {
3596 3596 static const char* argumentList[] ={"" , "int"};
3597 3597 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3598 3598 void* args[2] = {NULL, (void*)&steps0};
3599 3599 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3600 3600 if (result) { Py_DECREF(result); }
3601 3601 Py_DECREF(obj);
3602 3602 return;
3603 3603 } else {
3604 3604 PyErr_Clear();
3605 3605 }
3606 3606 }
3607 3607 QHexSpinBox::stepBy(steps0);
3608 3608 }
3609 3609 QAbstractSpinBox::StepEnabled PythonQtShell_QHexSpinBox::stepEnabled() const
3610 3610 {
3611 3611 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3612 3612 static PyObject* name = PyString_FromString("stepEnabled");
3613 3613 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3614 3614 if (obj) {
3615 3615 static const char* argumentList[] ={"QAbstractSpinBox::StepEnabled"};
3616 3616 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3617 3617 QAbstractSpinBox::StepEnabled returnValue;
3618 3618 void* args[1] = {NULL};
3619 3619 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3620 3620 if (result) {
3621 3621 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3622 3622 if (args[0]!=&returnValue) {
3623 3623 if (args[0]==NULL) {
3624 3624 PythonQt::priv()->handleVirtualOverloadReturnError("stepEnabled", methodInfo, result);
3625 3625 } else {
3626 3626 returnValue = *((QAbstractSpinBox::StepEnabled*)args[0]);
3627 3627 }
3628 3628 }
3629 3629 }
3630 3630 if (result) { Py_DECREF(result); }
3631 3631 Py_DECREF(obj);
3632 3632 return returnValue;
3633 3633 } else {
3634 3634 PyErr_Clear();
3635 3635 }
3636 3636 }
3637 3637 return QHexSpinBox::stepEnabled();
3638 3638 }
3639 3639 void PythonQtShell_QHexSpinBox::tabletEvent(QTabletEvent* arg__1)
3640 3640 {
3641 3641 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3642 3642 static PyObject* name = PyString_FromString("tabletEvent");
3643 3643 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3644 3644 if (obj) {
3645 3645 static const char* argumentList[] ={"" , "QTabletEvent*"};
3646 3646 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3647 3647 void* args[2] = {NULL, (void*)&arg__1};
3648 3648 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3649 3649 if (result) { Py_DECREF(result); }
3650 3650 Py_DECREF(obj);
3651 3651 return;
3652 3652 } else {
3653 3653 PyErr_Clear();
3654 3654 }
3655 3655 }
3656 3656 QHexSpinBox::tabletEvent(arg__1);
3657 3657 }
3658 3658 QString PythonQtShell_QHexSpinBox::textFromValue(int value0) const
3659 3659 {
3660 3660 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3661 3661 static PyObject* name = PyString_FromString("textFromValue");
3662 3662 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3663 3663 if (obj) {
3664 3664 static const char* argumentList[] ={"QString" , "int"};
3665 3665 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3666 3666 QString returnValue;
3667 3667 void* args[2] = {NULL, (void*)&value0};
3668 3668 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3669 3669 if (result) {
3670 3670 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3671 3671 if (args[0]!=&returnValue) {
3672 3672 if (args[0]==NULL) {
3673 3673 PythonQt::priv()->handleVirtualOverloadReturnError("textFromValue", methodInfo, result);
3674 3674 } else {
3675 3675 returnValue = *((QString*)args[0]);
3676 3676 }
3677 3677 }
3678 3678 }
3679 3679 if (result) { Py_DECREF(result); }
3680 3680 Py_DECREF(obj);
3681 3681 return returnValue;
3682 3682 } else {
3683 3683 PyErr_Clear();
3684 3684 }
3685 3685 }
3686 3686 return QHexSpinBox::textFromValue(value0);
3687 3687 }
3688 3688 void PythonQtShell_QHexSpinBox::timerEvent(QTimerEvent* event0)
3689 3689 {
3690 3690 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3691 3691 static PyObject* name = PyString_FromString("timerEvent");
3692 3692 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3693 3693 if (obj) {
3694 3694 static const char* argumentList[] ={"" , "QTimerEvent*"};
3695 3695 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3696 3696 void* args[2] = {NULL, (void*)&event0};
3697 3697 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3698 3698 if (result) { Py_DECREF(result); }
3699 3699 Py_DECREF(obj);
3700 3700 return;
3701 3701 } else {
3702 3702 PyErr_Clear();
3703 3703 }
3704 3704 }
3705 3705 QHexSpinBox::timerEvent(event0);
3706 3706 }
3707 3707 QValidator::State PythonQtShell_QHexSpinBox::validate(QString& input0, int& pos1) const
3708 3708 {
3709 3709 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3710 3710 static PyObject* name = PyString_FromString("validate");
3711 3711 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3712 3712 if (obj) {
3713 3713 static const char* argumentList[] ={"QValidator::State" , "QString&" , "int&"};
3714 3714 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3715 3715 QValidator::State returnValue;
3716 3716 void* args[3] = {NULL, (void*)&input0, (void*)&pos1};
3717 3717 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3718 3718 if (result) {
3719 3719 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3720 3720 if (args[0]!=&returnValue) {
3721 3721 if (args[0]==NULL) {
3722 3722 PythonQt::priv()->handleVirtualOverloadReturnError("validate", methodInfo, result);
3723 3723 } else {
3724 3724 returnValue = *((QValidator::State*)args[0]);
3725 3725 }
3726 3726 }
3727 3727 }
3728 3728 if (result) { Py_DECREF(result); }
3729 3729 Py_DECREF(obj);
3730 3730 return returnValue;
3731 3731 } else {
3732 3732 PyErr_Clear();
3733 3733 }
3734 3734 }
3735 3735 return QHexSpinBox::validate(input0, pos1);
3736 3736 }
3737 3737 int PythonQtShell_QHexSpinBox::valueFromText(const QString& text0) const
3738 3738 {
3739 3739 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3740 3740 static PyObject* name = PyString_FromString("valueFromText");
3741 3741 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3742 3742 if (obj) {
3743 3743 static const char* argumentList[] ={"int" , "const QString&"};
3744 3744 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3745 3745 int returnValue;
3746 3746 void* args[2] = {NULL, (void*)&text0};
3747 3747 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3748 3748 if (result) {
3749 3749 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3750 3750 if (args[0]!=&returnValue) {
3751 3751 if (args[0]==NULL) {
3752 3752 PythonQt::priv()->handleVirtualOverloadReturnError("valueFromText", methodInfo, result);
3753 3753 } else {
3754 3754 returnValue = *((int*)args[0]);
3755 3755 }
3756 3756 }
3757 3757 }
3758 3758 if (result) { Py_DECREF(result); }
3759 3759 Py_DECREF(obj);
3760 3760 return returnValue;
3761 3761 } else {
3762 3762 PyErr_Clear();
3763 3763 }
3764 3764 }
3765 3765 return QHexSpinBox::valueFromText(text0);
3766 3766 }
3767 3767 void PythonQtShell_QHexSpinBox::wheelEvent(QWheelEvent* event0)
3768 3768 {
3769 3769 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3770 3770 static PyObject* name = PyString_FromString("wheelEvent");
3771 3771 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3772 3772 if (obj) {
3773 3773 static const char* argumentList[] ={"" , "QWheelEvent*"};
3774 3774 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3775 3775 void* args[2] = {NULL, (void*)&event0};
3776 3776 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3777 3777 if (result) { Py_DECREF(result); }
3778 3778 Py_DECREF(obj);
3779 3779 return;
3780 3780 } else {
3781 3781 PyErr_Clear();
3782 3782 }
3783 3783 }
3784 3784 QHexSpinBox::wheelEvent(event0);
3785 3785 }
3786 3786 QHexSpinBox* PythonQtWrapper_QHexSpinBox::new_QHexSpinBox(QWidget* parent)
3787 3787 {
3788 3788 return new PythonQtShell_QHexSpinBox(parent); }
3789 3789
3790 3790 void PythonQtWrapper_QHexSpinBox::show(QHexSpinBox* theWrappedObject)
3791 3791 {
3792 3792 ( theWrappedObject->show());
3793 3793 }
3794 3794
3795 3795 QString PythonQtWrapper_QHexSpinBox::textFromValue(QHexSpinBox* theWrappedObject, int value) const
3796 3796 {
3797 3797 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_textFromValue(value));
3798 3798 }
3799 3799
3800 3800 QValidator::State PythonQtWrapper_QHexSpinBox::validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const
3801 3801 {
3802 3802 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_validate(input, pos));
3803 3803 }
3804 3804
3805 3805 int PythonQtWrapper_QHexSpinBox::valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const
3806 3806 {
3807 3807 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_valueFromText(text));
3808 3808 }
3809 3809
3810 3810
3811 3811
3812 3812 PythonQtShell_SocExplorerPlot::~PythonQtShell_SocExplorerPlot() {
3813 3813 PythonQtPrivate* priv = PythonQt::priv();
3814 3814 if (priv) { priv->shellClassDeleted(this); }
3815 3815 }
3816 3816 void PythonQtShell_SocExplorerPlot::actionEvent(QActionEvent* arg__1)
3817 3817 {
3818 3818 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3819 3819 static PyObject* name = PyString_FromString("actionEvent");
3820 3820 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3821 3821 if (obj) {
3822 3822 static const char* argumentList[] ={"" , "QActionEvent*"};
3823 3823 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3824 3824 void* args[2] = {NULL, (void*)&arg__1};
3825 3825 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3826 3826 if (result) { Py_DECREF(result); }
3827 3827 Py_DECREF(obj);
3828 3828 return;
3829 3829 } else {
3830 3830 PyErr_Clear();
3831 3831 }
3832 3832 }
3833 3833 SocExplorerPlot::actionEvent(arg__1);
3834 3834 }
3835 3835 void PythonQtShell_SocExplorerPlot::changeEvent(QEvent* arg__1)
3836 3836 {
3837 3837 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3838 3838 static PyObject* name = PyString_FromString("changeEvent");
3839 3839 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3840 3840 if (obj) {
3841 3841 static const char* argumentList[] ={"" , "QEvent*"};
3842 3842 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3843 3843 void* args[2] = {NULL, (void*)&arg__1};
3844 3844 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3845 3845 if (result) { Py_DECREF(result); }
3846 3846 Py_DECREF(obj);
3847 3847 return;
3848 3848 } else {
3849 3849 PyErr_Clear();
3850 3850 }
3851 3851 }
3852 3852 SocExplorerPlot::changeEvent(arg__1);
3853 3853 }
3854 3854 void PythonQtShell_SocExplorerPlot::childEvent(QChildEvent* arg__1)
3855 3855 {
3856 3856 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3857 3857 static PyObject* name = PyString_FromString("childEvent");
3858 3858 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3859 3859 if (obj) {
3860 3860 static const char* argumentList[] ={"" , "QChildEvent*"};
3861 3861 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3862 3862 void* args[2] = {NULL, (void*)&arg__1};
3863 3863 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3864 3864 if (result) { Py_DECREF(result); }
3865 3865 Py_DECREF(obj);
3866 3866 return;
3867 3867 } else {
3868 3868 PyErr_Clear();
3869 3869 }
3870 3870 }
3871 3871 SocExplorerPlot::childEvent(arg__1);
3872 3872 }
3873 3873 void PythonQtShell_SocExplorerPlot::closeEvent(QCloseEvent* arg__1)
3874 3874 {
3875 3875 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3876 3876 static PyObject* name = PyString_FromString("closeEvent");
3877 3877 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3878 3878 if (obj) {
3879 3879 static const char* argumentList[] ={"" , "QCloseEvent*"};
3880 3880 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3881 3881 void* args[2] = {NULL, (void*)&arg__1};
3882 3882 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3883 3883 if (result) { Py_DECREF(result); }
3884 3884 Py_DECREF(obj);
3885 3885 return;
3886 3886 } else {
3887 3887 PyErr_Clear();
3888 3888 }
3889 3889 }
3890 3890 SocExplorerPlot::closeEvent(arg__1);
3891 3891 }
3892 3892 void PythonQtShell_SocExplorerPlot::contextMenuEvent(QContextMenuEvent* arg__1)
3893 3893 {
3894 3894 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3895 3895 static PyObject* name = PyString_FromString("contextMenuEvent");
3896 3896 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3897 3897 if (obj) {
3898 3898 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
3899 3899 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3900 3900 void* args[2] = {NULL, (void*)&arg__1};
3901 3901 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3902 3902 if (result) { Py_DECREF(result); }
3903 3903 Py_DECREF(obj);
3904 3904 return;
3905 3905 } else {
3906 3906 PyErr_Clear();
3907 3907 }
3908 3908 }
3909 3909 SocExplorerPlot::contextMenuEvent(arg__1);
3910 3910 }
3911 3911 void PythonQtShell_SocExplorerPlot::customEvent(QEvent* arg__1)
3912 3912 {
3913 3913 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3914 3914 static PyObject* name = PyString_FromString("customEvent");
3915 3915 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3916 3916 if (obj) {
3917 3917 static const char* argumentList[] ={"" , "QEvent*"};
3918 3918 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3919 3919 void* args[2] = {NULL, (void*)&arg__1};
3920 3920 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3921 3921 if (result) { Py_DECREF(result); }
3922 3922 Py_DECREF(obj);
3923 3923 return;
3924 3924 } else {
3925 3925 PyErr_Clear();
3926 3926 }
3927 3927 }
3928 3928 SocExplorerPlot::customEvent(arg__1);
3929 3929 }
3930 3930 int PythonQtShell_SocExplorerPlot::devType() const
3931 3931 {
3932 3932 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3933 3933 static PyObject* name = PyString_FromString("devType");
3934 3934 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3935 3935 if (obj) {
3936 3936 static const char* argumentList[] ={"int"};
3937 3937 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3938 3938 int returnValue;
3939 3939 void* args[1] = {NULL};
3940 3940 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3941 3941 if (result) {
3942 3942 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3943 3943 if (args[0]!=&returnValue) {
3944 3944 if (args[0]==NULL) {
3945 3945 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
3946 3946 } else {
3947 3947 returnValue = *((int*)args[0]);
3948 3948 }
3949 3949 }
3950 3950 }
3951 3951 if (result) { Py_DECREF(result); }
3952 3952 Py_DECREF(obj);
3953 3953 return returnValue;
3954 3954 } else {
3955 3955 PyErr_Clear();
3956 3956 }
3957 3957 }
3958 3958 return SocExplorerPlot::devType();
3959 3959 }
3960 3960 void PythonQtShell_SocExplorerPlot::dragEnterEvent(QDragEnterEvent* arg__1)
3961 3961 {
3962 3962 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3963 3963 static PyObject* name = PyString_FromString("dragEnterEvent");
3964 3964 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3965 3965 if (obj) {
3966 3966 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
3967 3967 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3968 3968 void* args[2] = {NULL, (void*)&arg__1};
3969 3969 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3970 3970 if (result) { Py_DECREF(result); }
3971 3971 Py_DECREF(obj);
3972 3972 return;
3973 3973 } else {
3974 3974 PyErr_Clear();
3975 3975 }
3976 3976 }
3977 3977 SocExplorerPlot::dragEnterEvent(arg__1);
3978 3978 }
3979 3979 void PythonQtShell_SocExplorerPlot::dragLeaveEvent(QDragLeaveEvent* arg__1)
3980 3980 {
3981 3981 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3982 3982 static PyObject* name = PyString_FromString("dragLeaveEvent");
3983 3983 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3984 3984 if (obj) {
3985 3985 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
3986 3986 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3987 3987 void* args[2] = {NULL, (void*)&arg__1};
3988 3988 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3989 3989 if (result) { Py_DECREF(result); }
3990 3990 Py_DECREF(obj);
3991 3991 return;
3992 3992 } else {
3993 3993 PyErr_Clear();
3994 3994 }
3995 3995 }
3996 3996 SocExplorerPlot::dragLeaveEvent(arg__1);
3997 3997 }
3998 3998 void PythonQtShell_SocExplorerPlot::dragMoveEvent(QDragMoveEvent* arg__1)
3999 3999 {
4000 4000 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4001 4001 static PyObject* name = PyString_FromString("dragMoveEvent");
4002 4002 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4003 4003 if (obj) {
4004 4004 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
4005 4005 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4006 4006 void* args[2] = {NULL, (void*)&arg__1};
4007 4007 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4008 4008 if (result) { Py_DECREF(result); }
4009 4009 Py_DECREF(obj);
4010 4010 return;
4011 4011 } else {
4012 4012 PyErr_Clear();
4013 4013 }
4014 4014 }
4015 4015 SocExplorerPlot::dragMoveEvent(arg__1);
4016 4016 }
4017 4017 void PythonQtShell_SocExplorerPlot::dropEvent(QDropEvent* arg__1)
4018 4018 {
4019 4019 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4020 4020 static PyObject* name = PyString_FromString("dropEvent");
4021 4021 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4022 4022 if (obj) {
4023 4023 static const char* argumentList[] ={"" , "QDropEvent*"};
4024 4024 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4025 4025 void* args[2] = {NULL, (void*)&arg__1};
4026 4026 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4027 4027 if (result) { Py_DECREF(result); }
4028 4028 Py_DECREF(obj);
4029 4029 return;
4030 4030 } else {
4031 4031 PyErr_Clear();
4032 4032 }
4033 4033 }
4034 4034 SocExplorerPlot::dropEvent(arg__1);
4035 4035 }
4036 4036 void PythonQtShell_SocExplorerPlot::enterEvent(QEvent* arg__1)
4037 4037 {
4038 4038 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4039 4039 static PyObject* name = PyString_FromString("enterEvent");
4040 4040 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4041 4041 if (obj) {
4042 4042 static const char* argumentList[] ={"" , "QEvent*"};
4043 4043 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4044 4044 void* args[2] = {NULL, (void*)&arg__1};
4045 4045 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4046 4046 if (result) { Py_DECREF(result); }
4047 4047 Py_DECREF(obj);
4048 4048 return;
4049 4049 } else {
4050 4050 PyErr_Clear();
4051 4051 }
4052 4052 }
4053 4053 SocExplorerPlot::enterEvent(arg__1);
4054 4054 }
4055 4055 bool PythonQtShell_SocExplorerPlot::event(QEvent* arg__1)
4056 4056 {
4057 4057 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4058 4058 static PyObject* name = PyString_FromString("event");
4059 4059 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4060 4060 if (obj) {
4061 4061 static const char* argumentList[] ={"bool" , "QEvent*"};
4062 4062 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4063 4063 bool returnValue;
4064 4064 void* args[2] = {NULL, (void*)&arg__1};
4065 4065 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4066 4066 if (result) {
4067 4067 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4068 4068 if (args[0]!=&returnValue) {
4069 4069 if (args[0]==NULL) {
4070 4070 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
4071 4071 } else {
4072 4072 returnValue = *((bool*)args[0]);
4073 4073 }
4074 4074 }
4075 4075 }
4076 4076 if (result) { Py_DECREF(result); }
4077 4077 Py_DECREF(obj);
4078 4078 return returnValue;
4079 4079 } else {
4080 4080 PyErr_Clear();
4081 4081 }
4082 4082 }
4083 4083 return SocExplorerPlot::event(arg__1);
4084 4084 }
4085 4085 bool PythonQtShell_SocExplorerPlot::eventFilter(QObject* arg__1, QEvent* arg__2)
4086 4086 {
4087 4087 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4088 4088 static PyObject* name = PyString_FromString("eventFilter");
4089 4089 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4090 4090 if (obj) {
4091 4091 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4092 4092 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4093 4093 bool returnValue;
4094 4094 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
4095 4095 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4096 4096 if (result) {
4097 4097 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4098 4098 if (args[0]!=&returnValue) {
4099 4099 if (args[0]==NULL) {
4100 4100 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
4101 4101 } else {
4102 4102 returnValue = *((bool*)args[0]);
4103 4103 }
4104 4104 }
4105 4105 }
4106 4106 if (result) { Py_DECREF(result); }
4107 4107 Py_DECREF(obj);
4108 4108 return returnValue;
4109 4109 } else {
4110 4110 PyErr_Clear();
4111 4111 }
4112 4112 }
4113 4113 return SocExplorerPlot::eventFilter(arg__1, arg__2);
4114 4114 }
4115 4115 void PythonQtShell_SocExplorerPlot::focusInEvent(QFocusEvent* arg__1)
4116 4116 {
4117 4117 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4118 4118 static PyObject* name = PyString_FromString("focusInEvent");
4119 4119 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4120 4120 if (obj) {
4121 4121 static const char* argumentList[] ={"" , "QFocusEvent*"};
4122 4122 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4123 4123 void* args[2] = {NULL, (void*)&arg__1};
4124 4124 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4125 4125 if (result) { Py_DECREF(result); }
4126 4126 Py_DECREF(obj);
4127 4127 return;
4128 4128 } else {
4129 4129 PyErr_Clear();
4130 4130 }
4131 4131 }
4132 4132 SocExplorerPlot::focusInEvent(arg__1);
4133 4133 }
4134 4134 bool PythonQtShell_SocExplorerPlot::focusNextPrevChild(bool next0)
4135 4135 {
4136 4136 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4137 4137 static PyObject* name = PyString_FromString("focusNextPrevChild");
4138 4138 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4139 4139 if (obj) {
4140 4140 static const char* argumentList[] ={"bool" , "bool"};
4141 4141 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4142 4142 bool returnValue;
4143 4143 void* args[2] = {NULL, (void*)&next0};
4144 4144 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4145 4145 if (result) {
4146 4146 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4147 4147 if (args[0]!=&returnValue) {
4148 4148 if (args[0]==NULL) {
4149 4149 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
4150 4150 } else {
4151 4151 returnValue = *((bool*)args[0]);
4152 4152 }
4153 4153 }
4154 4154 }
4155 4155 if (result) { Py_DECREF(result); }
4156 4156 Py_DECREF(obj);
4157 4157 return returnValue;
4158 4158 } else {
4159 4159 PyErr_Clear();
4160 4160 }
4161 4161 }
4162 4162 return SocExplorerPlot::focusNextPrevChild(next0);
4163 4163 }
4164 4164 void PythonQtShell_SocExplorerPlot::focusOutEvent(QFocusEvent* arg__1)
4165 4165 {
4166 4166 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4167 4167 static PyObject* name = PyString_FromString("focusOutEvent");
4168 4168 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4169 4169 if (obj) {
4170 4170 static const char* argumentList[] ={"" , "QFocusEvent*"};
4171 4171 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4172 4172 void* args[2] = {NULL, (void*)&arg__1};
4173 4173 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4174 4174 if (result) { Py_DECREF(result); }
4175 4175 Py_DECREF(obj);
4176 4176 return;
4177 4177 } else {
4178 4178 PyErr_Clear();
4179 4179 }
4180 4180 }
4181 4181 SocExplorerPlot::focusOutEvent(arg__1);
4182 4182 }
4183 4183 bool PythonQtShell_SocExplorerPlot::hasHeightForWidth() const
4184 4184 {
4185 4185 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4186 4186 static PyObject* name = PyString_FromString("hasHeightForWidth");
4187 4187 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4188 4188 if (obj) {
4189 4189 static const char* argumentList[] ={"bool"};
4190 4190 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4191 4191 bool returnValue;
4192 4192 void* args[1] = {NULL};
4193 4193 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4194 4194 if (result) {
4195 4195 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4196 4196 if (args[0]!=&returnValue) {
4197 4197 if (args[0]==NULL) {
4198 4198 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
4199 4199 } else {
4200 4200 returnValue = *((bool*)args[0]);
4201 4201 }
4202 4202 }
4203 4203 }
4204 4204 if (result) { Py_DECREF(result); }
4205 4205 Py_DECREF(obj);
4206 4206 return returnValue;
4207 4207 } else {
4208 4208 PyErr_Clear();
4209 4209 }
4210 4210 }
4211 4211 return SocExplorerPlot::hasHeightForWidth();
4212 4212 }
4213 4213 int PythonQtShell_SocExplorerPlot::heightForWidth(int arg__1) const
4214 4214 {
4215 4215 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4216 4216 static PyObject* name = PyString_FromString("heightForWidth");
4217 4217 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4218 4218 if (obj) {
4219 4219 static const char* argumentList[] ={"int" , "int"};
4220 4220 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4221 4221 int returnValue;
4222 4222 void* args[2] = {NULL, (void*)&arg__1};
4223 4223 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4224 4224 if (result) {
4225 4225 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4226 4226 if (args[0]!=&returnValue) {
4227 4227 if (args[0]==NULL) {
4228 4228 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
4229 4229 } else {
4230 4230 returnValue = *((int*)args[0]);
4231 4231 }
4232 4232 }
4233 4233 }
4234 4234 if (result) { Py_DECREF(result); }
4235 4235 Py_DECREF(obj);
4236 4236 return returnValue;
4237 4237 } else {
4238 4238 PyErr_Clear();
4239 4239 }
4240 4240 }
4241 4241 return SocExplorerPlot::heightForWidth(arg__1);
4242 4242 }
4243 4243 void PythonQtShell_SocExplorerPlot::hideEvent(QHideEvent* arg__1)
4244 4244 {
4245 4245 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4246 4246 static PyObject* name = PyString_FromString("hideEvent");
4247 4247 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4248 4248 if (obj) {
4249 4249 static const char* argumentList[] ={"" , "QHideEvent*"};
4250 4250 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4251 4251 void* args[2] = {NULL, (void*)&arg__1};
4252 4252 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4253 4253 if (result) { Py_DECREF(result); }
4254 4254 Py_DECREF(obj);
4255 4255 return;
4256 4256 } else {
4257 4257 PyErr_Clear();
4258 4258 }
4259 4259 }
4260 4260 SocExplorerPlot::hideEvent(arg__1);
4261 4261 }
4262 4262 void PythonQtShell_SocExplorerPlot::initPainter(QPainter* painter0) const
4263 4263 {
4264 4264 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4265 4265 static PyObject* name = PyString_FromString("initPainter");
4266 4266 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4267 4267 if (obj) {
4268 4268 static const char* argumentList[] ={"" , "QPainter*"};
4269 4269 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4270 4270 void* args[2] = {NULL, (void*)&painter0};
4271 4271 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4272 4272 if (result) { Py_DECREF(result); }
4273 4273 Py_DECREF(obj);
4274 4274 return;
4275 4275 } else {
4276 4276 PyErr_Clear();
4277 4277 }
4278 4278 }
4279 4279 SocExplorerPlot::initPainter(painter0);
4280 4280 }
4281 4281 void PythonQtShell_SocExplorerPlot::inputMethodEvent(QInputMethodEvent* arg__1)
4282 4282 {
4283 4283 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4284 4284 static PyObject* name = PyString_FromString("inputMethodEvent");
4285 4285 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4286 4286 if (obj) {
4287 4287 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
4288 4288 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4289 4289 void* args[2] = {NULL, (void*)&arg__1};
4290 4290 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4291 4291 if (result) { Py_DECREF(result); }
4292 4292 Py_DECREF(obj);
4293 4293 return;
4294 4294 } else {
4295 4295 PyErr_Clear();
4296 4296 }
4297 4297 }
4298 4298 SocExplorerPlot::inputMethodEvent(arg__1);
4299 4299 }
4300 4300 QVariant PythonQtShell_SocExplorerPlot::inputMethodQuery(Qt::InputMethodQuery arg__1) const
4301 4301 {
4302 4302 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4303 4303 static PyObject* name = PyString_FromString("inputMethodQuery");
4304 4304 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4305 4305 if (obj) {
4306 4306 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
4307 4307 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4308 4308 QVariant returnValue;
4309 4309 void* args[2] = {NULL, (void*)&arg__1};
4310 4310 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4311 4311 if (result) {
4312 4312 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4313 4313 if (args[0]!=&returnValue) {
4314 4314 if (args[0]==NULL) {
4315 4315 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
4316 4316 } else {
4317 4317 returnValue = *((QVariant*)args[0]);
4318 4318 }
4319 4319 }
4320 4320 }
4321 4321 if (result) { Py_DECREF(result); }
4322 4322 Py_DECREF(obj);
4323 4323 return returnValue;
4324 4324 } else {
4325 4325 PyErr_Clear();
4326 4326 }
4327 4327 }
4328 4328 return SocExplorerPlot::inputMethodQuery(arg__1);
4329 4329 }
4330 4330 void PythonQtShell_SocExplorerPlot::keyPressEvent(QKeyEvent* arg__1)
4331 4331 {
4332 4332 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4333 4333 static PyObject* name = PyString_FromString("keyPressEvent");
4334 4334 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4335 4335 if (obj) {
4336 4336 static const char* argumentList[] ={"" , "QKeyEvent*"};
4337 4337 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4338 4338 void* args[2] = {NULL, (void*)&arg__1};
4339 4339 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4340 4340 if (result) { Py_DECREF(result); }
4341 4341 Py_DECREF(obj);
4342 4342 return;
4343 4343 } else {
4344 4344 PyErr_Clear();
4345 4345 }
4346 4346 }
4347 4347 SocExplorerPlot::keyPressEvent(arg__1);
4348 4348 }
4349 4349 void PythonQtShell_SocExplorerPlot::keyReleaseEvent(QKeyEvent* arg__1)
4350 4350 {
4351 4351 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4352 4352 static PyObject* name = PyString_FromString("keyReleaseEvent");
4353 4353 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4354 4354 if (obj) {
4355 4355 static const char* argumentList[] ={"" , "QKeyEvent*"};
4356 4356 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4357 4357 void* args[2] = {NULL, (void*)&arg__1};
4358 4358 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4359 4359 if (result) { Py_DECREF(result); }
4360 4360 Py_DECREF(obj);
4361 4361 return;
4362 4362 } else {
4363 4363 PyErr_Clear();
4364 4364 }
4365 4365 }
4366 4366 SocExplorerPlot::keyReleaseEvent(arg__1);
4367 4367 }
4368 4368 void PythonQtShell_SocExplorerPlot::leaveEvent(QEvent* arg__1)
4369 4369 {
4370 4370 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4371 4371 static PyObject* name = PyString_FromString("leaveEvent");
4372 4372 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4373 4373 if (obj) {
4374 4374 static const char* argumentList[] ={"" , "QEvent*"};
4375 4375 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4376 4376 void* args[2] = {NULL, (void*)&arg__1};
4377 4377 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4378 4378 if (result) { Py_DECREF(result); }
4379 4379 Py_DECREF(obj);
4380 4380 return;
4381 4381 } else {
4382 4382 PyErr_Clear();
4383 4383 }
4384 4384 }
4385 4385 SocExplorerPlot::leaveEvent(arg__1);
4386 4386 }
4387 4387 int PythonQtShell_SocExplorerPlot::metric(QPaintDevice::PaintDeviceMetric arg__1) const
4388 4388 {
4389 4389 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4390 4390 static PyObject* name = PyString_FromString("metric");
4391 4391 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4392 4392 if (obj) {
4393 4393 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
4394 4394 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4395 4395 int returnValue;
4396 4396 void* args[2] = {NULL, (void*)&arg__1};
4397 4397 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4398 4398 if (result) {
4399 4399 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4400 4400 if (args[0]!=&returnValue) {
4401 4401 if (args[0]==NULL) {
4402 4402 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
4403 4403 } else {
4404 4404 returnValue = *((int*)args[0]);
4405 4405 }
4406 4406 }
4407 4407 }
4408 4408 if (result) { Py_DECREF(result); }
4409 4409 Py_DECREF(obj);
4410 4410 return returnValue;
4411 4411 } else {
4412 4412 PyErr_Clear();
4413 4413 }
4414 4414 }
4415 4415 return SocExplorerPlot::metric(arg__1);
4416 4416 }
4417 4417 QSize PythonQtShell_SocExplorerPlot::minimumSizeHint() const
4418 4418 {
4419 4419 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4420 4420 static PyObject* name = PyString_FromString("getMinimumSizeHint");
4421 4421 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4422 4422 if (obj) {
4423 4423 static const char* argumentList[] ={"QSize"};
4424 4424 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4425 4425 QSize returnValue;
4426 4426 void* args[1] = {NULL};
4427 4427 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4428 4428 if (result) {
4429 4429 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4430 4430 if (args[0]!=&returnValue) {
4431 4431 if (args[0]==NULL) {
4432 4432 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
4433 4433 } else {
4434 4434 returnValue = *((QSize*)args[0]);
4435 4435 }
4436 4436 }
4437 4437 }
4438 4438 if (result) { Py_DECREF(result); }
4439 4439 Py_DECREF(obj);
4440 4440 return returnValue;
4441 4441 } else {
4442 4442 PyErr_Clear();
4443 4443 }
4444 4444 }
4445 4445 return SocExplorerPlot::minimumSizeHint();
4446 4446 }
4447 4447 void PythonQtShell_SocExplorerPlot::mouseDoubleClickEvent(QMouseEvent* arg__1)
4448 4448 {
4449 4449 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4450 4450 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
4451 4451 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4452 4452 if (obj) {
4453 4453 static const char* argumentList[] ={"" , "QMouseEvent*"};
4454 4454 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4455 4455 void* args[2] = {NULL, (void*)&arg__1};
4456 4456 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4457 4457 if (result) { Py_DECREF(result); }
4458 4458 Py_DECREF(obj);
4459 4459 return;
4460 4460 } else {
4461 4461 PyErr_Clear();
4462 4462 }
4463 4463 }
4464 4464 SocExplorerPlot::mouseDoubleClickEvent(arg__1);
4465 4465 }
4466 4466 void PythonQtShell_SocExplorerPlot::mouseMoveEvent(QMouseEvent* arg__1)
4467 4467 {
4468 4468 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4469 4469 static PyObject* name = PyString_FromString("mouseMoveEvent");
4470 4470 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4471 4471 if (obj) {
4472 4472 static const char* argumentList[] ={"" , "QMouseEvent*"};
4473 4473 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4474 4474 void* args[2] = {NULL, (void*)&arg__1};
4475 4475 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4476 4476 if (result) { Py_DECREF(result); }
4477 4477 Py_DECREF(obj);
4478 4478 return;
4479 4479 } else {
4480 4480 PyErr_Clear();
4481 4481 }
4482 4482 }
4483 4483 SocExplorerPlot::mouseMoveEvent(arg__1);
4484 4484 }
4485 4485 void PythonQtShell_SocExplorerPlot::mousePressEvent(QMouseEvent* arg__1)
4486 4486 {
4487 4487 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4488 4488 static PyObject* name = PyString_FromString("mousePressEvent");
4489 4489 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4490 4490 if (obj) {
4491 4491 static const char* argumentList[] ={"" , "QMouseEvent*"};
4492 4492 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4493 4493 void* args[2] = {NULL, (void*)&arg__1};
4494 4494 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4495 4495 if (result) { Py_DECREF(result); }
4496 4496 Py_DECREF(obj);
4497 4497 return;
4498 4498 } else {
4499 4499 PyErr_Clear();
4500 4500 }
4501 4501 }
4502 4502 SocExplorerPlot::mousePressEvent(arg__1);
4503 4503 }
4504 4504 void PythonQtShell_SocExplorerPlot::mouseReleaseEvent(QMouseEvent* arg__1)
4505 4505 {
4506 4506 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4507 4507 static PyObject* name = PyString_FromString("mouseReleaseEvent");
4508 4508 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4509 4509 if (obj) {
4510 4510 static const char* argumentList[] ={"" , "QMouseEvent*"};
4511 4511 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4512 4512 void* args[2] = {NULL, (void*)&arg__1};
4513 4513 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4514 4514 if (result) { Py_DECREF(result); }
4515 4515 Py_DECREF(obj);
4516 4516 return;
4517 4517 } else {
4518 4518 PyErr_Clear();
4519 4519 }
4520 4520 }
4521 4521 SocExplorerPlot::mouseReleaseEvent(arg__1);
4522 4522 }
4523 4523 void PythonQtShell_SocExplorerPlot::moveEvent(QMoveEvent* arg__1)
4524 4524 {
4525 4525 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4526 4526 static PyObject* name = PyString_FromString("moveEvent");
4527 4527 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4528 4528 if (obj) {
4529 4529 static const char* argumentList[] ={"" , "QMoveEvent*"};
4530 4530 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4531 4531 void* args[2] = {NULL, (void*)&arg__1};
4532 4532 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4533 4533 if (result) { Py_DECREF(result); }
4534 4534 Py_DECREF(obj);
4535 4535 return;
4536 4536 } else {
4537 4537 PyErr_Clear();
4538 4538 }
4539 4539 }
4540 4540 SocExplorerPlot::moveEvent(arg__1);
4541 4541 }
4542 4542 bool PythonQtShell_SocExplorerPlot::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
4543 4543 {
4544 4544 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4545 4545 static PyObject* name = PyString_FromString("nativeEvent");
4546 4546 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4547 4547 if (obj) {
4548 4548 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
4549 4549 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
4550 4550 bool returnValue;
4551 4551 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
4552 4552 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4553 4553 if (result) {
4554 4554 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4555 4555 if (args[0]!=&returnValue) {
4556 4556 if (args[0]==NULL) {
4557 4557 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
4558 4558 } else {
4559 4559 returnValue = *((bool*)args[0]);
4560 4560 }
4561 4561 }
4562 4562 }
4563 4563 if (result) { Py_DECREF(result); }
4564 4564 Py_DECREF(obj);
4565 4565 return returnValue;
4566 4566 } else {
4567 4567 PyErr_Clear();
4568 4568 }
4569 4569 }
4570 4570 return SocExplorerPlot::nativeEvent(eventType0, message1, result2);
4571 4571 }
4572 4572 QPaintEngine* PythonQtShell_SocExplorerPlot::paintEngine() const
4573 4573 {
4574 4574 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4575 4575 static PyObject* name = PyString_FromString("paintEngine");
4576 4576 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4577 4577 if (obj) {
4578 4578 static const char* argumentList[] ={"QPaintEngine*"};
4579 4579 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4580 4580 QPaintEngine* returnValue;
4581 4581 void* args[1] = {NULL};
4582 4582 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4583 4583 if (result) {
4584 4584 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4585 4585 if (args[0]!=&returnValue) {
4586 4586 if (args[0]==NULL) {
4587 4587 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
4588 4588 } else {
4589 4589 returnValue = *((QPaintEngine**)args[0]);
4590 4590 }
4591 4591 }
4592 4592 }
4593 4593 if (result) { Py_DECREF(result); }
4594 4594 Py_DECREF(obj);
4595 4595 return returnValue;
4596 4596 } else {
4597 4597 PyErr_Clear();
4598 4598 }
4599 4599 }
4600 4600 return SocExplorerPlot::paintEngine();
4601 4601 }
4602 4602 void PythonQtShell_SocExplorerPlot::paintEvent(QPaintEvent* arg__1)
4603 4603 {
4604 4604 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4605 4605 static PyObject* name = PyString_FromString("paintEvent");
4606 4606 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4607 4607 if (obj) {
4608 4608 static const char* argumentList[] ={"" , "QPaintEvent*"};
4609 4609 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4610 4610 void* args[2] = {NULL, (void*)&arg__1};
4611 4611 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4612 4612 if (result) { Py_DECREF(result); }
4613 4613 Py_DECREF(obj);
4614 4614 return;
4615 4615 } else {
4616 4616 PyErr_Clear();
4617 4617 }
4618 4618 }
4619 4619 SocExplorerPlot::paintEvent(arg__1);
4620 4620 }
4621 4621 QPaintDevice* PythonQtShell_SocExplorerPlot::redirected(QPoint* offset0) const
4622 4622 {
4623 4623 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4624 4624 static PyObject* name = PyString_FromString("redirected");
4625 4625 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4626 4626 if (obj) {
4627 4627 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
4628 4628 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4629 4629 QPaintDevice* returnValue;
4630 4630 void* args[2] = {NULL, (void*)&offset0};
4631 4631 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4632 4632 if (result) {
4633 4633 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4634 4634 if (args[0]!=&returnValue) {
4635 4635 if (args[0]==NULL) {
4636 4636 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
4637 4637 } else {
4638 4638 returnValue = *((QPaintDevice**)args[0]);
4639 4639 }
4640 4640 }
4641 4641 }
4642 4642 if (result) { Py_DECREF(result); }
4643 4643 Py_DECREF(obj);
4644 4644 return returnValue;
4645 4645 } else {
4646 4646 PyErr_Clear();
4647 4647 }
4648 4648 }
4649 4649 return SocExplorerPlot::redirected(offset0);
4650 4650 }
4651 4651 void PythonQtShell_SocExplorerPlot::resizeEvent(QResizeEvent* arg__1)
4652 4652 {
4653 4653 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4654 4654 static PyObject* name = PyString_FromString("resizeEvent");
4655 4655 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4656 4656 if (obj) {
4657 4657 static const char* argumentList[] ={"" , "QResizeEvent*"};
4658 4658 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4659 4659 void* args[2] = {NULL, (void*)&arg__1};
4660 4660 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4661 4661 if (result) { Py_DECREF(result); }
4662 4662 Py_DECREF(obj);
4663 4663 return;
4664 4664 } else {
4665 4665 PyErr_Clear();
4666 4666 }
4667 4667 }
4668 4668 SocExplorerPlot::resizeEvent(arg__1);
4669 4669 }
4670 4670 QPainter* PythonQtShell_SocExplorerPlot::sharedPainter() const
4671 4671 {
4672 4672 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4673 4673 static PyObject* name = PyString_FromString("sharedPainter");
4674 4674 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4675 4675 if (obj) {
4676 4676 static const char* argumentList[] ={"QPainter*"};
4677 4677 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4678 4678 QPainter* returnValue;
4679 4679 void* args[1] = {NULL};
4680 4680 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4681 4681 if (result) {
4682 4682 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4683 4683 if (args[0]!=&returnValue) {
4684 4684 if (args[0]==NULL) {
4685 4685 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
4686 4686 } else {
4687 4687 returnValue = *((QPainter**)args[0]);
4688 4688 }
4689 4689 }
4690 4690 }
4691 4691 if (result) { Py_DECREF(result); }
4692 4692 Py_DECREF(obj);
4693 4693 return returnValue;
4694 4694 } else {
4695 4695 PyErr_Clear();
4696 4696 }
4697 4697 }
4698 4698 return SocExplorerPlot::sharedPainter();
4699 4699 }
4700 4700 void PythonQtShell_SocExplorerPlot::showEvent(QShowEvent* arg__1)
4701 4701 {
4702 4702 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4703 4703 static PyObject* name = PyString_FromString("showEvent");
4704 4704 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4705 4705 if (obj) {
4706 4706 static const char* argumentList[] ={"" , "QShowEvent*"};
4707 4707 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4708 4708 void* args[2] = {NULL, (void*)&arg__1};
4709 4709 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4710 4710 if (result) { Py_DECREF(result); }
4711 4711 Py_DECREF(obj);
4712 4712 return;
4713 4713 } else {
4714 4714 PyErr_Clear();
4715 4715 }
4716 4716 }
4717 4717 SocExplorerPlot::showEvent(arg__1);
4718 4718 }
4719 4719 QSize PythonQtShell_SocExplorerPlot::sizeHint() const
4720 4720 {
4721 4721 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4722 4722 static PyObject* name = PyString_FromString("getSizeHint");
4723 4723 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4724 4724 if (obj) {
4725 4725 static const char* argumentList[] ={"QSize"};
4726 4726 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4727 4727 QSize returnValue;
4728 4728 void* args[1] = {NULL};
4729 4729 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4730 4730 if (result) {
4731 4731 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4732 4732 if (args[0]!=&returnValue) {
4733 4733 if (args[0]==NULL) {
4734 4734 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
4735 4735 } else {
4736 4736 returnValue = *((QSize*)args[0]);
4737 4737 }
4738 4738 }
4739 4739 }
4740 4740 if (result) { Py_DECREF(result); }
4741 4741 Py_DECREF(obj);
4742 4742 return returnValue;
4743 4743 } else {
4744 4744 PyErr_Clear();
4745 4745 }
4746 4746 }
4747 4747 return SocExplorerPlot::sizeHint();
4748 4748 }
4749 4749 void PythonQtShell_SocExplorerPlot::tabletEvent(QTabletEvent* arg__1)
4750 4750 {
4751 4751 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4752 4752 static PyObject* name = PyString_FromString("tabletEvent");
4753 4753 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4754 4754 if (obj) {
4755 4755 static const char* argumentList[] ={"" , "QTabletEvent*"};
4756 4756 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4757 4757 void* args[2] = {NULL, (void*)&arg__1};
4758 4758 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4759 4759 if (result) { Py_DECREF(result); }
4760 4760 Py_DECREF(obj);
4761 4761 return;
4762 4762 } else {
4763 4763 PyErr_Clear();
4764 4764 }
4765 4765 }
4766 4766 SocExplorerPlot::tabletEvent(arg__1);
4767 4767 }
4768 4768 void PythonQtShell_SocExplorerPlot::timerEvent(QTimerEvent* arg__1)
4769 4769 {
4770 4770 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4771 4771 static PyObject* name = PyString_FromString("timerEvent");
4772 4772 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4773 4773 if (obj) {
4774 4774 static const char* argumentList[] ={"" , "QTimerEvent*"};
4775 4775 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4776 4776 void* args[2] = {NULL, (void*)&arg__1};
4777 4777 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4778 4778 if (result) { Py_DECREF(result); }
4779 4779 Py_DECREF(obj);
4780 4780 return;
4781 4781 } else {
4782 4782 PyErr_Clear();
4783 4783 }
4784 4784 }
4785 4785 SocExplorerPlot::timerEvent(arg__1);
4786 4786 }
4787 4787 void PythonQtShell_SocExplorerPlot::wheelEvent(QWheelEvent* arg__1)
4788 4788 {
4789 4789 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4790 4790 static PyObject* name = PyString_FromString("wheelEvent");
4791 4791 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4792 4792 if (obj) {
4793 4793 static const char* argumentList[] ={"" , "QWheelEvent*"};
4794 4794 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4795 4795 void* args[2] = {NULL, (void*)&arg__1};
4796 4796 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4797 4797 if (result) { Py_DECREF(result); }
4798 4798 Py_DECREF(obj);
4799 4799 return;
4800 4800 } else {
4801 4801 PyErr_Clear();
4802 4802 }
4803 4803 }
4804 4804 SocExplorerPlot::wheelEvent(arg__1);
4805 4805 }
4806 4806 SocExplorerPlot* PythonQtWrapper_SocExplorerPlot::new_SocExplorerPlot(QWidget* parent)
4807 4807 {
4808 4808 return new PythonQtShell_SocExplorerPlot(parent); }
4809 4809
4810 4810 int PythonQtWrapper_SocExplorerPlot::addGraph(SocExplorerPlot* theWrappedObject)
4811 4811 {
4812 4812 return ( theWrappedObject->addGraph());
4813 4813 }
4814 4814
4815 4815 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4816 4816 {
4817 4817 ( theWrappedObject->addGraphData(graphIndex, x, y));
4818 4818 }
4819 4819
4820 4820 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y)
4821 4821 {
4822 4822 ( theWrappedObject->addGraphData(graphIndex, x, y));
4823 4823 }
4824 4824
4825 4825 QPen PythonQtWrapper_SocExplorerPlot::getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex)
4826 4826 {
4827 4827 return ( theWrappedObject->getGraphPen(graphIndex));
4828 4828 }
4829 4829
4830 4830 void PythonQtWrapper_SocExplorerPlot::keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4831 4831 {
4832 4832 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyPressEvent(arg__1));
4833 4833 }
4834 4834
4835 4835 void PythonQtWrapper_SocExplorerPlot::keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4836 4836 {
4837 4837 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyReleaseEvent(arg__1));
4838 4838 }
4839 4839
4840 4840 void PythonQtWrapper_SocExplorerPlot::mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4841 4841 {
4842 4842 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseMoveEvent(arg__1));
4843 4843 }
4844 4844
4845 4845 void PythonQtWrapper_SocExplorerPlot::mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4846 4846 {
4847 4847 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mousePressEvent(arg__1));
4848 4848 }
4849 4849
4850 4850 void PythonQtWrapper_SocExplorerPlot::mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4851 4851 {
4852 4852 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseReleaseEvent(arg__1));
4853 4853 }
4854 4854
4855 void PythonQtWrapper_SocExplorerPlot::removeAllGraphs(SocExplorerPlot* theWrappedObject)
4856 {
4857 ( theWrappedObject->removeAllGraphs());
4858 }
4859
4860 bool PythonQtWrapper_SocExplorerPlot::removeGraph(SocExplorerPlot* theWrappedObject, int graphIndex)
4861 {
4862 return ( theWrappedObject->removeGraph(graphIndex));
4863 }
4864
4865 void PythonQtWrapper_SocExplorerPlot::replot(SocExplorerPlot* theWrappedObject)
4866 {
4867 ( theWrappedObject->replot());
4868 }
4869
4855 4870 void PythonQtWrapper_SocExplorerPlot::rescaleAxis(SocExplorerPlot* theWrappedObject)
4856 4871 {
4857 4872 ( theWrappedObject->rescaleAxis());
4858 4873 }
4859 4874
4860 4875 void PythonQtWrapper_SocExplorerPlot::setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable)
4861 4876 {
4862 4877 ( theWrappedObject->setAdaptativeSampling(graphIndex, enable));
4863 4878 }
4864 4879
4865 4880 void PythonQtWrapper_SocExplorerPlot::setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4866 4881 {
4867 4882 ( theWrappedObject->setGraphData(graphIndex, x, y));
4868 4883 }
4869 4884
4870 4885 void PythonQtWrapper_SocExplorerPlot::setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle)
4871 4886 {
4872 4887 ( theWrappedObject->setGraphLineStyle(graphIndex, lineStyle));
4873 4888 }
4874 4889
4875 4890 void PythonQtWrapper_SocExplorerPlot::setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name)
4876 4891 {
4877 4892 ( theWrappedObject->setGraphName(graphIndex, name));
4878 4893 }
4879 4894
4880 4895 void PythonQtWrapper_SocExplorerPlot::setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen)
4881 4896 {
4882 4897 ( theWrappedObject->setGraphPen(graphIndex, pen));
4883 4898 }
4884 4899
4885 4900 void PythonQtWrapper_SocExplorerPlot::setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle)
4886 4901 {
4887 4902 ( theWrappedObject->setGraphScatterStyle(graphIndex, scatterStyle));
4888 4903 }
4889 4904
4890 4905 void PythonQtWrapper_SocExplorerPlot::setLegendFont(SocExplorerPlot* theWrappedObject, QFont font)
4891 4906 {
4892 4907 ( theWrappedObject->setLegendFont(font));
4893 4908 }
4894 4909
4895 4910 void PythonQtWrapper_SocExplorerPlot::setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font)
4896 4911 {
4897 4912 ( theWrappedObject->setLegendSelectedFont(font));
4898 4913 }
4899 4914
4900 4915 void PythonQtWrapper_SocExplorerPlot::setTitle(SocExplorerPlot* theWrappedObject, QString title)
4901 4916 {
4902 4917 ( theWrappedObject->setTitle(title));
4903 4918 }
4904 4919
4920 void PythonQtWrapper_SocExplorerPlot::setXaxisDateTimeFormat(SocExplorerPlot* theWrappedObject, const QString& format)
4921 {
4922 ( theWrappedObject->setXaxisDateTimeFormat(format));
4923 }
4924
4905 4925 void PythonQtWrapper_SocExplorerPlot::setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4906 4926 {
4907 4927 ( theWrappedObject->setXaxisLabel(label));
4908 4928 }
4909 4929
4910 4930 void PythonQtWrapper_SocExplorerPlot::setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4911 4931 {
4912 4932 ( theWrappedObject->setXaxisRange(lower, upper));
4913 4933 }
4914 4934
4915 4935 void PythonQtWrapper_SocExplorerPlot::setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4916 4936 {
4917 4937 ( theWrappedObject->setYaxisLabel(label));
4918 4938 }
4919 4939
4920 4940 void PythonQtWrapper_SocExplorerPlot::setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4921 4941 {
4922 4942 ( theWrappedObject->setYaxisRange(lower, upper));
4923 4943 }
4924 4944
4925 4945 void PythonQtWrapper_SocExplorerPlot::show(SocExplorerPlot* theWrappedObject)
4926 4946 {
4927 4947 ( theWrappedObject->show());
4928 4948 }
4929 4949
4930 4950 void PythonQtWrapper_SocExplorerPlot::wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1)
4931 4951 {
4932 4952 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_wheelEvent(arg__1));
4933 4953 }
4934 4954
4935 4955
4936 4956
4937 4957 PythonQtShell_TCP_Terminal_Client::~PythonQtShell_TCP_Terminal_Client() {
4938 4958 PythonQtPrivate* priv = PythonQt::priv();
4939 4959 if (priv) { priv->shellClassDeleted(this); }
4940 4960 }
4941 4961 void PythonQtShell_TCP_Terminal_Client::childEvent(QChildEvent* arg__1)
4942 4962 {
4943 4963 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4944 4964 static PyObject* name = PyString_FromString("childEvent");
4945 4965 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4946 4966 if (obj) {
4947 4967 static const char* argumentList[] ={"" , "QChildEvent*"};
4948 4968 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4949 4969 void* args[2] = {NULL, (void*)&arg__1};
4950 4970 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4951 4971 if (result) { Py_DECREF(result); }
4952 4972 Py_DECREF(obj);
4953 4973 return;
4954 4974 } else {
4955 4975 PyErr_Clear();
4956 4976 }
4957 4977 }
4958 4978 TCP_Terminal_Client::childEvent(arg__1);
4959 4979 }
4960 4980 void PythonQtShell_TCP_Terminal_Client::customEvent(QEvent* arg__1)
4961 4981 {
4962 4982 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4963 4983 static PyObject* name = PyString_FromString("customEvent");
4964 4984 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4965 4985 if (obj) {
4966 4986 static const char* argumentList[] ={"" , "QEvent*"};
4967 4987 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4968 4988 void* args[2] = {NULL, (void*)&arg__1};
4969 4989 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4970 4990 if (result) { Py_DECREF(result); }
4971 4991 Py_DECREF(obj);
4972 4992 return;
4973 4993 } else {
4974 4994 PyErr_Clear();
4975 4995 }
4976 4996 }
4977 4997 TCP_Terminal_Client::customEvent(arg__1);
4978 4998 }
4979 4999 bool PythonQtShell_TCP_Terminal_Client::event(QEvent* arg__1)
4980 5000 {
4981 5001 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4982 5002 static PyObject* name = PyString_FromString("event");
4983 5003 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4984 5004 if (obj) {
4985 5005 static const char* argumentList[] ={"bool" , "QEvent*"};
4986 5006 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4987 5007 bool returnValue;
4988 5008 void* args[2] = {NULL, (void*)&arg__1};
4989 5009 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4990 5010 if (result) {
4991 5011 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4992 5012 if (args[0]!=&returnValue) {
4993 5013 if (args[0]==NULL) {
4994 5014 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
4995 5015 } else {
4996 5016 returnValue = *((bool*)args[0]);
4997 5017 }
4998 5018 }
4999 5019 }
5000 5020 if (result) { Py_DECREF(result); }
5001 5021 Py_DECREF(obj);
5002 5022 return returnValue;
5003 5023 } else {
5004 5024 PyErr_Clear();
5005 5025 }
5006 5026 }
5007 5027 return TCP_Terminal_Client::event(arg__1);
5008 5028 }
5009 5029 bool PythonQtShell_TCP_Terminal_Client::eventFilter(QObject* arg__1, QEvent* arg__2)
5010 5030 {
5011 5031 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5012 5032 static PyObject* name = PyString_FromString("eventFilter");
5013 5033 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5014 5034 if (obj) {
5015 5035 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5016 5036 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5017 5037 bool returnValue;
5018 5038 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
5019 5039 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5020 5040 if (result) {
5021 5041 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5022 5042 if (args[0]!=&returnValue) {
5023 5043 if (args[0]==NULL) {
5024 5044 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
5025 5045 } else {
5026 5046 returnValue = *((bool*)args[0]);
5027 5047 }
5028 5048 }
5029 5049 }
5030 5050 if (result) { Py_DECREF(result); }
5031 5051 Py_DECREF(obj);
5032 5052 return returnValue;
5033 5053 } else {
5034 5054 PyErr_Clear();
5035 5055 }
5036 5056 }
5037 5057 return TCP_Terminal_Client::eventFilter(arg__1, arg__2);
5038 5058 }
5039 5059 void PythonQtShell_TCP_Terminal_Client::timerEvent(QTimerEvent* arg__1)
5040 5060 {
5041 5061 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5042 5062 static PyObject* name = PyString_FromString("timerEvent");
5043 5063 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5044 5064 if (obj) {
5045 5065 static const char* argumentList[] ={"" , "QTimerEvent*"};
5046 5066 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5047 5067 void* args[2] = {NULL, (void*)&arg__1};
5048 5068 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5049 5069 if (result) { Py_DECREF(result); }
5050 5070 Py_DECREF(obj);
5051 5071 return;
5052 5072 } else {
5053 5073 PyErr_Clear();
5054 5074 }
5055 5075 }
5056 5076 TCP_Terminal_Client::timerEvent(arg__1);
5057 5077 }
5058 5078 TCP_Terminal_Client* PythonQtWrapper_TCP_Terminal_Client::new_TCP_Terminal_Client(QObject* parent)
5059 5079 {
5060 5080 return new PythonQtShell_TCP_Terminal_Client(parent); }
5061 5081
5062 5082 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject)
5063 5083 {
5064 5084 ( theWrappedObject->connectToServer());
5065 5085 }
5066 5086
5067 5087 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port)
5068 5088 {
5069 5089 ( theWrappedObject->connectToServer(IP, port));
5070 5090 }
5071 5091
5072 5092 bool PythonQtWrapper_TCP_Terminal_Client::isConnected(TCP_Terminal_Client* theWrappedObject)
5073 5093 {
5074 5094 return ( theWrappedObject->isConnected());
5075 5095 }
5076 5096
5077 5097 void PythonQtWrapper_TCP_Terminal_Client::sendText(TCP_Terminal_Client* theWrappedObject, const QString& text)
5078 5098 {
5079 5099 ( theWrappedObject->sendText(text));
5080 5100 }
5081 5101
5082 5102 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject)
5083 5103 {
5084 5104 ( theWrappedObject->startServer());
5085 5105 }
5086 5106
5087 5107 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject, int port)
5088 5108 {
5089 5109 ( theWrappedObject->startServer(port));
5090 5110 }
5091 5111
5092 5112
5093 5113
5094 5114 XByteArray* PythonQtWrapper_XByteArray::new_XByteArray()
5095 5115 {
5096 5116 return new XByteArray(); }
5097 5117
5098 5118 int PythonQtWrapper_XByteArray::addressOffset(XByteArray* theWrappedObject)
5099 5119 {
5100 5120 return ( theWrappedObject->addressOffset());
5101 5121 }
5102 5122
5103 5123 int PythonQtWrapper_XByteArray::addressWidth(XByteArray* theWrappedObject)
5104 5124 {
5105 5125 return ( theWrappedObject->addressWidth());
5106 5126 }
5107 5127
5108 5128 QChar PythonQtWrapper_XByteArray::asciiChar(XByteArray* theWrappedObject, int index)
5109 5129 {
5110 5130 return ( theWrappedObject->asciiChar(index));
5111 5131 }
5112 5132
5113 5133 QByteArray* PythonQtWrapper_XByteArray::data(XByteArray* theWrappedObject)
5114 5134 {
5115 5135 return &( theWrappedObject->data());
5116 5136 }
5117 5137
5118 5138 bool PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i)
5119 5139 {
5120 5140 return ( theWrappedObject->dataChanged(i));
5121 5141 }
5122 5142
5123 5143 QByteArray PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i, int len)
5124 5144 {
5125 5145 return ( theWrappedObject->dataChanged(i, len));
5126 5146 }
5127 5147
5128 5148 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, char ch)
5129 5149 {
5130 5150 return &( theWrappedObject->insert(i, ch));
5131 5151 }
5132 5152
5133 5153 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, const QByteArray& ba)
5134 5154 {
5135 5155 return &( theWrappedObject->insert(i, ba));
5136 5156 }
5137 5157
5138 5158 int PythonQtWrapper_XByteArray::realAddressNumbers(XByteArray* theWrappedObject)
5139 5159 {
5140 5160 return ( theWrappedObject->realAddressNumbers());
5141 5161 }
5142 5162
5143 5163 QByteArray* PythonQtWrapper_XByteArray::remove(XByteArray* theWrappedObject, int pos, int len)
5144 5164 {
5145 5165 return &( theWrappedObject->remove(pos, len));
5146 5166 }
5147 5167
5148 5168 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, char ch)
5149 5169 {
5150 5170 return &( theWrappedObject->replace(index, ch));
5151 5171 }
5152 5172
5153 5173 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, const QByteArray& ba)
5154 5174 {
5155 5175 return &( theWrappedObject->replace(index, ba));
5156 5176 }
5157 5177
5158 5178 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba)
5159 5179 {
5160 5180 return &( theWrappedObject->replace(index, length, ba));
5161 5181 }
5162 5182
5163 5183 void PythonQtWrapper_XByteArray::setAddressOffset(XByteArray* theWrappedObject, int offset)
5164 5184 {
5165 5185 ( theWrappedObject->setAddressOffset(offset));
5166 5186 }
5167 5187
5168 5188 void PythonQtWrapper_XByteArray::setAddressWidth(XByteArray* theWrappedObject, int width)
5169 5189 {
5170 5190 ( theWrappedObject->setAddressWidth(width));
5171 5191 }
5172 5192
5173 5193 void PythonQtWrapper_XByteArray::setData(XByteArray* theWrappedObject, QByteArray data)
5174 5194 {
5175 5195 ( theWrappedObject->setData(data));
5176 5196 }
5177 5197
5178 5198 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, bool state)
5179 5199 {
5180 5200 ( theWrappedObject->setDataChanged(i, state));
5181 5201 }
5182 5202
5183 5203 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state)
5184 5204 {
5185 5205 ( theWrappedObject->setDataChanged(i, state));
5186 5206 }
5187 5207
5188 5208 int PythonQtWrapper_XByteArray::size(XByteArray* theWrappedObject)
5189 5209 {
5190 5210 return ( theWrappedObject->size());
5191 5211 }
5192 5212
5193 5213 QString PythonQtWrapper_XByteArray::toRedableString(XByteArray* theWrappedObject, int start, int end)
5194 5214 {
5195 5215 return ( theWrappedObject->toRedableString(start, end));
5196 5216 }
5197 5217
5198 5218
5199 5219
5200 5220 PythonQtShell_abstractBinFile::~PythonQtShell_abstractBinFile() {
5201 5221 PythonQtPrivate* priv = PythonQt::priv();
5202 5222 if (priv) { priv->shellClassDeleted(this); }
5203 5223 }
5204 5224 void PythonQtShell_abstractBinFile::childEvent(QChildEvent* arg__1)
5205 5225 {
5206 5226 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5207 5227 static PyObject* name = PyString_FromString("childEvent");
5208 5228 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5209 5229 if (obj) {
5210 5230 static const char* argumentList[] ={"" , "QChildEvent*"};
5211 5231 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5212 5232 void* args[2] = {NULL, (void*)&arg__1};
5213 5233 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5214 5234 if (result) { Py_DECREF(result); }
5215 5235 Py_DECREF(obj);
5216 5236 return;
5217 5237 } else {
5218 5238 PyErr_Clear();
5219 5239 }
5220 5240 }
5221 5241 abstractBinFile::childEvent(arg__1);
5222 5242 }
5223 5243 int PythonQtShell_abstractBinFile::closeFile()
5224 5244 {
5225 5245 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5226 5246 static PyObject* name = PyString_FromString("closeFile");
5227 5247 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5228 5248 if (obj) {
5229 5249 static const char* argumentList[] ={"int"};
5230 5250 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5231 5251 int returnValue;
5232 5252 void* args[1] = {NULL};
5233 5253 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5234 5254 if (result) {
5235 5255 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5236 5256 if (args[0]!=&returnValue) {
5237 5257 if (args[0]==NULL) {
5238 5258 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
5239 5259 } else {
5240 5260 returnValue = *((int*)args[0]);
5241 5261 }
5242 5262 }
5243 5263 }
5244 5264 if (result) { Py_DECREF(result); }
5245 5265 Py_DECREF(obj);
5246 5266 return returnValue;
5247 5267 } else {
5248 5268 PyErr_Clear();
5249 5269 }
5250 5270 }
5251 5271 return int();
5252 5272 }
5253 5273 void PythonQtShell_abstractBinFile::customEvent(QEvent* arg__1)
5254 5274 {
5255 5275 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5256 5276 static PyObject* name = PyString_FromString("customEvent");
5257 5277 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5258 5278 if (obj) {
5259 5279 static const char* argumentList[] ={"" , "QEvent*"};
5260 5280 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5261 5281 void* args[2] = {NULL, (void*)&arg__1};
5262 5282 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5263 5283 if (result) { Py_DECREF(result); }
5264 5284 Py_DECREF(obj);
5265 5285 return;
5266 5286 } else {
5267 5287 PyErr_Clear();
5268 5288 }
5269 5289 }
5270 5290 abstractBinFile::customEvent(arg__1);
5271 5291 }
5272 5292 bool PythonQtShell_abstractBinFile::event(QEvent* arg__1)
5273 5293 {
5274 5294 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5275 5295 static PyObject* name = PyString_FromString("event");
5276 5296 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5277 5297 if (obj) {
5278 5298 static const char* argumentList[] ={"bool" , "QEvent*"};
5279 5299 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5280 5300 bool returnValue;
5281 5301 void* args[2] = {NULL, (void*)&arg__1};
5282 5302 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5283 5303 if (result) {
5284 5304 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5285 5305 if (args[0]!=&returnValue) {
5286 5306 if (args[0]==NULL) {
5287 5307 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
5288 5308 } else {
5289 5309 returnValue = *((bool*)args[0]);
5290 5310 }
5291 5311 }
5292 5312 }
5293 5313 if (result) { Py_DECREF(result); }
5294 5314 Py_DECREF(obj);
5295 5315 return returnValue;
5296 5316 } else {
5297 5317 PyErr_Clear();
5298 5318 }
5299 5319 }
5300 5320 return abstractBinFile::event(arg__1);
5301 5321 }
5302 5322 bool PythonQtShell_abstractBinFile::eventFilter(QObject* arg__1, QEvent* arg__2)
5303 5323 {
5304 5324 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5305 5325 static PyObject* name = PyString_FromString("eventFilter");
5306 5326 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5307 5327 if (obj) {
5308 5328 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5309 5329 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5310 5330 bool returnValue;
5311 5331 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
5312 5332 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5313 5333 if (result) {
5314 5334 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5315 5335 if (args[0]!=&returnValue) {
5316 5336 if (args[0]==NULL) {
5317 5337 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
5318 5338 } else {
5319 5339 returnValue = *((bool*)args[0]);
5320 5340 }
5321 5341 }
5322 5342 }
5323 5343 if (result) { Py_DECREF(result); }
5324 5344 Py_DECREF(obj);
5325 5345 return returnValue;
5326 5346 } else {
5327 5347 PyErr_Clear();
5328 5348 }
5329 5349 }
5330 5350 return abstractBinFile::eventFilter(arg__1, arg__2);
5331 5351 }
5332 5352 QList<codeFragment* > PythonQtShell_abstractBinFile::getFragments()
5333 5353 {
5334 5354 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5335 5355 static PyObject* name = PyString_FromString("getFragments");
5336 5356 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5337 5357 if (obj) {
5338 5358 static const char* argumentList[] ={"QList<codeFragment* >"};
5339 5359 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5340 5360 QList<codeFragment* > returnValue;
5341 5361 void* args[1] = {NULL};
5342 5362 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5343 5363 if (result) {
5344 5364 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5345 5365 if (args[0]!=&returnValue) {
5346 5366 if (args[0]==NULL) {
5347 5367 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
5348 5368 } else {
5349 5369 returnValue = *((QList<codeFragment* >*)args[0]);
5350 5370 }
5351 5371 }
5352 5372 }
5353 5373 if (result) { Py_DECREF(result); }
5354 5374 Py_DECREF(obj);
5355 5375 return returnValue;
5356 5376 } else {
5357 5377 PyErr_Clear();
5358 5378 }
5359 5379 }
5360 5380 return QList<codeFragment* >();
5361 5381 }
5362 5382 bool PythonQtShell_abstractBinFile::isopened()
5363 5383 {
5364 5384 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5365 5385 static PyObject* name = PyString_FromString("isopened");
5366 5386 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5367 5387 if (obj) {
5368 5388 static const char* argumentList[] ={"bool"};
5369 5389 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5370 5390 bool returnValue;
5371 5391 void* args[1] = {NULL};
5372 5392 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5373 5393 if (result) {
5374 5394 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5375 5395 if (args[0]!=&returnValue) {
5376 5396 if (args[0]==NULL) {
5377 5397 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
5378 5398 } else {
5379 5399 returnValue = *((bool*)args[0]);
5380 5400 }
5381 5401 }
5382 5402 }
5383 5403 if (result) { Py_DECREF(result); }
5384 5404 Py_DECREF(obj);
5385 5405 return returnValue;
5386 5406 } else {
5387 5407 PyErr_Clear();
5388 5408 }
5389 5409 }
5390 5410 return bool();
5391 5411 }
5392 5412 bool PythonQtShell_abstractBinFile::openFile(const QString& File0)
5393 5413 {
5394 5414 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5395 5415 static PyObject* name = PyString_FromString("openFile");
5396 5416 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5397 5417 if (obj) {
5398 5418 static const char* argumentList[] ={"bool" , "const QString&"};
5399 5419 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5400 5420 bool returnValue;
5401 5421 void* args[2] = {NULL, (void*)&File0};
5402 5422 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5403 5423 if (result) {
5404 5424 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5405 5425 if (args[0]!=&returnValue) {
5406 5426 if (args[0]==NULL) {
5407 5427 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
5408 5428 } else {
5409 5429 returnValue = *((bool*)args[0]);
5410 5430 }
5411 5431 }
5412 5432 }
5413 5433 if (result) { Py_DECREF(result); }
5414 5434 Py_DECREF(obj);
5415 5435 return returnValue;
5416 5436 } else {
5417 5437 PyErr_Clear();
5418 5438 }
5419 5439 }
5420 5440 return bool();
5421 5441 }
5422 5442 void PythonQtShell_abstractBinFile::timerEvent(QTimerEvent* arg__1)
5423 5443 {
5424 5444 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5425 5445 static PyObject* name = PyString_FromString("timerEvent");
5426 5446 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5427 5447 if (obj) {
5428 5448 static const char* argumentList[] ={"" , "QTimerEvent*"};
5429 5449 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5430 5450 void* args[2] = {NULL, (void*)&arg__1};
5431 5451 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5432 5452 if (result) { Py_DECREF(result); }
5433 5453 Py_DECREF(obj);
5434 5454 return;
5435 5455 } else {
5436 5456 PyErr_Clear();
5437 5457 }
5438 5458 }
5439 5459 abstractBinFile::timerEvent(arg__1);
5440 5460 }
5441 5461 bool PythonQtShell_abstractBinFile::toBinary(const QString& File0)
5442 5462 {
5443 5463 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5444 5464 static PyObject* name = PyString_FromString("toBinary");
5445 5465 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5446 5466 if (obj) {
5447 5467 static const char* argumentList[] ={"bool" , "const QString&"};
5448 5468 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5449 5469 bool returnValue;
5450 5470 void* args[2] = {NULL, (void*)&File0};
5451 5471 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5452 5472 if (result) {
5453 5473 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5454 5474 if (args[0]!=&returnValue) {
5455 5475 if (args[0]==NULL) {
5456 5476 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
5457 5477 } else {
5458 5478 returnValue = *((bool*)args[0]);
5459 5479 }
5460 5480 }
5461 5481 }
5462 5482 if (result) { Py_DECREF(result); }
5463 5483 Py_DECREF(obj);
5464 5484 return returnValue;
5465 5485 } else {
5466 5486 PyErr_Clear();
5467 5487 }
5468 5488 }
5469 5489 return bool();
5470 5490 }
5471 5491 bool PythonQtShell_abstractBinFile::toSrec(const QString& File0)
5472 5492 {
5473 5493 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5474 5494 static PyObject* name = PyString_FromString("toSrec");
5475 5495 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5476 5496 if (obj) {
5477 5497 static const char* argumentList[] ={"bool" , "const QString&"};
5478 5498 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5479 5499 bool returnValue;
5480 5500 void* args[2] = {NULL, (void*)&File0};
5481 5501 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5482 5502 if (result) {
5483 5503 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5484 5504 if (args[0]!=&returnValue) {
5485 5505 if (args[0]==NULL) {
5486 5506 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
5487 5507 } else {
5488 5508 returnValue = *((bool*)args[0]);
5489 5509 }
5490 5510 }
5491 5511 }
5492 5512 if (result) { Py_DECREF(result); }
5493 5513 Py_DECREF(obj);
5494 5514 return returnValue;
5495 5515 } else {
5496 5516 PyErr_Clear();
5497 5517 }
5498 5518 }
5499 5519 return bool();
5500 5520 }
5501 5521 abstractBinFile* PythonQtWrapper_abstractBinFile::new_abstractBinFile()
5502 5522 {
5503 5523 return new PythonQtShell_abstractBinFile(); }
5504 5524
5505 5525 int PythonQtWrapper_abstractBinFile::closeFile(abstractBinFile* theWrappedObject)
5506 5526 {
5507 5527 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_closeFile());
5508 5528 }
5509 5529
5510 5530 QList<codeFragment* > PythonQtWrapper_abstractBinFile::getFragments(abstractBinFile* theWrappedObject)
5511 5531 {
5512 5532 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_getFragments());
5513 5533 }
5514 5534
5515 5535 bool PythonQtWrapper_abstractBinFile::isopened(abstractBinFile* theWrappedObject)
5516 5536 {
5517 5537 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_isopened());
5518 5538 }
5519 5539
5520 5540 bool PythonQtWrapper_abstractBinFile::openFile(abstractBinFile* theWrappedObject, const QString& File)
5521 5541 {
5522 5542 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_openFile(File));
5523 5543 }
5524 5544
5525 5545 bool PythonQtWrapper_abstractBinFile::toBinary(abstractBinFile* theWrappedObject, const QString& File)
5526 5546 {
5527 5547 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_toBinary(File));
5528 5548 }
5529 5549
5530 5550 bool PythonQtWrapper_abstractBinFile::toSrec(abstractBinFile* theWrappedObject, const QString& File)
5531 5551 {
5532 5552 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_toSrec(File));
5533 5553 }
5534 5554
5535 5555
5536 5556
5537 5557 PythonQtShell_abstractBinFileWidget::~PythonQtShell_abstractBinFileWidget() {
5538 5558 PythonQtPrivate* priv = PythonQt::priv();
5539 5559 if (priv) { priv->shellClassDeleted(this); }
5540 5560 }
5541 5561 void PythonQtShell_abstractBinFileWidget::actionEvent(QActionEvent* arg__1)
5542 5562 {
5543 5563 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5544 5564 static PyObject* name = PyString_FromString("actionEvent");
5545 5565 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5546 5566 if (obj) {
5547 5567 static const char* argumentList[] ={"" , "QActionEvent*"};
5548 5568 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5549 5569 void* args[2] = {NULL, (void*)&arg__1};
5550 5570 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5551 5571 if (result) { Py_DECREF(result); }
5552 5572 Py_DECREF(obj);
5553 5573 return;
5554 5574 } else {
5555 5575 PyErr_Clear();
5556 5576 }
5557 5577 }
5558 5578 abstractBinFileWidget::actionEvent(arg__1);
5559 5579 }
5560 5580 void PythonQtShell_abstractBinFileWidget::changeEvent(QEvent* arg__1)
5561 5581 {
5562 5582 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5563 5583 static PyObject* name = PyString_FromString("changeEvent");
5564 5584 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5565 5585 if (obj) {
5566 5586 static const char* argumentList[] ={"" , "QEvent*"};
5567 5587 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5568 5588 void* args[2] = {NULL, (void*)&arg__1};
5569 5589 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5570 5590 if (result) { Py_DECREF(result); }
5571 5591 Py_DECREF(obj);
5572 5592 return;
5573 5593 } else {
5574 5594 PyErr_Clear();
5575 5595 }
5576 5596 }
5577 5597 abstractBinFileWidget::changeEvent(arg__1);
5578 5598 }
5579 5599 void PythonQtShell_abstractBinFileWidget::childEvent(QChildEvent* arg__1)
5580 5600 {
5581 5601 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5582 5602 static PyObject* name = PyString_FromString("childEvent");
5583 5603 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5584 5604 if (obj) {
5585 5605 static const char* argumentList[] ={"" , "QChildEvent*"};
5586 5606 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5587 5607 void* args[2] = {NULL, (void*)&arg__1};
5588 5608 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5589 5609 if (result) { Py_DECREF(result); }
5590 5610 Py_DECREF(obj);
5591 5611 return;
5592 5612 } else {
5593 5613 PyErr_Clear();
5594 5614 }
5595 5615 }
5596 5616 abstractBinFileWidget::childEvent(arg__1);
5597 5617 }
5598 5618 void PythonQtShell_abstractBinFileWidget::closeEvent(QCloseEvent* arg__1)
5599 5619 {
5600 5620 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5601 5621 static PyObject* name = PyString_FromString("closeEvent");
5602 5622 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5603 5623 if (obj) {
5604 5624 static const char* argumentList[] ={"" , "QCloseEvent*"};
5605 5625 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5606 5626 void* args[2] = {NULL, (void*)&arg__1};
5607 5627 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5608 5628 if (result) { Py_DECREF(result); }
5609 5629 Py_DECREF(obj);
5610 5630 return;
5611 5631 } else {
5612 5632 PyErr_Clear();
5613 5633 }
5614 5634 }
5615 5635 abstractBinFileWidget::closeEvent(arg__1);
5616 5636 }
5617 5637 void PythonQtShell_abstractBinFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
5618 5638 {
5619 5639 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5620 5640 static PyObject* name = PyString_FromString("contextMenuEvent");
5621 5641 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5622 5642 if (obj) {
5623 5643 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
5624 5644 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5625 5645 void* args[2] = {NULL, (void*)&arg__1};
5626 5646 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5627 5647 if (result) { Py_DECREF(result); }
5628 5648 Py_DECREF(obj);
5629 5649 return;
5630 5650 } else {
5631 5651 PyErr_Clear();
5632 5652 }
5633 5653 }
5634 5654 abstractBinFileWidget::contextMenuEvent(arg__1);
5635 5655 }
5636 5656 void PythonQtShell_abstractBinFileWidget::customEvent(QEvent* arg__1)
5637 5657 {
5638 5658 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5639 5659 static PyObject* name = PyString_FromString("customEvent");
5640 5660 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5641 5661 if (obj) {
5642 5662 static const char* argumentList[] ={"" , "QEvent*"};
5643 5663 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5644 5664 void* args[2] = {NULL, (void*)&arg__1};
5645 5665 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5646 5666 if (result) { Py_DECREF(result); }
5647 5667 Py_DECREF(obj);
5648 5668 return;
5649 5669 } else {
5650 5670 PyErr_Clear();
5651 5671 }
5652 5672 }
5653 5673 abstractBinFileWidget::customEvent(arg__1);
5654 5674 }
5655 5675 int PythonQtShell_abstractBinFileWidget::devType() const
5656 5676 {
5657 5677 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5658 5678 static PyObject* name = PyString_FromString("devType");
5659 5679 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5660 5680 if (obj) {
5661 5681 static const char* argumentList[] ={"int"};
5662 5682 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5663 5683 int returnValue;
5664 5684 void* args[1] = {NULL};
5665 5685 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5666 5686 if (result) {
5667 5687 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5668 5688 if (args[0]!=&returnValue) {
5669 5689 if (args[0]==NULL) {
5670 5690 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
5671 5691 } else {
5672 5692 returnValue = *((int*)args[0]);
5673 5693 }
5674 5694 }
5675 5695 }
5676 5696 if (result) { Py_DECREF(result); }
5677 5697 Py_DECREF(obj);
5678 5698 return returnValue;
5679 5699 } else {
5680 5700 PyErr_Clear();
5681 5701 }
5682 5702 }
5683 5703 return abstractBinFileWidget::devType();
5684 5704 }
5685 5705 void PythonQtShell_abstractBinFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
5686 5706 {
5687 5707 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5688 5708 static PyObject* name = PyString_FromString("dragEnterEvent");
5689 5709 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5690 5710 if (obj) {
5691 5711 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
5692 5712 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5693 5713 void* args[2] = {NULL, (void*)&arg__1};
5694 5714 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5695 5715 if (result) { Py_DECREF(result); }
5696 5716 Py_DECREF(obj);
5697 5717 return;
5698 5718 } else {
5699 5719 PyErr_Clear();
5700 5720 }
5701 5721 }
5702 5722 abstractBinFileWidget::dragEnterEvent(arg__1);
5703 5723 }
5704 5724 void PythonQtShell_abstractBinFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
5705 5725 {
5706 5726 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5707 5727 static PyObject* name = PyString_FromString("dragLeaveEvent");
5708 5728 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5709 5729 if (obj) {
5710 5730 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
5711 5731 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5712 5732 void* args[2] = {NULL, (void*)&arg__1};
5713 5733 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5714 5734 if (result) { Py_DECREF(result); }
5715 5735 Py_DECREF(obj);
5716 5736 return;
5717 5737 } else {
5718 5738 PyErr_Clear();
5719 5739 }
5720 5740 }
5721 5741 abstractBinFileWidget::dragLeaveEvent(arg__1);
5722 5742 }
5723 5743 void PythonQtShell_abstractBinFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
5724 5744 {
5725 5745 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5726 5746 static PyObject* name = PyString_FromString("dragMoveEvent");
5727 5747 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5728 5748 if (obj) {
5729 5749 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
5730 5750 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5731 5751 void* args[2] = {NULL, (void*)&arg__1};
5732 5752 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5733 5753 if (result) { Py_DECREF(result); }
5734 5754 Py_DECREF(obj);
5735 5755 return;
5736 5756 } else {
5737 5757 PyErr_Clear();
5738 5758 }
5739 5759 }
5740 5760 abstractBinFileWidget::dragMoveEvent(arg__1);
5741 5761 }
5742 5762 void PythonQtShell_abstractBinFileWidget::dropEvent(QDropEvent* arg__1)
5743 5763 {
5744 5764 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5745 5765 static PyObject* name = PyString_FromString("dropEvent");
5746 5766 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5747 5767 if (obj) {
5748 5768 static const char* argumentList[] ={"" , "QDropEvent*"};
5749 5769 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5750 5770 void* args[2] = {NULL, (void*)&arg__1};
5751 5771 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5752 5772 if (result) { Py_DECREF(result); }
5753 5773 Py_DECREF(obj);
5754 5774 return;
5755 5775 } else {
5756 5776 PyErr_Clear();
5757 5777 }
5758 5778 }
5759 5779 abstractBinFileWidget::dropEvent(arg__1);
5760 5780 }
5761 5781 void PythonQtShell_abstractBinFileWidget::enterEvent(QEvent* arg__1)
5762 5782 {
5763 5783 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5764 5784 static PyObject* name = PyString_FromString("enterEvent");
5765 5785 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5766 5786 if (obj) {
5767 5787 static const char* argumentList[] ={"" , "QEvent*"};
5768 5788 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5769 5789 void* args[2] = {NULL, (void*)&arg__1};
5770 5790 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5771 5791 if (result) { Py_DECREF(result); }
5772 5792 Py_DECREF(obj);
5773 5793 return;
5774 5794 } else {
5775 5795 PyErr_Clear();
5776 5796 }
5777 5797 }
5778 5798 abstractBinFileWidget::enterEvent(arg__1);
5779 5799 }
5780 5800 bool PythonQtShell_abstractBinFileWidget::event(QEvent* arg__1)
5781 5801 {
5782 5802 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5783 5803 static PyObject* name = PyString_FromString("event");
5784 5804 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5785 5805 if (obj) {
5786 5806 static const char* argumentList[] ={"bool" , "QEvent*"};
5787 5807 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5788 5808 bool returnValue;
5789 5809 void* args[2] = {NULL, (void*)&arg__1};
5790 5810 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5791 5811 if (result) {
5792 5812 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5793 5813 if (args[0]!=&returnValue) {
5794 5814 if (args[0]==NULL) {
5795 5815 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
5796 5816 } else {
5797 5817 returnValue = *((bool*)args[0]);
5798 5818 }
5799 5819 }
5800 5820 }
5801 5821 if (result) { Py_DECREF(result); }
5802 5822 Py_DECREF(obj);
5803 5823 return returnValue;
5804 5824 } else {
5805 5825 PyErr_Clear();
5806 5826 }
5807 5827 }
5808 5828 return abstractBinFileWidget::event(arg__1);
5809 5829 }
5810 5830 bool PythonQtShell_abstractBinFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
5811 5831 {
5812 5832 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5813 5833 static PyObject* name = PyString_FromString("eventFilter");
5814 5834 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5815 5835 if (obj) {
5816 5836 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5817 5837 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5818 5838 bool returnValue;
5819 5839 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
5820 5840 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5821 5841 if (result) {
5822 5842 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5823 5843 if (args[0]!=&returnValue) {
5824 5844 if (args[0]==NULL) {
5825 5845 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
5826 5846 } else {
5827 5847 returnValue = *((bool*)args[0]);
5828 5848 }
5829 5849 }
5830 5850 }
5831 5851 if (result) { Py_DECREF(result); }
5832 5852 Py_DECREF(obj);
5833 5853 return returnValue;
5834 5854 } else {
5835 5855 PyErr_Clear();
5836 5856 }
5837 5857 }
5838 5858 return abstractBinFileWidget::eventFilter(arg__1, arg__2);
5839 5859 }
5840 5860 void PythonQtShell_abstractBinFileWidget::focusInEvent(QFocusEvent* arg__1)
5841 5861 {
5842 5862 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5843 5863 static PyObject* name = PyString_FromString("focusInEvent");
5844 5864 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5845 5865 if (obj) {
5846 5866 static const char* argumentList[] ={"" , "QFocusEvent*"};
5847 5867 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5848 5868 void* args[2] = {NULL, (void*)&arg__1};
5849 5869 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5850 5870 if (result) { Py_DECREF(result); }
5851 5871 Py_DECREF(obj);
5852 5872 return;
5853 5873 } else {
5854 5874 PyErr_Clear();
5855 5875 }
5856 5876 }
5857 5877 abstractBinFileWidget::focusInEvent(arg__1);
5858 5878 }
5859 5879 bool PythonQtShell_abstractBinFileWidget::focusNextPrevChild(bool next0)
5860 5880 {
5861 5881 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5862 5882 static PyObject* name = PyString_FromString("focusNextPrevChild");
5863 5883 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5864 5884 if (obj) {
5865 5885 static const char* argumentList[] ={"bool" , "bool"};
5866 5886 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5867 5887 bool returnValue;
5868 5888 void* args[2] = {NULL, (void*)&next0};
5869 5889 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5870 5890 if (result) {
5871 5891 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5872 5892 if (args[0]!=&returnValue) {
5873 5893 if (args[0]==NULL) {
5874 5894 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
5875 5895 } else {
5876 5896 returnValue = *((bool*)args[0]);
5877 5897 }
5878 5898 }
5879 5899 }
5880 5900 if (result) { Py_DECREF(result); }
5881 5901 Py_DECREF(obj);
5882 5902 return returnValue;
5883 5903 } else {
5884 5904 PyErr_Clear();
5885 5905 }
5886 5906 }
5887 5907 return abstractBinFileWidget::focusNextPrevChild(next0);
5888 5908 }
5889 5909 void PythonQtShell_abstractBinFileWidget::focusOutEvent(QFocusEvent* arg__1)
5890 5910 {
5891 5911 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5892 5912 static PyObject* name = PyString_FromString("focusOutEvent");
5893 5913 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5894 5914 if (obj) {
5895 5915 static const char* argumentList[] ={"" , "QFocusEvent*"};
5896 5916 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5897 5917 void* args[2] = {NULL, (void*)&arg__1};
5898 5918 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5899 5919 if (result) { Py_DECREF(result); }
5900 5920 Py_DECREF(obj);
5901 5921 return;
5902 5922 } else {
5903 5923 PyErr_Clear();
5904 5924 }
5905 5925 }
5906 5926 abstractBinFileWidget::focusOutEvent(arg__1);
5907 5927 }
5908 5928 bool PythonQtShell_abstractBinFileWidget::hasHeightForWidth() const
5909 5929 {
5910 5930 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5911 5931 static PyObject* name = PyString_FromString("hasHeightForWidth");
5912 5932 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5913 5933 if (obj) {
5914 5934 static const char* argumentList[] ={"bool"};
5915 5935 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5916 5936 bool returnValue;
5917 5937 void* args[1] = {NULL};
5918 5938 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5919 5939 if (result) {
5920 5940 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5921 5941 if (args[0]!=&returnValue) {
5922 5942 if (args[0]==NULL) {
5923 5943 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
5924 5944 } else {
5925 5945 returnValue = *((bool*)args[0]);
5926 5946 }
5927 5947 }
5928 5948 }
5929 5949 if (result) { Py_DECREF(result); }
5930 5950 Py_DECREF(obj);
5931 5951 return returnValue;
5932 5952 } else {
5933 5953 PyErr_Clear();
5934 5954 }
5935 5955 }
5936 5956 return abstractBinFileWidget::hasHeightForWidth();
5937 5957 }
5938 5958 int PythonQtShell_abstractBinFileWidget::heightForWidth(int arg__1) const
5939 5959 {
5940 5960 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5941 5961 static PyObject* name = PyString_FromString("heightForWidth");
5942 5962 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5943 5963 if (obj) {
5944 5964 static const char* argumentList[] ={"int" , "int"};
5945 5965 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5946 5966 int returnValue;
5947 5967 void* args[2] = {NULL, (void*)&arg__1};
5948 5968 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5949 5969 if (result) {
5950 5970 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5951 5971 if (args[0]!=&returnValue) {
5952 5972 if (args[0]==NULL) {
5953 5973 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
5954 5974 } else {
5955 5975 returnValue = *((int*)args[0]);
5956 5976 }
5957 5977 }
5958 5978 }
5959 5979 if (result) { Py_DECREF(result); }
5960 5980 Py_DECREF(obj);
5961 5981 return returnValue;
5962 5982 } else {
5963 5983 PyErr_Clear();
5964 5984 }
5965 5985 }
5966 5986 return abstractBinFileWidget::heightForWidth(arg__1);
5967 5987 }
5968 5988 void PythonQtShell_abstractBinFileWidget::hideEvent(QHideEvent* arg__1)
5969 5989 {
5970 5990 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5971 5991 static PyObject* name = PyString_FromString("hideEvent");
5972 5992 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5973 5993 if (obj) {
5974 5994 static const char* argumentList[] ={"" , "QHideEvent*"};
5975 5995 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5976 5996 void* args[2] = {NULL, (void*)&arg__1};
5977 5997 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5978 5998 if (result) { Py_DECREF(result); }
5979 5999 Py_DECREF(obj);
5980 6000 return;
5981 6001 } else {
5982 6002 PyErr_Clear();
5983 6003 }
5984 6004 }
5985 6005 abstractBinFileWidget::hideEvent(arg__1);
5986 6006 }
5987 6007 void PythonQtShell_abstractBinFileWidget::initPainter(QPainter* painter0) const
5988 6008 {
5989 6009 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5990 6010 static PyObject* name = PyString_FromString("initPainter");
5991 6011 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5992 6012 if (obj) {
5993 6013 static const char* argumentList[] ={"" , "QPainter*"};
5994 6014 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5995 6015 void* args[2] = {NULL, (void*)&painter0};
5996 6016 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5997 6017 if (result) { Py_DECREF(result); }
5998 6018 Py_DECREF(obj);
5999 6019 return;
6000 6020 } else {
6001 6021 PyErr_Clear();
6002 6022 }
6003 6023 }
6004 6024 abstractBinFileWidget::initPainter(painter0);
6005 6025 }
6006 6026 void PythonQtShell_abstractBinFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
6007 6027 {
6008 6028 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6009 6029 static PyObject* name = PyString_FromString("inputMethodEvent");
6010 6030 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6011 6031 if (obj) {
6012 6032 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
6013 6033 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6014 6034 void* args[2] = {NULL, (void*)&arg__1};
6015 6035 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6016 6036 if (result) { Py_DECREF(result); }
6017 6037 Py_DECREF(obj);
6018 6038 return;
6019 6039 } else {
6020 6040 PyErr_Clear();
6021 6041 }
6022 6042 }
6023 6043 abstractBinFileWidget::inputMethodEvent(arg__1);
6024 6044 }
6025 6045 QVariant PythonQtShell_abstractBinFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
6026 6046 {
6027 6047 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6028 6048 static PyObject* name = PyString_FromString("inputMethodQuery");
6029 6049 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6030 6050 if (obj) {
6031 6051 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
6032 6052 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6033 6053 QVariant returnValue;
6034 6054 void* args[2] = {NULL, (void*)&arg__1};
6035 6055 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6036 6056 if (result) {
6037 6057 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6038 6058 if (args[0]!=&returnValue) {
6039 6059 if (args[0]==NULL) {
6040 6060 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
6041 6061 } else {
6042 6062 returnValue = *((QVariant*)args[0]);
6043 6063 }
6044 6064 }
6045 6065 }
6046 6066 if (result) { Py_DECREF(result); }
6047 6067 Py_DECREF(obj);
6048 6068 return returnValue;
6049 6069 } else {
6050 6070 PyErr_Clear();
6051 6071 }
6052 6072 }
6053 6073 return abstractBinFileWidget::inputMethodQuery(arg__1);
6054 6074 }
6055 6075 void PythonQtShell_abstractBinFileWidget::keyPressEvent(QKeyEvent* arg__1)
6056 6076 {
6057 6077 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6058 6078 static PyObject* name = PyString_FromString("keyPressEvent");
6059 6079 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6060 6080 if (obj) {
6061 6081 static const char* argumentList[] ={"" , "QKeyEvent*"};
6062 6082 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6063 6083 void* args[2] = {NULL, (void*)&arg__1};
6064 6084 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6065 6085 if (result) { Py_DECREF(result); }
6066 6086 Py_DECREF(obj);
6067 6087 return;
6068 6088 } else {
6069 6089 PyErr_Clear();
6070 6090 }
6071 6091 }
6072 6092 abstractBinFileWidget::keyPressEvent(arg__1);
6073 6093 }
6074 6094 void PythonQtShell_abstractBinFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
6075 6095 {
6076 6096 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6077 6097 static PyObject* name = PyString_FromString("keyReleaseEvent");
6078 6098 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6079 6099 if (obj) {
6080 6100 static const char* argumentList[] ={"" , "QKeyEvent*"};
6081 6101 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6082 6102 void* args[2] = {NULL, (void*)&arg__1};
6083 6103 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6084 6104 if (result) { Py_DECREF(result); }
6085 6105 Py_DECREF(obj);
6086 6106 return;
6087 6107 } else {
6088 6108 PyErr_Clear();
6089 6109 }
6090 6110 }
6091 6111 abstractBinFileWidget::keyReleaseEvent(arg__1);
6092 6112 }
6093 6113 void PythonQtShell_abstractBinFileWidget::leaveEvent(QEvent* arg__1)
6094 6114 {
6095 6115 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6096 6116 static PyObject* name = PyString_FromString("leaveEvent");
6097 6117 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6098 6118 if (obj) {
6099 6119 static const char* argumentList[] ={"" , "QEvent*"};
6100 6120 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6101 6121 void* args[2] = {NULL, (void*)&arg__1};
6102 6122 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6103 6123 if (result) { Py_DECREF(result); }
6104 6124 Py_DECREF(obj);
6105 6125 return;
6106 6126 } else {
6107 6127 PyErr_Clear();
6108 6128 }
6109 6129 }
6110 6130 abstractBinFileWidget::leaveEvent(arg__1);
6111 6131 }
6112 6132 int PythonQtShell_abstractBinFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
6113 6133 {
6114 6134 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6115 6135 static PyObject* name = PyString_FromString("metric");
6116 6136 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6117 6137 if (obj) {
6118 6138 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
6119 6139 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6120 6140 int returnValue;
6121 6141 void* args[2] = {NULL, (void*)&arg__1};
6122 6142 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6123 6143 if (result) {
6124 6144 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6125 6145 if (args[0]!=&returnValue) {
6126 6146 if (args[0]==NULL) {
6127 6147 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
6128 6148 } else {
6129 6149 returnValue = *((int*)args[0]);
6130 6150 }
6131 6151 }
6132 6152 }
6133 6153 if (result) { Py_DECREF(result); }
6134 6154 Py_DECREF(obj);
6135 6155 return returnValue;
6136 6156 } else {
6137 6157 PyErr_Clear();
6138 6158 }
6139 6159 }
6140 6160 return abstractBinFileWidget::metric(arg__1);
6141 6161 }
6142 6162 QSize PythonQtShell_abstractBinFileWidget::minimumSizeHint() const
6143 6163 {
6144 6164 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6145 6165 static PyObject* name = PyString_FromString("getMinimumSizeHint");
6146 6166 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6147 6167 if (obj) {
6148 6168 static const char* argumentList[] ={"QSize"};
6149 6169 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6150 6170 QSize returnValue;
6151 6171 void* args[1] = {NULL};
6152 6172 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6153 6173 if (result) {
6154 6174 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6155 6175 if (args[0]!=&returnValue) {
6156 6176 if (args[0]==NULL) {
6157 6177 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
6158 6178 } else {
6159 6179 returnValue = *((QSize*)args[0]);
6160 6180 }
6161 6181 }
6162 6182 }
6163 6183 if (result) { Py_DECREF(result); }
6164 6184 Py_DECREF(obj);
6165 6185 return returnValue;
6166 6186 } else {
6167 6187 PyErr_Clear();
6168 6188 }
6169 6189 }
6170 6190 return abstractBinFileWidget::minimumSizeHint();
6171 6191 }
6172 6192 void PythonQtShell_abstractBinFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
6173 6193 {
6174 6194 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6175 6195 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
6176 6196 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6177 6197 if (obj) {
6178 6198 static const char* argumentList[] ={"" , "QMouseEvent*"};
6179 6199 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6180 6200 void* args[2] = {NULL, (void*)&arg__1};
6181 6201 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6182 6202 if (result) { Py_DECREF(result); }
6183 6203 Py_DECREF(obj);
6184 6204 return;
6185 6205 } else {
6186 6206 PyErr_Clear();
6187 6207 }
6188 6208 }
6189 6209 abstractBinFileWidget::mouseDoubleClickEvent(arg__1);
6190 6210 }
6191 6211 void PythonQtShell_abstractBinFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
6192 6212 {
6193 6213 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6194 6214 static PyObject* name = PyString_FromString("mouseMoveEvent");
6195 6215 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6196 6216 if (obj) {
6197 6217 static const char* argumentList[] ={"" , "QMouseEvent*"};
6198 6218 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6199 6219 void* args[2] = {NULL, (void*)&arg__1};
6200 6220 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6201 6221 if (result) { Py_DECREF(result); }
6202 6222 Py_DECREF(obj);
6203 6223 return;
6204 6224 } else {
6205 6225 PyErr_Clear();
6206 6226 }
6207 6227 }
6208 6228 abstractBinFileWidget::mouseMoveEvent(arg__1);
6209 6229 }
6210 6230 void PythonQtShell_abstractBinFileWidget::mousePressEvent(QMouseEvent* arg__1)
6211 6231 {
6212 6232 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6213 6233 static PyObject* name = PyString_FromString("mousePressEvent");
6214 6234 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6215 6235 if (obj) {
6216 6236 static const char* argumentList[] ={"" , "QMouseEvent*"};
6217 6237 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6218 6238 void* args[2] = {NULL, (void*)&arg__1};
6219 6239 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6220 6240 if (result) { Py_DECREF(result); }
6221 6241 Py_DECREF(obj);
6222 6242 return;
6223 6243 } else {
6224 6244 PyErr_Clear();
6225 6245 }
6226 6246 }
6227 6247 abstractBinFileWidget::mousePressEvent(arg__1);
6228 6248 }
6229 6249 void PythonQtShell_abstractBinFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
6230 6250 {
6231 6251 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6232 6252 static PyObject* name = PyString_FromString("mouseReleaseEvent");
6233 6253 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6234 6254 if (obj) {
6235 6255 static const char* argumentList[] ={"" , "QMouseEvent*"};
6236 6256 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6237 6257 void* args[2] = {NULL, (void*)&arg__1};
6238 6258 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6239 6259 if (result) { Py_DECREF(result); }
6240 6260 Py_DECREF(obj);
6241 6261 return;
6242 6262 } else {
6243 6263 PyErr_Clear();
6244 6264 }
6245 6265 }
6246 6266 abstractBinFileWidget::mouseReleaseEvent(arg__1);
6247 6267 }
6248 6268 void PythonQtShell_abstractBinFileWidget::moveEvent(QMoveEvent* arg__1)
6249 6269 {
6250 6270 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6251 6271 static PyObject* name = PyString_FromString("moveEvent");
6252 6272 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6253 6273 if (obj) {
6254 6274 static const char* argumentList[] ={"" , "QMoveEvent*"};
6255 6275 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6256 6276 void* args[2] = {NULL, (void*)&arg__1};
6257 6277 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6258 6278 if (result) { Py_DECREF(result); }
6259 6279 Py_DECREF(obj);
6260 6280 return;
6261 6281 } else {
6262 6282 PyErr_Clear();
6263 6283 }
6264 6284 }
6265 6285 abstractBinFileWidget::moveEvent(arg__1);
6266 6286 }
6267 6287 bool PythonQtShell_abstractBinFileWidget::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
6268 6288 {
6269 6289 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6270 6290 static PyObject* name = PyString_FromString("nativeEvent");
6271 6291 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6272 6292 if (obj) {
6273 6293 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
6274 6294 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
6275 6295 bool returnValue;
6276 6296 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
6277 6297 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6278 6298 if (result) {
6279 6299 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6280 6300 if (args[0]!=&returnValue) {
6281 6301 if (args[0]==NULL) {
6282 6302 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
6283 6303 } else {
6284 6304 returnValue = *((bool*)args[0]);
6285 6305 }
6286 6306 }
6287 6307 }
6288 6308 if (result) { Py_DECREF(result); }
6289 6309 Py_DECREF(obj);
6290 6310 return returnValue;
6291 6311 } else {
6292 6312 PyErr_Clear();
6293 6313 }
6294 6314 }
6295 6315 return abstractBinFileWidget::nativeEvent(eventType0, message1, result2);
6296 6316 }
6297 6317 QPaintEngine* PythonQtShell_abstractBinFileWidget::paintEngine() const
6298 6318 {
6299 6319 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6300 6320 static PyObject* name = PyString_FromString("paintEngine");
6301 6321 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6302 6322 if (obj) {
6303 6323 static const char* argumentList[] ={"QPaintEngine*"};
6304 6324 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6305 6325 QPaintEngine* returnValue;
6306 6326 void* args[1] = {NULL};
6307 6327 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6308 6328 if (result) {
6309 6329 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6310 6330 if (args[0]!=&returnValue) {
6311 6331 if (args[0]==NULL) {
6312 6332 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
6313 6333 } else {
6314 6334 returnValue = *((QPaintEngine**)args[0]);
6315 6335 }
6316 6336 }
6317 6337 }
6318 6338 if (result) { Py_DECREF(result); }
6319 6339 Py_DECREF(obj);
6320 6340 return returnValue;
6321 6341 } else {
6322 6342 PyErr_Clear();
6323 6343 }
6324 6344 }
6325 6345 return abstractBinFileWidget::paintEngine();
6326 6346 }
6327 6347 void PythonQtShell_abstractBinFileWidget::paintEvent(QPaintEvent* arg__1)
6328 6348 {
6329 6349 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6330 6350 static PyObject* name = PyString_FromString("paintEvent");
6331 6351 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6332 6352 if (obj) {
6333 6353 static const char* argumentList[] ={"" , "QPaintEvent*"};
6334 6354 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6335 6355 void* args[2] = {NULL, (void*)&arg__1};
6336 6356 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6337 6357 if (result) { Py_DECREF(result); }
6338 6358 Py_DECREF(obj);
6339 6359 return;
6340 6360 } else {
6341 6361 PyErr_Clear();
6342 6362 }
6343 6363 }
6344 6364 abstractBinFileWidget::paintEvent(arg__1);
6345 6365 }
6346 6366 QPaintDevice* PythonQtShell_abstractBinFileWidget::redirected(QPoint* offset0) const
6347 6367 {
6348 6368 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6349 6369 static PyObject* name = PyString_FromString("redirected");
6350 6370 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6351 6371 if (obj) {
6352 6372 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
6353 6373 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6354 6374 QPaintDevice* returnValue;
6355 6375 void* args[2] = {NULL, (void*)&offset0};
6356 6376 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6357 6377 if (result) {
6358 6378 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6359 6379 if (args[0]!=&returnValue) {
6360 6380 if (args[0]==NULL) {
6361 6381 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
6362 6382 } else {
6363 6383 returnValue = *((QPaintDevice**)args[0]);
6364 6384 }
6365 6385 }
6366 6386 }
6367 6387 if (result) { Py_DECREF(result); }
6368 6388 Py_DECREF(obj);
6369 6389 return returnValue;
6370 6390 } else {
6371 6391 PyErr_Clear();
6372 6392 }
6373 6393 }
6374 6394 return abstractBinFileWidget::redirected(offset0);
6375 6395 }
6376 6396 void PythonQtShell_abstractBinFileWidget::reloadFile()
6377 6397 {
6378 6398 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6379 6399 static PyObject* name = PyString_FromString("reloadFile");
6380 6400 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6381 6401 if (obj) {
6382 6402 static const char* argumentList[] ={""};
6383 6403 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6384 6404 void* args[1] = {NULL};
6385 6405 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6386 6406 if (result) { Py_DECREF(result); }
6387 6407 Py_DECREF(obj);
6388 6408 return;
6389 6409 } else {
6390 6410 PyErr_Clear();
6391 6411 }
6392 6412 }
6393 6413
6394 6414 }
6395 6415 void PythonQtShell_abstractBinFileWidget::resizeEvent(QResizeEvent* arg__1)
6396 6416 {
6397 6417 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6398 6418 static PyObject* name = PyString_FromString("resizeEvent");
6399 6419 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6400 6420 if (obj) {
6401 6421 static const char* argumentList[] ={"" , "QResizeEvent*"};
6402 6422 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6403 6423 void* args[2] = {NULL, (void*)&arg__1};
6404 6424 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6405 6425 if (result) { Py_DECREF(result); }
6406 6426 Py_DECREF(obj);
6407 6427 return;
6408 6428 } else {
6409 6429 PyErr_Clear();
6410 6430 }
6411 6431 }
6412 6432 abstractBinFileWidget::resizeEvent(arg__1);
6413 6433 }
6414 6434 void PythonQtShell_abstractBinFileWidget::setFile(abstractBinFile* file0)
6415 6435 {
6416 6436 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6417 6437 static PyObject* name = PyString_FromString("setFile");
6418 6438 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6419 6439 if (obj) {
6420 6440 static const char* argumentList[] ={"" , "abstractBinFile*"};
6421 6441 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6422 6442 void* args[2] = {NULL, (void*)&file0};
6423 6443 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6424 6444 if (result) { Py_DECREF(result); }
6425 6445 Py_DECREF(obj);
6426 6446 return;
6427 6447 } else {
6428 6448 PyErr_Clear();
6429 6449 }
6430 6450 }
6431 6451
6432 6452 }
6433 6453 QPainter* PythonQtShell_abstractBinFileWidget::sharedPainter() const
6434 6454 {
6435 6455 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6436 6456 static PyObject* name = PyString_FromString("sharedPainter");
6437 6457 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6438 6458 if (obj) {
6439 6459 static const char* argumentList[] ={"QPainter*"};
6440 6460 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6441 6461 QPainter* returnValue;
6442 6462 void* args[1] = {NULL};
6443 6463 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6444 6464 if (result) {
6445 6465 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6446 6466 if (args[0]!=&returnValue) {
6447 6467 if (args[0]==NULL) {
6448 6468 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
6449 6469 } else {
6450 6470 returnValue = *((QPainter**)args[0]);
6451 6471 }
6452 6472 }
6453 6473 }
6454 6474 if (result) { Py_DECREF(result); }
6455 6475 Py_DECREF(obj);
6456 6476 return returnValue;
6457 6477 } else {
6458 6478 PyErr_Clear();
6459 6479 }
6460 6480 }
6461 6481 return abstractBinFileWidget::sharedPainter();
6462 6482 }
6463 6483 void PythonQtShell_abstractBinFileWidget::showEvent(QShowEvent* arg__1)
6464 6484 {
6465 6485 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6466 6486 static PyObject* name = PyString_FromString("showEvent");
6467 6487 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6468 6488 if (obj) {
6469 6489 static const char* argumentList[] ={"" , "QShowEvent*"};
6470 6490 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6471 6491 void* args[2] = {NULL, (void*)&arg__1};
6472 6492 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6473 6493 if (result) { Py_DECREF(result); }
6474 6494 Py_DECREF(obj);
6475 6495 return;
6476 6496 } else {
6477 6497 PyErr_Clear();
6478 6498 }
6479 6499 }
6480 6500 abstractBinFileWidget::showEvent(arg__1);
6481 6501 }
6482 6502 QSize PythonQtShell_abstractBinFileWidget::sizeHint() const
6483 6503 {
6484 6504 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6485 6505 static PyObject* name = PyString_FromString("getSizeHint");
6486 6506 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6487 6507 if (obj) {
6488 6508 static const char* argumentList[] ={"QSize"};
6489 6509 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6490 6510 QSize returnValue;
6491 6511 void* args[1] = {NULL};
6492 6512 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6493 6513 if (result) {
6494 6514 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6495 6515 if (args[0]!=&returnValue) {
6496 6516 if (args[0]==NULL) {
6497 6517 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
6498 6518 } else {
6499 6519 returnValue = *((QSize*)args[0]);
6500 6520 }
6501 6521 }
6502 6522 }
6503 6523 if (result) { Py_DECREF(result); }
6504 6524 Py_DECREF(obj);
6505 6525 return returnValue;
6506 6526 } else {
6507 6527 PyErr_Clear();
6508 6528 }
6509 6529 }
6510 6530 return abstractBinFileWidget::sizeHint();
6511 6531 }
6512 6532 void PythonQtShell_abstractBinFileWidget::tabletEvent(QTabletEvent* arg__1)
6513 6533 {
6514 6534 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6515 6535 static PyObject* name = PyString_FromString("tabletEvent");
6516 6536 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6517 6537 if (obj) {
6518 6538 static const char* argumentList[] ={"" , "QTabletEvent*"};
6519 6539 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6520 6540 void* args[2] = {NULL, (void*)&arg__1};
6521 6541 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6522 6542 if (result) { Py_DECREF(result); }
6523 6543 Py_DECREF(obj);
6524 6544 return;
6525 6545 } else {
6526 6546 PyErr_Clear();
6527 6547 }
6528 6548 }
6529 6549 abstractBinFileWidget::tabletEvent(arg__1);
6530 6550 }
6531 6551 void PythonQtShell_abstractBinFileWidget::timerEvent(QTimerEvent* arg__1)
6532 6552 {
6533 6553 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6534 6554 static PyObject* name = PyString_FromString("timerEvent");
6535 6555 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6536 6556 if (obj) {
6537 6557 static const char* argumentList[] ={"" , "QTimerEvent*"};
6538 6558 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6539 6559 void* args[2] = {NULL, (void*)&arg__1};
6540 6560 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6541 6561 if (result) { Py_DECREF(result); }
6542 6562 Py_DECREF(obj);
6543 6563 return;
6544 6564 } else {
6545 6565 PyErr_Clear();
6546 6566 }
6547 6567 }
6548 6568 abstractBinFileWidget::timerEvent(arg__1);
6549 6569 }
6550 6570 void PythonQtShell_abstractBinFileWidget::wheelEvent(QWheelEvent* arg__1)
6551 6571 {
6552 6572 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6553 6573 static PyObject* name = PyString_FromString("wheelEvent");
6554 6574 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6555 6575 if (obj) {
6556 6576 static const char* argumentList[] ={"" , "QWheelEvent*"};
6557 6577 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6558 6578 void* args[2] = {NULL, (void*)&arg__1};
6559 6579 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6560 6580 if (result) { Py_DECREF(result); }
6561 6581 Py_DECREF(obj);
6562 6582 return;
6563 6583 } else {
6564 6584 PyErr_Clear();
6565 6585 }
6566 6586 }
6567 6587 abstractBinFileWidget::wheelEvent(arg__1);
6568 6588 }
6569 6589 abstractBinFileWidget* PythonQtWrapper_abstractBinFileWidget::new_abstractBinFileWidget(QWidget* parent)
6570 6590 {
6571 6591 return new PythonQtShell_abstractBinFileWidget(parent); }
6572 6592
6573 6593 void PythonQtWrapper_abstractBinFileWidget::reloadFile(abstractBinFileWidget* theWrappedObject)
6574 6594 {
6575 6595 ( ((PythonQtPublicPromoter_abstractBinFileWidget*)theWrappedObject)->promoted_reloadFile());
6576 6596 }
6577 6597
6578 6598 void PythonQtWrapper_abstractBinFileWidget::setFile(abstractBinFileWidget* theWrappedObject, abstractBinFile* file)
6579 6599 {
6580 6600 ( ((PythonQtPublicPromoter_abstractBinFileWidget*)theWrappedObject)->promoted_setFile(file));
6581 6601 }
6582 6602
6583 6603
6584 6604
6585 6605 PythonQtShell_binaryFile::~PythonQtShell_binaryFile() {
6586 6606 PythonQtPrivate* priv = PythonQt::priv();
6587 6607 if (priv) { priv->shellClassDeleted(this); }
6588 6608 }
6589 6609 int PythonQtShell_binaryFile::closeFile()
6590 6610 {
6591 6611 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6592 6612 static PyObject* name = PyString_FromString("closeFile");
6593 6613 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6594 6614 if (obj) {
6595 6615 static const char* argumentList[] ={"int"};
6596 6616 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6597 6617 int returnValue;
6598 6618 void* args[1] = {NULL};
6599 6619 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6600 6620 if (result) {
6601 6621 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6602 6622 if (args[0]!=&returnValue) {
6603 6623 if (args[0]==NULL) {
6604 6624 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
6605 6625 } else {
6606 6626 returnValue = *((int*)args[0]);
6607 6627 }
6608 6628 }
6609 6629 }
6610 6630 if (result) { Py_DECREF(result); }
6611 6631 Py_DECREF(obj);
6612 6632 return returnValue;
6613 6633 } else {
6614 6634 PyErr_Clear();
6615 6635 }
6616 6636 }
6617 6637 return binaryFile::closeFile();
6618 6638 }
6619 6639 QList<codeFragment* > PythonQtShell_binaryFile::getFragments()
6620 6640 {
6621 6641 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6622 6642 static PyObject* name = PyString_FromString("getFragments");
6623 6643 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6624 6644 if (obj) {
6625 6645 static const char* argumentList[] ={"QList<codeFragment* >"};
6626 6646 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6627 6647 QList<codeFragment* > returnValue;
6628 6648 void* args[1] = {NULL};
6629 6649 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6630 6650 if (result) {
6631 6651 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6632 6652 if (args[0]!=&returnValue) {
6633 6653 if (args[0]==NULL) {
6634 6654 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
6635 6655 } else {
6636 6656 returnValue = *((QList<codeFragment* >*)args[0]);
6637 6657 }
6638 6658 }
6639 6659 }
6640 6660 if (result) { Py_DECREF(result); }
6641 6661 Py_DECREF(obj);
6642 6662 return returnValue;
6643 6663 } else {
6644 6664 PyErr_Clear();
6645 6665 }
6646 6666 }
6647 6667 return binaryFile::getFragments();
6648 6668 }
6649 6669 bool PythonQtShell_binaryFile::isopened()
6650 6670 {
6651 6671 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6652 6672 static PyObject* name = PyString_FromString("isopened");
6653 6673 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6654 6674 if (obj) {
6655 6675 static const char* argumentList[] ={"bool"};
6656 6676 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6657 6677 bool returnValue;
6658 6678 void* args[1] = {NULL};
6659 6679 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6660 6680 if (result) {
6661 6681 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6662 6682 if (args[0]!=&returnValue) {
6663 6683 if (args[0]==NULL) {
6664 6684 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
6665 6685 } else {
6666 6686 returnValue = *((bool*)args[0]);
6667 6687 }
6668 6688 }
6669 6689 }
6670 6690 if (result) { Py_DECREF(result); }
6671 6691 Py_DECREF(obj);
6672 6692 return returnValue;
6673 6693 } else {
6674 6694 PyErr_Clear();
6675 6695 }
6676 6696 }
6677 6697 return binaryFile::isopened();
6678 6698 }
6679 6699 bool PythonQtShell_binaryFile::openFile(const QString& File0)
6680 6700 {
6681 6701 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6682 6702 static PyObject* name = PyString_FromString("openFile");
6683 6703 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6684 6704 if (obj) {
6685 6705 static const char* argumentList[] ={"bool" , "const QString&"};
6686 6706 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6687 6707 bool returnValue;
6688 6708 void* args[2] = {NULL, (void*)&File0};
6689 6709 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6690 6710 if (result) {
6691 6711 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6692 6712 if (args[0]!=&returnValue) {
6693 6713 if (args[0]==NULL) {
6694 6714 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
6695 6715 } else {
6696 6716 returnValue = *((bool*)args[0]);
6697 6717 }
6698 6718 }
6699 6719 }
6700 6720 if (result) { Py_DECREF(result); }
6701 6721 Py_DECREF(obj);
6702 6722 return returnValue;
6703 6723 } else {
6704 6724 PyErr_Clear();
6705 6725 }
6706 6726 }
6707 6727 return binaryFile::openFile(File0);
6708 6728 }
6709 6729 bool PythonQtShell_binaryFile::toBinary(const QString& fileName0)
6710 6730 {
6711 6731 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6712 6732 static PyObject* name = PyString_FromString("toBinary");
6713 6733 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6714 6734 if (obj) {
6715 6735 static const char* argumentList[] ={"bool" , "const QString&"};
6716 6736 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6717 6737 bool returnValue;
6718 6738 void* args[2] = {NULL, (void*)&fileName0};
6719 6739 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6720 6740 if (result) {
6721 6741 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6722 6742 if (args[0]!=&returnValue) {
6723 6743 if (args[0]==NULL) {
6724 6744 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
6725 6745 } else {
6726 6746 returnValue = *((bool*)args[0]);
6727 6747 }
6728 6748 }
6729 6749 }
6730 6750 if (result) { Py_DECREF(result); }
6731 6751 Py_DECREF(obj);
6732 6752 return returnValue;
6733 6753 } else {
6734 6754 PyErr_Clear();
6735 6755 }
6736 6756 }
6737 6757 return binaryFile::toBinary(fileName0);
6738 6758 }
6739 6759 bool PythonQtShell_binaryFile::toSrec(const QString& fileName0)
6740 6760 {
6741 6761 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6742 6762 static PyObject* name = PyString_FromString("toSrec");
6743 6763 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6744 6764 if (obj) {
6745 6765 static const char* argumentList[] ={"bool" , "const QString&"};
6746 6766 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6747 6767 bool returnValue;
6748 6768 void* args[2] = {NULL, (void*)&fileName0};
6749 6769 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6750 6770 if (result) {
6751 6771 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6752 6772 if (args[0]!=&returnValue) {
6753 6773 if (args[0]==NULL) {
6754 6774 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
6755 6775 } else {
6756 6776 returnValue = *((bool*)args[0]);
6757 6777 }
6758 6778 }
6759 6779 }
6760 6780 if (result) { Py_DECREF(result); }
6761 6781 Py_DECREF(obj);
6762 6782 return returnValue;
6763 6783 } else {
6764 6784 PyErr_Clear();
6765 6785 }
6766 6786 }
6767 6787 return binaryFile::toSrec(fileName0);
6768 6788 }
6769 6789 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile()
6770 6790 {
6771 6791 return new PythonQtShell_binaryFile(); }
6772 6792
6773 6793 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile(const QString& File)
6774 6794 {
6775 6795 return new PythonQtShell_binaryFile(File); }
6776 6796
6777 6797 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile(const QStringList& Files)
6778 6798 {
6779 6799 return new PythonQtShell_binaryFile(Files); }
6780 6800
6781 6801 int PythonQtWrapper_binaryFile::closeFile(binaryFile* theWrappedObject)
6782 6802 {
6783 6803 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_closeFile());
6784 6804 }
6785 6805
6786 6806 codeFragment* PythonQtWrapper_binaryFile::getFragment(binaryFile* theWrappedObject, int index)
6787 6807 {
6788 6808 return ( theWrappedObject->getFragment(index));
6789 6809 }
6790 6810
6791 6811 int PythonQtWrapper_binaryFile::getFragmentAddress(binaryFile* theWrappedObject, int index)
6792 6812 {
6793 6813 return ( theWrappedObject->getFragmentAddress(index));
6794 6814 }
6795 6815
6796 6816 bool PythonQtWrapper_binaryFile::getFragmentData(binaryFile* theWrappedObject, int index, char** buffer)
6797 6817 {
6798 6818 return ( theWrappedObject->getFragmentData(index, buffer));
6799 6819 }
6800 6820
6801 6821 QString PythonQtWrapper_binaryFile::getFragmentHeader(binaryFile* theWrappedObject, int index)
6802 6822 {
6803 6823 return ( theWrappedObject->getFragmentHeader(index));
6804 6824 }
6805 6825
6806 6826 int PythonQtWrapper_binaryFile::getFragmentSize(binaryFile* theWrappedObject, int index)
6807 6827 {
6808 6828 return ( theWrappedObject->getFragmentSize(index));
6809 6829 }
6810 6830
6811 6831 QList<codeFragment* > PythonQtWrapper_binaryFile::getFragments(binaryFile* theWrappedObject)
6812 6832 {
6813 6833 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_getFragments());
6814 6834 }
6815 6835
6816 6836 int PythonQtWrapper_binaryFile::getFragmentsCount(binaryFile* theWrappedObject)
6817 6837 {
6818 6838 return ( theWrappedObject->getFragmentsCount());
6819 6839 }
6820 6840
6821 6841 bool PythonQtWrapper_binaryFile::isopened(binaryFile* theWrappedObject)
6822 6842 {
6823 6843 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_isopened());
6824 6844 }
6825 6845
6826 6846 bool PythonQtWrapper_binaryFile::openFile(binaryFile* theWrappedObject, const QString& File)
6827 6847 {
6828 6848 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_openFile(File));
6829 6849 }
6830 6850
6831 6851 bool PythonQtWrapper_binaryFile::openFiles(binaryFile* theWrappedObject, const QStringList& Files)
6832 6852 {
6833 6853 return ( theWrappedObject->openFiles(Files));
6834 6854 }
6835 6855
6836 6856 bool PythonQtWrapper_binaryFile::static_binaryFile_toBinary(QList<codeFragment* > fragments, const QString& File)
6837 6857 {
6838 6858 return (binaryFile::toBinary(fragments, File));
6839 6859 }
6840 6860
6841 6861 bool PythonQtWrapper_binaryFile::toBinary(binaryFile* theWrappedObject, const QString& fileName)
6842 6862 {
6843 6863 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_toBinary(fileName));
6844 6864 }
6845 6865
6846 6866 bool PythonQtWrapper_binaryFile::toSrec(binaryFile* theWrappedObject, const QString& fileName)
6847 6867 {
6848 6868 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_toSrec(fileName));
6849 6869 }
6850 6870
6851 6871
6852 6872
6853 6873 PythonQtShell_binaryFileWidget::~PythonQtShell_binaryFileWidget() {
6854 6874 PythonQtPrivate* priv = PythonQt::priv();
6855 6875 if (priv) { priv->shellClassDeleted(this); }
6856 6876 }
6857 6877 void PythonQtShell_binaryFileWidget::reloadFile()
6858 6878 {
6859 6879 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6860 6880 static PyObject* name = PyString_FromString("reloadFile");
6861 6881 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6862 6882 if (obj) {
6863 6883 static const char* argumentList[] ={""};
6864 6884 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6865 6885 void* args[1] = {NULL};
6866 6886 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6867 6887 if (result) { Py_DECREF(result); }
6868 6888 Py_DECREF(obj);
6869 6889 return;
6870 6890 } else {
6871 6891 PyErr_Clear();
6872 6892 }
6873 6893 }
6874 6894 binaryFileWidget::reloadFile();
6875 6895 }
6876 6896 void PythonQtShell_binaryFileWidget::setFile(abstractBinFile* file0)
6877 6897 {
6878 6898 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6879 6899 static PyObject* name = PyString_FromString("setFile");
6880 6900 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6881 6901 if (obj) {
6882 6902 static const char* argumentList[] ={"" , "abstractBinFile*"};
6883 6903 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6884 6904 void* args[2] = {NULL, (void*)&file0};
6885 6905 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6886 6906 if (result) { Py_DECREF(result); }
6887 6907 Py_DECREF(obj);
6888 6908 return;
6889 6909 } else {
6890 6910 PyErr_Clear();
6891 6911 }
6892 6912 }
6893 6913 binaryFileWidget::setFile(file0);
6894 6914 }
6895 6915 binaryFileWidget* PythonQtWrapper_binaryFileWidget::new_binaryFileWidget(QWidget* parent)
6896 6916 {
6897 6917 return new PythonQtShell_binaryFileWidget(parent); }
6898 6918
6899 6919 void PythonQtWrapper_binaryFileWidget::reloadFile(binaryFileWidget* theWrappedObject)
6900 6920 {
6901 6921 ( ((PythonQtPublicPromoter_binaryFileWidget*)theWrappedObject)->promoted_reloadFile());
6902 6922 }
6903 6923
6904 6924 void PythonQtWrapper_binaryFileWidget::setFile(binaryFileWidget* theWrappedObject, abstractBinFile* file)
6905 6925 {
6906 6926 ( ((PythonQtPublicPromoter_binaryFileWidget*)theWrappedObject)->promoted_setFile(file));
6907 6927 }
6908 6928
6909 6929
6910 6930
6911 6931 PythonQtShell_codeFragment::~PythonQtShell_codeFragment() {
6912 6932 PythonQtPrivate* priv = PythonQt::priv();
6913 6933 if (priv) { priv->shellClassDeleted(this); }
6914 6934 }
6915 6935 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment()
6916 6936 {
6917 6937 return new PythonQtShell_codeFragment(); }
6918 6938
6919 6939 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment(char* data, quint64 size, quint64 address)
6920 6940 {
6921 6941 return new PythonQtShell_codeFragment(data, size, address); }
6922 6942
6923 6943
6924 6944
6925 6945 PythonQtShell_elfFileWidget::~PythonQtShell_elfFileWidget() {
6926 6946 PythonQtPrivate* priv = PythonQt::priv();
6927 6947 if (priv) { priv->shellClassDeleted(this); }
6928 6948 }
6929 6949 void PythonQtShell_elfFileWidget::reloadFile()
6930 6950 {
6931 6951 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6932 6952 static PyObject* name = PyString_FromString("reloadFile");
6933 6953 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6934 6954 if (obj) {
6935 6955 static const char* argumentList[] ={""};
6936 6956 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6937 6957 void* args[1] = {NULL};
6938 6958 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6939 6959 if (result) { Py_DECREF(result); }
6940 6960 Py_DECREF(obj);
6941 6961 return;
6942 6962 } else {
6943 6963 PyErr_Clear();
6944 6964 }
6945 6965 }
6946 6966 elfFileWidget::reloadFile();
6947 6967 }
6948 6968 void PythonQtShell_elfFileWidget::setFile(abstractBinFile* file0)
6949 6969 {
6950 6970 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6951 6971 static PyObject* name = PyString_FromString("setFile");
6952 6972 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6953 6973 if (obj) {
6954 6974 static const char* argumentList[] ={"" , "abstractBinFile*"};
6955 6975 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6956 6976 void* args[2] = {NULL, (void*)&file0};
6957 6977 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6958 6978 if (result) { Py_DECREF(result); }
6959 6979 Py_DECREF(obj);
6960 6980 return;
6961 6981 } else {
6962 6982 PyErr_Clear();
6963 6983 }
6964 6984 }
6965 6985 elfFileWidget::setFile(file0);
6966 6986 }
6967 6987 elfFileWidget* PythonQtWrapper_elfFileWidget::new_elfFileWidget(QWidget* parent)
6968 6988 {
6969 6989 return new PythonQtShell_elfFileWidget(parent); }
6970 6990
6971 6991 void PythonQtWrapper_elfFileWidget::reloadFile(elfFileWidget* theWrappedObject)
6972 6992 {
6973 6993 ( ((PythonQtPublicPromoter_elfFileWidget*)theWrappedObject)->promoted_reloadFile());
6974 6994 }
6975 6995
6976 6996 void PythonQtWrapper_elfFileWidget::setFile(elfFileWidget* theWrappedObject, abstractBinFile* file)
6977 6997 {
6978 6998 ( ((PythonQtPublicPromoter_elfFileWidget*)theWrappedObject)->promoted_setFile(file));
6979 6999 }
6980 7000
6981 7001
6982 7002
6983 7003 PythonQtShell_elfInfoWdgt::~PythonQtShell_elfInfoWdgt() {
6984 7004 PythonQtPrivate* priv = PythonQt::priv();
6985 7005 if (priv) { priv->shellClassDeleted(this); }
6986 7006 }
6987 7007 void PythonQtShell_elfInfoWdgt::actionEvent(QActionEvent* arg__1)
6988 7008 {
6989 7009 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6990 7010 static PyObject* name = PyString_FromString("actionEvent");
6991 7011 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6992 7012 if (obj) {
6993 7013 static const char* argumentList[] ={"" , "QActionEvent*"};
6994 7014 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6995 7015 void* args[2] = {NULL, (void*)&arg__1};
6996 7016 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6997 7017 if (result) { Py_DECREF(result); }
6998 7018 Py_DECREF(obj);
6999 7019 return;
7000 7020 } else {
7001 7021 PyErr_Clear();
7002 7022 }
7003 7023 }
7004 7024 elfInfoWdgt::actionEvent(arg__1);
7005 7025 }
7006 7026 void PythonQtShell_elfInfoWdgt::changeEvent(QEvent* arg__1)
7007 7027 {
7008 7028 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7009 7029 static PyObject* name = PyString_FromString("changeEvent");
7010 7030 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7011 7031 if (obj) {
7012 7032 static const char* argumentList[] ={"" , "QEvent*"};
7013 7033 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7014 7034 void* args[2] = {NULL, (void*)&arg__1};
7015 7035 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7016 7036 if (result) { Py_DECREF(result); }
7017 7037 Py_DECREF(obj);
7018 7038 return;
7019 7039 } else {
7020 7040 PyErr_Clear();
7021 7041 }
7022 7042 }
7023 7043 elfInfoWdgt::changeEvent(arg__1);
7024 7044 }
7025 7045 void PythonQtShell_elfInfoWdgt::childEvent(QChildEvent* arg__1)
7026 7046 {
7027 7047 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7028 7048 static PyObject* name = PyString_FromString("childEvent");
7029 7049 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7030 7050 if (obj) {
7031 7051 static const char* argumentList[] ={"" , "QChildEvent*"};
7032 7052 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7033 7053 void* args[2] = {NULL, (void*)&arg__1};
7034 7054 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7035 7055 if (result) { Py_DECREF(result); }
7036 7056 Py_DECREF(obj);
7037 7057 return;
7038 7058 } else {
7039 7059 PyErr_Clear();
7040 7060 }
7041 7061 }
7042 7062 elfInfoWdgt::childEvent(arg__1);
7043 7063 }
7044 7064 void PythonQtShell_elfInfoWdgt::closeEvent(QCloseEvent* arg__1)
7045 7065 {
7046 7066 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7047 7067 static PyObject* name = PyString_FromString("closeEvent");
7048 7068 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7049 7069 if (obj) {
7050 7070 static const char* argumentList[] ={"" , "QCloseEvent*"};
7051 7071 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7052 7072 void* args[2] = {NULL, (void*)&arg__1};
7053 7073 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7054 7074 if (result) { Py_DECREF(result); }
7055 7075 Py_DECREF(obj);
7056 7076 return;
7057 7077 } else {
7058 7078 PyErr_Clear();
7059 7079 }
7060 7080 }
7061 7081 elfInfoWdgt::closeEvent(arg__1);
7062 7082 }
7063 7083 void PythonQtShell_elfInfoWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
7064 7084 {
7065 7085 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7066 7086 static PyObject* name = PyString_FromString("contextMenuEvent");
7067 7087 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7068 7088 if (obj) {
7069 7089 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
7070 7090 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7071 7091 void* args[2] = {NULL, (void*)&arg__1};
7072 7092 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7073 7093 if (result) { Py_DECREF(result); }
7074 7094 Py_DECREF(obj);
7075 7095 return;
7076 7096 } else {
7077 7097 PyErr_Clear();
7078 7098 }
7079 7099 }
7080 7100 elfInfoWdgt::contextMenuEvent(arg__1);
7081 7101 }
7082 7102 void PythonQtShell_elfInfoWdgt::customEvent(QEvent* arg__1)
7083 7103 {
7084 7104 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7085 7105 static PyObject* name = PyString_FromString("customEvent");
7086 7106 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7087 7107 if (obj) {
7088 7108 static const char* argumentList[] ={"" , "QEvent*"};
7089 7109 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7090 7110 void* args[2] = {NULL, (void*)&arg__1};
7091 7111 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7092 7112 if (result) { Py_DECREF(result); }
7093 7113 Py_DECREF(obj);
7094 7114 return;
7095 7115 } else {
7096 7116 PyErr_Clear();
7097 7117 }
7098 7118 }
7099 7119 elfInfoWdgt::customEvent(arg__1);
7100 7120 }
7101 7121 int PythonQtShell_elfInfoWdgt::devType() const
7102 7122 {
7103 7123 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7104 7124 static PyObject* name = PyString_FromString("devType");
7105 7125 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7106 7126 if (obj) {
7107 7127 static const char* argumentList[] ={"int"};
7108 7128 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7109 7129 int returnValue;
7110 7130 void* args[1] = {NULL};
7111 7131 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7112 7132 if (result) {
7113 7133 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7114 7134 if (args[0]!=&returnValue) {
7115 7135 if (args[0]==NULL) {
7116 7136 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
7117 7137 } else {
7118 7138 returnValue = *((int*)args[0]);
7119 7139 }
7120 7140 }
7121 7141 }
7122 7142 if (result) { Py_DECREF(result); }
7123 7143 Py_DECREF(obj);
7124 7144 return returnValue;
7125 7145 } else {
7126 7146 PyErr_Clear();
7127 7147 }
7128 7148 }
7129 7149 return elfInfoWdgt::devType();
7130 7150 }
7131 7151 void PythonQtShell_elfInfoWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
7132 7152 {
7133 7153 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7134 7154 static PyObject* name = PyString_FromString("dragEnterEvent");
7135 7155 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7136 7156 if (obj) {
7137 7157 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
7138 7158 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7139 7159 void* args[2] = {NULL, (void*)&arg__1};
7140 7160 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7141 7161 if (result) { Py_DECREF(result); }
7142 7162 Py_DECREF(obj);
7143 7163 return;
7144 7164 } else {
7145 7165 PyErr_Clear();
7146 7166 }
7147 7167 }
7148 7168 elfInfoWdgt::dragEnterEvent(arg__1);
7149 7169 }
7150 7170 void PythonQtShell_elfInfoWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
7151 7171 {
7152 7172 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7153 7173 static PyObject* name = PyString_FromString("dragLeaveEvent");
7154 7174 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7155 7175 if (obj) {
7156 7176 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
7157 7177 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7158 7178 void* args[2] = {NULL, (void*)&arg__1};
7159 7179 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7160 7180 if (result) { Py_DECREF(result); }
7161 7181 Py_DECREF(obj);
7162 7182 return;
7163 7183 } else {
7164 7184 PyErr_Clear();
7165 7185 }
7166 7186 }
7167 7187 elfInfoWdgt::dragLeaveEvent(arg__1);
7168 7188 }
7169 7189 void PythonQtShell_elfInfoWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
7170 7190 {
7171 7191 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7172 7192 static PyObject* name = PyString_FromString("dragMoveEvent");
7173 7193 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7174 7194 if (obj) {
7175 7195 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
7176 7196 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7177 7197 void* args[2] = {NULL, (void*)&arg__1};
7178 7198 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7179 7199 if (result) { Py_DECREF(result); }
7180 7200 Py_DECREF(obj);
7181 7201 return;
7182 7202 } else {
7183 7203 PyErr_Clear();
7184 7204 }
7185 7205 }
7186 7206 elfInfoWdgt::dragMoveEvent(arg__1);
7187 7207 }
7188 7208 void PythonQtShell_elfInfoWdgt::dropEvent(QDropEvent* arg__1)
7189 7209 {
7190 7210 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7191 7211 static PyObject* name = PyString_FromString("dropEvent");
7192 7212 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7193 7213 if (obj) {
7194 7214 static const char* argumentList[] ={"" , "QDropEvent*"};
7195 7215 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7196 7216 void* args[2] = {NULL, (void*)&arg__1};
7197 7217 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7198 7218 if (result) { Py_DECREF(result); }
7199 7219 Py_DECREF(obj);
7200 7220 return;
7201 7221 } else {
7202 7222 PyErr_Clear();
7203 7223 }
7204 7224 }
7205 7225 elfInfoWdgt::dropEvent(arg__1);
7206 7226 }
7207 7227 void PythonQtShell_elfInfoWdgt::enterEvent(QEvent* arg__1)
7208 7228 {
7209 7229 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7210 7230 static PyObject* name = PyString_FromString("enterEvent");
7211 7231 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7212 7232 if (obj) {
7213 7233 static const char* argumentList[] ={"" , "QEvent*"};
7214 7234 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7215 7235 void* args[2] = {NULL, (void*)&arg__1};
7216 7236 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7217 7237 if (result) { Py_DECREF(result); }
7218 7238 Py_DECREF(obj);
7219 7239 return;
7220 7240 } else {
7221 7241 PyErr_Clear();
7222 7242 }
7223 7243 }
7224 7244 elfInfoWdgt::enterEvent(arg__1);
7225 7245 }
7226 7246 bool PythonQtShell_elfInfoWdgt::event(QEvent* arg__1)
7227 7247 {
7228 7248 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7229 7249 static PyObject* name = PyString_FromString("event");
7230 7250 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7231 7251 if (obj) {
7232 7252 static const char* argumentList[] ={"bool" , "QEvent*"};
7233 7253 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7234 7254 bool returnValue;
7235 7255 void* args[2] = {NULL, (void*)&arg__1};
7236 7256 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7237 7257 if (result) {
7238 7258 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7239 7259 if (args[0]!=&returnValue) {
7240 7260 if (args[0]==NULL) {
7241 7261 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
7242 7262 } else {
7243 7263 returnValue = *((bool*)args[0]);
7244 7264 }
7245 7265 }
7246 7266 }
7247 7267 if (result) { Py_DECREF(result); }
7248 7268 Py_DECREF(obj);
7249 7269 return returnValue;
7250 7270 } else {
7251 7271 PyErr_Clear();
7252 7272 }
7253 7273 }
7254 7274 return elfInfoWdgt::event(arg__1);
7255 7275 }
7256 7276 bool PythonQtShell_elfInfoWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
7257 7277 {
7258 7278 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7259 7279 static PyObject* name = PyString_FromString("eventFilter");
7260 7280 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7261 7281 if (obj) {
7262 7282 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
7263 7283 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
7264 7284 bool returnValue;
7265 7285 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
7266 7286 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7267 7287 if (result) {
7268 7288 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7269 7289 if (args[0]!=&returnValue) {
7270 7290 if (args[0]==NULL) {
7271 7291 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
7272 7292 } else {
7273 7293 returnValue = *((bool*)args[0]);
7274 7294 }
7275 7295 }
7276 7296 }
7277 7297 if (result) { Py_DECREF(result); }
7278 7298 Py_DECREF(obj);
7279 7299 return returnValue;
7280 7300 } else {
7281 7301 PyErr_Clear();
7282 7302 }
7283 7303 }
7284 7304 return elfInfoWdgt::eventFilter(arg__1, arg__2);
7285 7305 }
7286 7306 void PythonQtShell_elfInfoWdgt::focusInEvent(QFocusEvent* arg__1)
7287 7307 {
7288 7308 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7289 7309 static PyObject* name = PyString_FromString("focusInEvent");
7290 7310 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7291 7311 if (obj) {
7292 7312 static const char* argumentList[] ={"" , "QFocusEvent*"};
7293 7313 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7294 7314 void* args[2] = {NULL, (void*)&arg__1};
7295 7315 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7296 7316 if (result) { Py_DECREF(result); }
7297 7317 Py_DECREF(obj);
7298 7318 return;
7299 7319 } else {
7300 7320 PyErr_Clear();
7301 7321 }
7302 7322 }
7303 7323 elfInfoWdgt::focusInEvent(arg__1);
7304 7324 }
7305 7325 bool PythonQtShell_elfInfoWdgt::focusNextPrevChild(bool next0)
7306 7326 {
7307 7327 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7308 7328 static PyObject* name = PyString_FromString("focusNextPrevChild");
7309 7329 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7310 7330 if (obj) {
7311 7331 static const char* argumentList[] ={"bool" , "bool"};
7312 7332 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7313 7333 bool returnValue;
7314 7334 void* args[2] = {NULL, (void*)&next0};
7315 7335 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7316 7336 if (result) {
7317 7337 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7318 7338 if (args[0]!=&returnValue) {
7319 7339 if (args[0]==NULL) {
7320 7340 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
7321 7341 } else {
7322 7342 returnValue = *((bool*)args[0]);
7323 7343 }
7324 7344 }
7325 7345 }
7326 7346 if (result) { Py_DECREF(result); }
7327 7347 Py_DECREF(obj);
7328 7348 return returnValue;
7329 7349 } else {
7330 7350 PyErr_Clear();
7331 7351 }
7332 7352 }
7333 7353 return elfInfoWdgt::focusNextPrevChild(next0);
7334 7354 }
7335 7355 void PythonQtShell_elfInfoWdgt::focusOutEvent(QFocusEvent* arg__1)
7336 7356 {
7337 7357 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7338 7358 static PyObject* name = PyString_FromString("focusOutEvent");
7339 7359 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7340 7360 if (obj) {
7341 7361 static const char* argumentList[] ={"" , "QFocusEvent*"};
7342 7362 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7343 7363 void* args[2] = {NULL, (void*)&arg__1};
7344 7364 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7345 7365 if (result) { Py_DECREF(result); }
7346 7366 Py_DECREF(obj);
7347 7367 return;
7348 7368 } else {
7349 7369 PyErr_Clear();
7350 7370 }
7351 7371 }
7352 7372 elfInfoWdgt::focusOutEvent(arg__1);
7353 7373 }
7354 7374 bool PythonQtShell_elfInfoWdgt::hasHeightForWidth() const
7355 7375 {
7356 7376 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7357 7377 static PyObject* name = PyString_FromString("hasHeightForWidth");
7358 7378 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7359 7379 if (obj) {
7360 7380 static const char* argumentList[] ={"bool"};
7361 7381 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7362 7382 bool returnValue;
7363 7383 void* args[1] = {NULL};
7364 7384 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7365 7385 if (result) {
7366 7386 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7367 7387 if (args[0]!=&returnValue) {
7368 7388 if (args[0]==NULL) {
7369 7389 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
7370 7390 } else {
7371 7391 returnValue = *((bool*)args[0]);
7372 7392 }
7373 7393 }
7374 7394 }
7375 7395 if (result) { Py_DECREF(result); }
7376 7396 Py_DECREF(obj);
7377 7397 return returnValue;
7378 7398 } else {
7379 7399 PyErr_Clear();
7380 7400 }
7381 7401 }
7382 7402 return elfInfoWdgt::hasHeightForWidth();
7383 7403 }
7384 7404 int PythonQtShell_elfInfoWdgt::heightForWidth(int arg__1) const
7385 7405 {
7386 7406 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7387 7407 static PyObject* name = PyString_FromString("heightForWidth");
7388 7408 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7389 7409 if (obj) {
7390 7410 static const char* argumentList[] ={"int" , "int"};
7391 7411 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7392 7412 int returnValue;
7393 7413 void* args[2] = {NULL, (void*)&arg__1};
7394 7414 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7395 7415 if (result) {
7396 7416 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7397 7417 if (args[0]!=&returnValue) {
7398 7418 if (args[0]==NULL) {
7399 7419 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
7400 7420 } else {
7401 7421 returnValue = *((int*)args[0]);
7402 7422 }
7403 7423 }
7404 7424 }
7405 7425 if (result) { Py_DECREF(result); }
7406 7426 Py_DECREF(obj);
7407 7427 return returnValue;
7408 7428 } else {
7409 7429 PyErr_Clear();
7410 7430 }
7411 7431 }
7412 7432 return elfInfoWdgt::heightForWidth(arg__1);
7413 7433 }
7414 7434 void PythonQtShell_elfInfoWdgt::hideEvent(QHideEvent* arg__1)
7415 7435 {
7416 7436 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7417 7437 static PyObject* name = PyString_FromString("hideEvent");
7418 7438 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7419 7439 if (obj) {
7420 7440 static const char* argumentList[] ={"" , "QHideEvent*"};
7421 7441 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7422 7442 void* args[2] = {NULL, (void*)&arg__1};
7423 7443 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7424 7444 if (result) { Py_DECREF(result); }
7425 7445 Py_DECREF(obj);
7426 7446 return;
7427 7447 } else {
7428 7448 PyErr_Clear();
7429 7449 }
7430 7450 }
7431 7451 elfInfoWdgt::hideEvent(arg__1);
7432 7452 }
7433 7453 void PythonQtShell_elfInfoWdgt::initPainter(QPainter* painter0) const
7434 7454 {
7435 7455 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7436 7456 static PyObject* name = PyString_FromString("initPainter");
7437 7457 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7438 7458 if (obj) {
7439 7459 static const char* argumentList[] ={"" , "QPainter*"};
7440 7460 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7441 7461 void* args[2] = {NULL, (void*)&painter0};
7442 7462 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7443 7463 if (result) { Py_DECREF(result); }
7444 7464 Py_DECREF(obj);
7445 7465 return;
7446 7466 } else {
7447 7467 PyErr_Clear();
7448 7468 }
7449 7469 }
7450 7470 elfInfoWdgt::initPainter(painter0);
7451 7471 }
7452 7472 void PythonQtShell_elfInfoWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
7453 7473 {
7454 7474 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7455 7475 static PyObject* name = PyString_FromString("inputMethodEvent");
7456 7476 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7457 7477 if (obj) {
7458 7478 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
7459 7479 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7460 7480 void* args[2] = {NULL, (void*)&arg__1};
7461 7481 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7462 7482 if (result) { Py_DECREF(result); }
7463 7483 Py_DECREF(obj);
7464 7484 return;
7465 7485 } else {
7466 7486 PyErr_Clear();
7467 7487 }
7468 7488 }
7469 7489 elfInfoWdgt::inputMethodEvent(arg__1);
7470 7490 }
7471 7491 QVariant PythonQtShell_elfInfoWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
7472 7492 {
7473 7493 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7474 7494 static PyObject* name = PyString_FromString("inputMethodQuery");
7475 7495 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7476 7496 if (obj) {
7477 7497 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
7478 7498 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7479 7499 QVariant returnValue;
7480 7500 void* args[2] = {NULL, (void*)&arg__1};
7481 7501 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7482 7502 if (result) {
7483 7503 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7484 7504 if (args[0]!=&returnValue) {
7485 7505 if (args[0]==NULL) {
7486 7506 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
7487 7507 } else {
7488 7508 returnValue = *((QVariant*)args[0]);
7489 7509 }
7490 7510 }
7491 7511 }
7492 7512 if (result) { Py_DECREF(result); }
7493 7513 Py_DECREF(obj);
7494 7514 return returnValue;
7495 7515 } else {
7496 7516 PyErr_Clear();
7497 7517 }
7498 7518 }
7499 7519 return elfInfoWdgt::inputMethodQuery(arg__1);
7500 7520 }
7501 7521 void PythonQtShell_elfInfoWdgt::keyPressEvent(QKeyEvent* arg__1)
7502 7522 {
7503 7523 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7504 7524 static PyObject* name = PyString_FromString("keyPressEvent");
7505 7525 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7506 7526 if (obj) {
7507 7527 static const char* argumentList[] ={"" , "QKeyEvent*"};
7508 7528 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7509 7529 void* args[2] = {NULL, (void*)&arg__1};
7510 7530 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7511 7531 if (result) { Py_DECREF(result); }
7512 7532 Py_DECREF(obj);
7513 7533 return;
7514 7534 } else {
7515 7535 PyErr_Clear();
7516 7536 }
7517 7537 }
7518 7538 elfInfoWdgt::keyPressEvent(arg__1);
7519 7539 }
7520 7540 void PythonQtShell_elfInfoWdgt::keyReleaseEvent(QKeyEvent* arg__1)
7521 7541 {
7522 7542 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7523 7543 static PyObject* name = PyString_FromString("keyReleaseEvent");
7524 7544 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7525 7545 if (obj) {
7526 7546 static const char* argumentList[] ={"" , "QKeyEvent*"};
7527 7547 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7528 7548 void* args[2] = {NULL, (void*)&arg__1};
7529 7549 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7530 7550 if (result) { Py_DECREF(result); }
7531 7551 Py_DECREF(obj);
7532 7552 return;
7533 7553 } else {
7534 7554 PyErr_Clear();
7535 7555 }
7536 7556 }
7537 7557 elfInfoWdgt::keyReleaseEvent(arg__1);
7538 7558 }
7539 7559 void PythonQtShell_elfInfoWdgt::leaveEvent(QEvent* arg__1)
7540 7560 {
7541 7561 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7542 7562 static PyObject* name = PyString_FromString("leaveEvent");
7543 7563 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7544 7564 if (obj) {
7545 7565 static const char* argumentList[] ={"" , "QEvent*"};
7546 7566 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7547 7567 void* args[2] = {NULL, (void*)&arg__1};
7548 7568 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7549 7569 if (result) { Py_DECREF(result); }
7550 7570 Py_DECREF(obj);
7551 7571 return;
7552 7572 } else {
7553 7573 PyErr_Clear();
7554 7574 }
7555 7575 }
7556 7576 elfInfoWdgt::leaveEvent(arg__1);
7557 7577 }
7558 7578 int PythonQtShell_elfInfoWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
7559 7579 {
7560 7580 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7561 7581 static PyObject* name = PyString_FromString("metric");
7562 7582 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7563 7583 if (obj) {
7564 7584 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
7565 7585 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7566 7586 int returnValue;
7567 7587 void* args[2] = {NULL, (void*)&arg__1};
7568 7588 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7569 7589 if (result) {
7570 7590 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7571 7591 if (args[0]!=&returnValue) {
7572 7592 if (args[0]==NULL) {
7573 7593 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
7574 7594 } else {
7575 7595 returnValue = *((int*)args[0]);
7576 7596 }
7577 7597 }
7578 7598 }
7579 7599 if (result) { Py_DECREF(result); }
7580 7600 Py_DECREF(obj);
7581 7601 return returnValue;
7582 7602 } else {
7583 7603 PyErr_Clear();
7584 7604 }
7585 7605 }
7586 7606 return elfInfoWdgt::metric(arg__1);
7587 7607 }
7588 7608 QSize PythonQtShell_elfInfoWdgt::minimumSizeHint() const
7589 7609 {
7590 7610 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7591 7611 static PyObject* name = PyString_FromString("getMinimumSizeHint");
7592 7612 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7593 7613 if (obj) {
7594 7614 static const char* argumentList[] ={"QSize"};
7595 7615 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7596 7616 QSize returnValue;
7597 7617 void* args[1] = {NULL};
7598 7618 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7599 7619 if (result) {
7600 7620 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7601 7621 if (args[0]!=&returnValue) {
7602 7622 if (args[0]==NULL) {
7603 7623 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
7604 7624 } else {
7605 7625 returnValue = *((QSize*)args[0]);
7606 7626 }
7607 7627 }
7608 7628 }
7609 7629 if (result) { Py_DECREF(result); }
7610 7630 Py_DECREF(obj);
7611 7631 return returnValue;
7612 7632 } else {
7613 7633 PyErr_Clear();
7614 7634 }
7615 7635 }
7616 7636 return elfInfoWdgt::minimumSizeHint();
7617 7637 }
7618 7638 void PythonQtShell_elfInfoWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
7619 7639 {
7620 7640 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7621 7641 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
7622 7642 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7623 7643 if (obj) {
7624 7644 static const char* argumentList[] ={"" , "QMouseEvent*"};
7625 7645 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7626 7646 void* args[2] = {NULL, (void*)&arg__1};
7627 7647 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7628 7648 if (result) { Py_DECREF(result); }
7629 7649 Py_DECREF(obj);
7630 7650 return;
7631 7651 } else {
7632 7652 PyErr_Clear();
7633 7653 }
7634 7654 }
7635 7655 elfInfoWdgt::mouseDoubleClickEvent(arg__1);
7636 7656 }
7637 7657 void PythonQtShell_elfInfoWdgt::mouseMoveEvent(QMouseEvent* arg__1)
7638 7658 {
7639 7659 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7640 7660 static PyObject* name = PyString_FromString("mouseMoveEvent");
7641 7661 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7642 7662 if (obj) {
7643 7663 static const char* argumentList[] ={"" , "QMouseEvent*"};
7644 7664 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7645 7665 void* args[2] = {NULL, (void*)&arg__1};
7646 7666 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7647 7667 if (result) { Py_DECREF(result); }
7648 7668 Py_DECREF(obj);
7649 7669 return;
7650 7670 } else {
7651 7671 PyErr_Clear();
7652 7672 }
7653 7673 }
7654 7674 elfInfoWdgt::mouseMoveEvent(arg__1);
7655 7675 }
7656 7676 void PythonQtShell_elfInfoWdgt::mousePressEvent(QMouseEvent* arg__1)
7657 7677 {
7658 7678 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7659 7679 static PyObject* name = PyString_FromString("mousePressEvent");
7660 7680 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7661 7681 if (obj) {
7662 7682 static const char* argumentList[] ={"" , "QMouseEvent*"};
7663 7683 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7664 7684 void* args[2] = {NULL, (void*)&arg__1};
7665 7685 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7666 7686 if (result) { Py_DECREF(result); }
7667 7687 Py_DECREF(obj);
7668 7688 return;
7669 7689 } else {
7670 7690 PyErr_Clear();
7671 7691 }
7672 7692 }
7673 7693 elfInfoWdgt::mousePressEvent(arg__1);
7674 7694 }
7675 7695 void PythonQtShell_elfInfoWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
7676 7696 {
7677 7697 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7678 7698 static PyObject* name = PyString_FromString("mouseReleaseEvent");
7679 7699 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7680 7700 if (obj) {
7681 7701 static const char* argumentList[] ={"" , "QMouseEvent*"};
7682 7702 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7683 7703 void* args[2] = {NULL, (void*)&arg__1};
7684 7704 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7685 7705 if (result) { Py_DECREF(result); }
7686 7706 Py_DECREF(obj);
7687 7707 return;
7688 7708 } else {
7689 7709 PyErr_Clear();
7690 7710 }
7691 7711 }
7692 7712 elfInfoWdgt::mouseReleaseEvent(arg__1);
7693 7713 }
7694 7714 void PythonQtShell_elfInfoWdgt::moveEvent(QMoveEvent* arg__1)
7695 7715 {
7696 7716 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7697 7717 static PyObject* name = PyString_FromString("moveEvent");
7698 7718 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7699 7719 if (obj) {
7700 7720 static const char* argumentList[] ={"" , "QMoveEvent*"};
7701 7721 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7702 7722 void* args[2] = {NULL, (void*)&arg__1};
7703 7723 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7704 7724 if (result) { Py_DECREF(result); }
7705 7725 Py_DECREF(obj);
7706 7726 return;
7707 7727 } else {
7708 7728 PyErr_Clear();
7709 7729 }
7710 7730 }
7711 7731 elfInfoWdgt::moveEvent(arg__1);
7712 7732 }
7713 7733 bool PythonQtShell_elfInfoWdgt::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
7714 7734 {
7715 7735 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7716 7736 static PyObject* name = PyString_FromString("nativeEvent");
7717 7737 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7718 7738 if (obj) {
7719 7739 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
7720 7740 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
7721 7741 bool returnValue;
7722 7742 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
7723 7743 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7724 7744 if (result) {
7725 7745 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7726 7746 if (args[0]!=&returnValue) {
7727 7747 if (args[0]==NULL) {
7728 7748 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
7729 7749 } else {
7730 7750 returnValue = *((bool*)args[0]);
7731 7751 }
7732 7752 }
7733 7753 }
7734 7754 if (result) { Py_DECREF(result); }
7735 7755 Py_DECREF(obj);
7736 7756 return returnValue;
7737 7757 } else {
7738 7758 PyErr_Clear();
7739 7759 }
7740 7760 }
7741 7761 return elfInfoWdgt::nativeEvent(eventType0, message1, result2);
7742 7762 }
7743 7763 QPaintEngine* PythonQtShell_elfInfoWdgt::paintEngine() const
7744 7764 {
7745 7765 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7746 7766 static PyObject* name = PyString_FromString("paintEngine");
7747 7767 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7748 7768 if (obj) {
7749 7769 static const char* argumentList[] ={"QPaintEngine*"};
7750 7770 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7751 7771 QPaintEngine* returnValue;
7752 7772 void* args[1] = {NULL};
7753 7773 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7754 7774 if (result) {
7755 7775 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7756 7776 if (args[0]!=&returnValue) {
7757 7777 if (args[0]==NULL) {
7758 7778 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
7759 7779 } else {
7760 7780 returnValue = *((QPaintEngine**)args[0]);
7761 7781 }
7762 7782 }
7763 7783 }
7764 7784 if (result) { Py_DECREF(result); }
7765 7785 Py_DECREF(obj);
7766 7786 return returnValue;
7767 7787 } else {
7768 7788 PyErr_Clear();
7769 7789 }
7770 7790 }
7771 7791 return elfInfoWdgt::paintEngine();
7772 7792 }
7773 7793 void PythonQtShell_elfInfoWdgt::paintEvent(QPaintEvent* arg__1)
7774 7794 {
7775 7795 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7776 7796 static PyObject* name = PyString_FromString("paintEvent");
7777 7797 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7778 7798 if (obj) {
7779 7799 static const char* argumentList[] ={"" , "QPaintEvent*"};
7780 7800 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7781 7801 void* args[2] = {NULL, (void*)&arg__1};
7782 7802 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7783 7803 if (result) { Py_DECREF(result); }
7784 7804 Py_DECREF(obj);
7785 7805 return;
7786 7806 } else {
7787 7807 PyErr_Clear();
7788 7808 }
7789 7809 }
7790 7810 elfInfoWdgt::paintEvent(arg__1);
7791 7811 }
7792 7812 QPaintDevice* PythonQtShell_elfInfoWdgt::redirected(QPoint* offset0) const
7793 7813 {
7794 7814 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7795 7815 static PyObject* name = PyString_FromString("redirected");
7796 7816 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7797 7817 if (obj) {
7798 7818 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
7799 7819 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7800 7820 QPaintDevice* returnValue;
7801 7821 void* args[2] = {NULL, (void*)&offset0};
7802 7822 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7803 7823 if (result) {
7804 7824 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7805 7825 if (args[0]!=&returnValue) {
7806 7826 if (args[0]==NULL) {
7807 7827 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
7808 7828 } else {
7809 7829 returnValue = *((QPaintDevice**)args[0]);
7810 7830 }
7811 7831 }
7812 7832 }
7813 7833 if (result) { Py_DECREF(result); }
7814 7834 Py_DECREF(obj);
7815 7835 return returnValue;
7816 7836 } else {
7817 7837 PyErr_Clear();
7818 7838 }
7819 7839 }
7820 7840 return elfInfoWdgt::redirected(offset0);
7821 7841 }
7822 7842 void PythonQtShell_elfInfoWdgt::resizeEvent(QResizeEvent* arg__1)
7823 7843 {
7824 7844 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7825 7845 static PyObject* name = PyString_FromString("resizeEvent");
7826 7846 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7827 7847 if (obj) {
7828 7848 static const char* argumentList[] ={"" , "QResizeEvent*"};
7829 7849 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7830 7850 void* args[2] = {NULL, (void*)&arg__1};
7831 7851 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7832 7852 if (result) { Py_DECREF(result); }
7833 7853 Py_DECREF(obj);
7834 7854 return;
7835 7855 } else {
7836 7856 PyErr_Clear();
7837 7857 }
7838 7858 }
7839 7859 elfInfoWdgt::resizeEvent(arg__1);
7840 7860 }
7841 7861 QPainter* PythonQtShell_elfInfoWdgt::sharedPainter() const
7842 7862 {
7843 7863 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7844 7864 static PyObject* name = PyString_FromString("sharedPainter");
7845 7865 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7846 7866 if (obj) {
7847 7867 static const char* argumentList[] ={"QPainter*"};
7848 7868 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7849 7869 QPainter* returnValue;
7850 7870 void* args[1] = {NULL};
7851 7871 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7852 7872 if (result) {
7853 7873 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7854 7874 if (args[0]!=&returnValue) {
7855 7875 if (args[0]==NULL) {
7856 7876 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
7857 7877 } else {
7858 7878 returnValue = *((QPainter**)args[0]);
7859 7879 }
7860 7880 }
7861 7881 }
7862 7882 if (result) { Py_DECREF(result); }
7863 7883 Py_DECREF(obj);
7864 7884 return returnValue;
7865 7885 } else {
7866 7886 PyErr_Clear();
7867 7887 }
7868 7888 }
7869 7889 return elfInfoWdgt::sharedPainter();
7870 7890 }
7871 7891 void PythonQtShell_elfInfoWdgt::showEvent(QShowEvent* arg__1)
7872 7892 {
7873 7893 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7874 7894 static PyObject* name = PyString_FromString("showEvent");
7875 7895 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7876 7896 if (obj) {
7877 7897 static const char* argumentList[] ={"" , "QShowEvent*"};
7878 7898 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7879 7899 void* args[2] = {NULL, (void*)&arg__1};
7880 7900 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7881 7901 if (result) { Py_DECREF(result); }
7882 7902 Py_DECREF(obj);
7883 7903 return;
7884 7904 } else {
7885 7905 PyErr_Clear();
7886 7906 }
7887 7907 }
7888 7908 elfInfoWdgt::showEvent(arg__1);
7889 7909 }
7890 7910 QSize PythonQtShell_elfInfoWdgt::sizeHint() const
7891 7911 {
7892 7912 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7893 7913 static PyObject* name = PyString_FromString("getSizeHint");
7894 7914 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7895 7915 if (obj) {
7896 7916 static const char* argumentList[] ={"QSize"};
7897 7917 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7898 7918 QSize returnValue;
7899 7919 void* args[1] = {NULL};
7900 7920 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7901 7921 if (result) {
7902 7922 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7903 7923 if (args[0]!=&returnValue) {
7904 7924 if (args[0]==NULL) {
7905 7925 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
7906 7926 } else {
7907 7927 returnValue = *((QSize*)args[0]);
7908 7928 }
7909 7929 }
7910 7930 }
7911 7931 if (result) { Py_DECREF(result); }
7912 7932 Py_DECREF(obj);
7913 7933 return returnValue;
7914 7934 } else {
7915 7935 PyErr_Clear();
7916 7936 }
7917 7937 }
7918 7938 return elfInfoWdgt::sizeHint();
7919 7939 }
7920 7940 void PythonQtShell_elfInfoWdgt::tabletEvent(QTabletEvent* arg__1)
7921 7941 {
7922 7942 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7923 7943 static PyObject* name = PyString_FromString("tabletEvent");
7924 7944 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7925 7945 if (obj) {
7926 7946 static const char* argumentList[] ={"" , "QTabletEvent*"};
7927 7947 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7928 7948 void* args[2] = {NULL, (void*)&arg__1};
7929 7949 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7930 7950 if (result) { Py_DECREF(result); }
7931 7951 Py_DECREF(obj);
7932 7952 return;
7933 7953 } else {
7934 7954 PyErr_Clear();
7935 7955 }
7936 7956 }
7937 7957 elfInfoWdgt::tabletEvent(arg__1);
7938 7958 }
7939 7959 void PythonQtShell_elfInfoWdgt::timerEvent(QTimerEvent* arg__1)
7940 7960 {
7941 7961 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7942 7962 static PyObject* name = PyString_FromString("timerEvent");
7943 7963 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7944 7964 if (obj) {
7945 7965 static const char* argumentList[] ={"" , "QTimerEvent*"};
7946 7966 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7947 7967 void* args[2] = {NULL, (void*)&arg__1};
7948 7968 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7949 7969 if (result) { Py_DECREF(result); }
7950 7970 Py_DECREF(obj);
7951 7971 return;
7952 7972 } else {
7953 7973 PyErr_Clear();
7954 7974 }
7955 7975 }
7956 7976 elfInfoWdgt::timerEvent(arg__1);
7957 7977 }
7958 7978 void PythonQtShell_elfInfoWdgt::wheelEvent(QWheelEvent* arg__1)
7959 7979 {
7960 7980 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7961 7981 static PyObject* name = PyString_FromString("wheelEvent");
7962 7982 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7963 7983 if (obj) {
7964 7984 static const char* argumentList[] ={"" , "QWheelEvent*"};
7965 7985 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7966 7986 void* args[2] = {NULL, (void*)&arg__1};
7967 7987 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7968 7988 if (result) { Py_DECREF(result); }
7969 7989 Py_DECREF(obj);
7970 7990 return;
7971 7991 } else {
7972 7992 PyErr_Clear();
7973 7993 }
7974 7994 }
7975 7995 elfInfoWdgt::wheelEvent(arg__1);
7976 7996 }
7977 7997 elfInfoWdgt* PythonQtWrapper_elfInfoWdgt::new_elfInfoWdgt(QWidget* parent)
7978 7998 {
7979 7999 return new PythonQtShell_elfInfoWdgt(parent); }
7980 8000
7981 8001
7982 8002
7983 8003 elfparser* PythonQtWrapper_elfparser::new_elfparser()
7984 8004 {
7985 8005 return new elfparser(); }
7986 8006
7987 8007 int PythonQtWrapper_elfparser::closeFile(elfparser* theWrappedObject)
7988 8008 {
7989 8009 return ( theWrappedObject->closeFile());
7990 8010 }
7991 8011
7992 8012 QString PythonQtWrapper_elfparser::getABI(elfparser* theWrappedObject)
7993 8013 {
7994 8014 return ( theWrappedObject->getABI());
7995 8015 }
7996 8016
7997 8017 QString PythonQtWrapper_elfparser::getArchitecture(elfparser* theWrappedObject)
7998 8018 {
7999 8019 return ( theWrappedObject->getArchitecture());
8000 8020 }
8001 8021
8002 8022 QString PythonQtWrapper_elfparser::getClass(elfparser* theWrappedObject)
8003 8023 {
8004 8024 return ( theWrappedObject->getClass());
8005 8025 }
8006 8026
8007 8027 QString PythonQtWrapper_elfparser::getEndianness(elfparser* theWrappedObject)
8008 8028 {
8009 8029 return ( theWrappedObject->getEndianness());
8010 8030 }
8011 8031
8012 8032 qint64 PythonQtWrapper_elfparser::getEntryPointAddress(elfparser* theWrappedObject)
8013 8033 {
8014 8034 return ( theWrappedObject->getEntryPointAddress());
8015 8035 }
8016 8036
8017 8037 bool PythonQtWrapper_elfparser::getSectionData(elfparser* theWrappedObject, int index, char** buffer)
8018 8038 {
8019 8039 return ( theWrappedObject->getSectionData(index, buffer));
8020 8040 }
8021 8041
8022 8042 qint64 PythonQtWrapper_elfparser::getSectionDatasz(elfparser* theWrappedObject, int index)
8023 8043 {
8024 8044 return ( theWrappedObject->getSectionDatasz(index));
8025 8045 }
8026 8046
8027 8047 qint64 PythonQtWrapper_elfparser::getSectionMemsz(elfparser* theWrappedObject, int index)
8028 8048 {
8029 8049 return ( theWrappedObject->getSectionMemsz(index));
8030 8050 }
8031 8051
8032 8052 QString PythonQtWrapper_elfparser::getSectionName(elfparser* theWrappedObject, int index)
8033 8053 {
8034 8054 return ( theWrappedObject->getSectionName(index));
8035 8055 }
8036 8056
8037 8057 qint64 PythonQtWrapper_elfparser::getSectionPaddr(elfparser* theWrappedObject, int index)
8038 8058 {
8039 8059 return ( theWrappedObject->getSectionPaddr(index));
8040 8060 }
8041 8061
8042 8062 QString PythonQtWrapper_elfparser::getSectionType(elfparser* theWrappedObject, int index)
8043 8063 {
8044 8064 return ( theWrappedObject->getSectionType(index));
8045 8065 }
8046 8066
8047 8067 int PythonQtWrapper_elfparser::getSectioncount(elfparser* theWrappedObject)
8048 8068 {
8049 8069 return ( theWrappedObject->getSectioncount());
8050 8070 }
8051 8071
8052 8072 qint64 PythonQtWrapper_elfparser::getSegmentFilesz(elfparser* theWrappedObject, int index)
8053 8073 {
8054 8074 return ( theWrappedObject->getSegmentFilesz(index));
8055 8075 }
8056 8076
8057 8077 QString PythonQtWrapper_elfparser::getSegmentFlags(elfparser* theWrappedObject, int index)
8058 8078 {
8059 8079 return ( theWrappedObject->getSegmentFlags(index));
8060 8080 }
8061 8081
8062 8082 qint64 PythonQtWrapper_elfparser::getSegmentMemsz(elfparser* theWrappedObject, int index)
8063 8083 {
8064 8084 return ( theWrappedObject->getSegmentMemsz(index));
8065 8085 }
8066 8086
8067 8087 qint64 PythonQtWrapper_elfparser::getSegmentOffset(elfparser* theWrappedObject, int index)
8068 8088 {
8069 8089 return ( theWrappedObject->getSegmentOffset(index));
8070 8090 }
8071 8091
8072 8092 qint64 PythonQtWrapper_elfparser::getSegmentPaddr(elfparser* theWrappedObject, int index)
8073 8093 {
8074 8094 return ( theWrappedObject->getSegmentPaddr(index));
8075 8095 }
8076 8096
8077 8097 QString PythonQtWrapper_elfparser::getSegmentType(elfparser* theWrappedObject, int index)
8078 8098 {
8079 8099 return ( theWrappedObject->getSegmentType(index));
8080 8100 }
8081 8101
8082 8102 qint64 PythonQtWrapper_elfparser::getSegmentVaddr(elfparser* theWrappedObject, int index)
8083 8103 {
8084 8104 return ( theWrappedObject->getSegmentVaddr(index));
8085 8105 }
8086 8106
8087 8107 int PythonQtWrapper_elfparser::getSegmentcount(elfparser* theWrappedObject)
8088 8108 {
8089 8109 return ( theWrappedObject->getSegmentcount());
8090 8110 }
8091 8111
8092 8112 QString PythonQtWrapper_elfparser::getType(elfparser* theWrappedObject)
8093 8113 {
8094 8114 return ( theWrappedObject->getType());
8095 8115 }
8096 8116
8097 8117 qint64 PythonQtWrapper_elfparser::getVersion(elfparser* theWrappedObject)
8098 8118 {
8099 8119 return ( theWrappedObject->getVersion());
8100 8120 }
8101 8121
8102 8122 bool PythonQtWrapper_elfparser::static_elfparser_isElf(const QString& File)
8103 8123 {
8104 8124 return (elfparser::isElf(File));
8105 8125 }
8106 8126
8107 8127 bool PythonQtWrapper_elfparser::iself(elfparser* theWrappedObject)
8108 8128 {
8109 8129 return ( theWrappedObject->iself());
8110 8130 }
8111 8131
8112 8132 bool PythonQtWrapper_elfparser::isopened(elfparser* theWrappedObject)
8113 8133 {
8114 8134 return ( theWrappedObject->isopened());
8115 8135 }
8116 8136
8117 8137 int PythonQtWrapper_elfparser::setFilename(elfparser* theWrappedObject, const QString& name)
8118 8138 {
8119 8139 return ( theWrappedObject->setFilename(name));
8120 8140 }
8121 8141
8122 8142
8123 8143
8124 8144 PythonQtShell_genericBinaryFileWidget::~PythonQtShell_genericBinaryFileWidget() {
8125 8145 PythonQtPrivate* priv = PythonQt::priv();
8126 8146 if (priv) { priv->shellClassDeleted(this); }
8127 8147 }
8128 8148 void PythonQtShell_genericBinaryFileWidget::actionEvent(QActionEvent* arg__1)
8129 8149 {
8130 8150 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8131 8151 static PyObject* name = PyString_FromString("actionEvent");
8132 8152 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8133 8153 if (obj) {
8134 8154 static const char* argumentList[] ={"" , "QActionEvent*"};
8135 8155 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8136 8156 void* args[2] = {NULL, (void*)&arg__1};
8137 8157 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8138 8158 if (result) { Py_DECREF(result); }
8139 8159 Py_DECREF(obj);
8140 8160 return;
8141 8161 } else {
8142 8162 PyErr_Clear();
8143 8163 }
8144 8164 }
8145 8165 genericBinaryFileWidget::actionEvent(arg__1);
8146 8166 }
8147 8167 void PythonQtShell_genericBinaryFileWidget::changeEvent(QEvent* arg__1)
8148 8168 {
8149 8169 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8150 8170 static PyObject* name = PyString_FromString("changeEvent");
8151 8171 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8152 8172 if (obj) {
8153 8173 static const char* argumentList[] ={"" , "QEvent*"};
8154 8174 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8155 8175 void* args[2] = {NULL, (void*)&arg__1};
8156 8176 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8157 8177 if (result) { Py_DECREF(result); }
8158 8178 Py_DECREF(obj);
8159 8179 return;
8160 8180 } else {
8161 8181 PyErr_Clear();
8162 8182 }
8163 8183 }
8164 8184 genericBinaryFileWidget::changeEvent(arg__1);
8165 8185 }
8166 8186 void PythonQtShell_genericBinaryFileWidget::childEvent(QChildEvent* arg__1)
8167 8187 {
8168 8188 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8169 8189 static PyObject* name = PyString_FromString("childEvent");
8170 8190 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8171 8191 if (obj) {
8172 8192 static const char* argumentList[] ={"" , "QChildEvent*"};
8173 8193 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8174 8194 void* args[2] = {NULL, (void*)&arg__1};
8175 8195 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8176 8196 if (result) { Py_DECREF(result); }
8177 8197 Py_DECREF(obj);
8178 8198 return;
8179 8199 } else {
8180 8200 PyErr_Clear();
8181 8201 }
8182 8202 }
8183 8203 genericBinaryFileWidget::childEvent(arg__1);
8184 8204 }
8185 8205 void PythonQtShell_genericBinaryFileWidget::closeEvent(QCloseEvent* arg__1)
8186 8206 {
8187 8207 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8188 8208 static PyObject* name = PyString_FromString("closeEvent");
8189 8209 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8190 8210 if (obj) {
8191 8211 static const char* argumentList[] ={"" , "QCloseEvent*"};
8192 8212 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8193 8213 void* args[2] = {NULL, (void*)&arg__1};
8194 8214 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8195 8215 if (result) { Py_DECREF(result); }
8196 8216 Py_DECREF(obj);
8197 8217 return;
8198 8218 } else {
8199 8219 PyErr_Clear();
8200 8220 }
8201 8221 }
8202 8222 genericBinaryFileWidget::closeEvent(arg__1);
8203 8223 }
8204 8224 void PythonQtShell_genericBinaryFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
8205 8225 {
8206 8226 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8207 8227 static PyObject* name = PyString_FromString("contextMenuEvent");
8208 8228 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8209 8229 if (obj) {
8210 8230 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
8211 8231 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8212 8232 void* args[2] = {NULL, (void*)&arg__1};
8213 8233 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8214 8234 if (result) { Py_DECREF(result); }
8215 8235 Py_DECREF(obj);
8216 8236 return;
8217 8237 } else {
8218 8238 PyErr_Clear();
8219 8239 }
8220 8240 }
8221 8241 genericBinaryFileWidget::contextMenuEvent(arg__1);
8222 8242 }
8223 8243 void PythonQtShell_genericBinaryFileWidget::customEvent(QEvent* arg__1)
8224 8244 {
8225 8245 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8226 8246 static PyObject* name = PyString_FromString("customEvent");
8227 8247 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8228 8248 if (obj) {
8229 8249 static const char* argumentList[] ={"" , "QEvent*"};
8230 8250 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8231 8251 void* args[2] = {NULL, (void*)&arg__1};
8232 8252 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8233 8253 if (result) { Py_DECREF(result); }
8234 8254 Py_DECREF(obj);
8235 8255 return;
8236 8256 } else {
8237 8257 PyErr_Clear();
8238 8258 }
8239 8259 }
8240 8260 genericBinaryFileWidget::customEvent(arg__1);
8241 8261 }
8242 8262 int PythonQtShell_genericBinaryFileWidget::devType() const
8243 8263 {
8244 8264 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8245 8265 static PyObject* name = PyString_FromString("devType");
8246 8266 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8247 8267 if (obj) {
8248 8268 static const char* argumentList[] ={"int"};
8249 8269 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8250 8270 int returnValue;
8251 8271 void* args[1] = {NULL};
8252 8272 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8253 8273 if (result) {
8254 8274 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8255 8275 if (args[0]!=&returnValue) {
8256 8276 if (args[0]==NULL) {
8257 8277 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
8258 8278 } else {
8259 8279 returnValue = *((int*)args[0]);
8260 8280 }
8261 8281 }
8262 8282 }
8263 8283 if (result) { Py_DECREF(result); }
8264 8284 Py_DECREF(obj);
8265 8285 return returnValue;
8266 8286 } else {
8267 8287 PyErr_Clear();
8268 8288 }
8269 8289 }
8270 8290 return genericBinaryFileWidget::devType();
8271 8291 }
8272 8292 void PythonQtShell_genericBinaryFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
8273 8293 {
8274 8294 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8275 8295 static PyObject* name = PyString_FromString("dragEnterEvent");
8276 8296 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8277 8297 if (obj) {
8278 8298 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
8279 8299 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8280 8300 void* args[2] = {NULL, (void*)&arg__1};
8281 8301 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8282 8302 if (result) { Py_DECREF(result); }
8283 8303 Py_DECREF(obj);
8284 8304 return;
8285 8305 } else {
8286 8306 PyErr_Clear();
8287 8307 }
8288 8308 }
8289 8309 genericBinaryFileWidget::dragEnterEvent(arg__1);
8290 8310 }
8291 8311 void PythonQtShell_genericBinaryFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
8292 8312 {
8293 8313 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8294 8314 static PyObject* name = PyString_FromString("dragLeaveEvent");
8295 8315 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8296 8316 if (obj) {
8297 8317 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
8298 8318 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8299 8319 void* args[2] = {NULL, (void*)&arg__1};
8300 8320 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8301 8321 if (result) { Py_DECREF(result); }
8302 8322 Py_DECREF(obj);
8303 8323 return;
8304 8324 } else {
8305 8325 PyErr_Clear();
8306 8326 }
8307 8327 }
8308 8328 genericBinaryFileWidget::dragLeaveEvent(arg__1);
8309 8329 }
8310 8330 void PythonQtShell_genericBinaryFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
8311 8331 {
8312 8332 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8313 8333 static PyObject* name = PyString_FromString("dragMoveEvent");
8314 8334 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8315 8335 if (obj) {
8316 8336 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
8317 8337 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8318 8338 void* args[2] = {NULL, (void*)&arg__1};
8319 8339 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8320 8340 if (result) { Py_DECREF(result); }
8321 8341 Py_DECREF(obj);
8322 8342 return;
8323 8343 } else {
8324 8344 PyErr_Clear();
8325 8345 }
8326 8346 }
8327 8347 genericBinaryFileWidget::dragMoveEvent(arg__1);
8328 8348 }
8329 8349 void PythonQtShell_genericBinaryFileWidget::dropEvent(QDropEvent* arg__1)
8330 8350 {
8331 8351 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8332 8352 static PyObject* name = PyString_FromString("dropEvent");
8333 8353 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8334 8354 if (obj) {
8335 8355 static const char* argumentList[] ={"" , "QDropEvent*"};
8336 8356 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8337 8357 void* args[2] = {NULL, (void*)&arg__1};
8338 8358 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8339 8359 if (result) { Py_DECREF(result); }
8340 8360 Py_DECREF(obj);
8341 8361 return;
8342 8362 } else {
8343 8363 PyErr_Clear();
8344 8364 }
8345 8365 }
8346 8366 genericBinaryFileWidget::dropEvent(arg__1);
8347 8367 }
8348 8368 void PythonQtShell_genericBinaryFileWidget::enterEvent(QEvent* arg__1)
8349 8369 {
8350 8370 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8351 8371 static PyObject* name = PyString_FromString("enterEvent");
8352 8372 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8353 8373 if (obj) {
8354 8374 static const char* argumentList[] ={"" , "QEvent*"};
8355 8375 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8356 8376 void* args[2] = {NULL, (void*)&arg__1};
8357 8377 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8358 8378 if (result) { Py_DECREF(result); }
8359 8379 Py_DECREF(obj);
8360 8380 return;
8361 8381 } else {
8362 8382 PyErr_Clear();
8363 8383 }
8364 8384 }
8365 8385 genericBinaryFileWidget::enterEvent(arg__1);
8366 8386 }
8367 8387 bool PythonQtShell_genericBinaryFileWidget::event(QEvent* arg__1)
8368 8388 {
8369 8389 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8370 8390 static PyObject* name = PyString_FromString("event");
8371 8391 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8372 8392 if (obj) {
8373 8393 static const char* argumentList[] ={"bool" , "QEvent*"};
8374 8394 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8375 8395 bool returnValue;
8376 8396 void* args[2] = {NULL, (void*)&arg__1};
8377 8397 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8378 8398 if (result) {
8379 8399 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8380 8400 if (args[0]!=&returnValue) {
8381 8401 if (args[0]==NULL) {
8382 8402 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
8383 8403 } else {
8384 8404 returnValue = *((bool*)args[0]);
8385 8405 }
8386 8406 }
8387 8407 }
8388 8408 if (result) { Py_DECREF(result); }
8389 8409 Py_DECREF(obj);
8390 8410 return returnValue;
8391 8411 } else {
8392 8412 PyErr_Clear();
8393 8413 }
8394 8414 }
8395 8415 return genericBinaryFileWidget::event(arg__1);
8396 8416 }
8397 8417 bool PythonQtShell_genericBinaryFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
8398 8418 {
8399 8419 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8400 8420 static PyObject* name = PyString_FromString("eventFilter");
8401 8421 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8402 8422 if (obj) {
8403 8423 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
8404 8424 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
8405 8425 bool returnValue;
8406 8426 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
8407 8427 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8408 8428 if (result) {
8409 8429 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8410 8430 if (args[0]!=&returnValue) {
8411 8431 if (args[0]==NULL) {
8412 8432 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
8413 8433 } else {
8414 8434 returnValue = *((bool*)args[0]);
8415 8435 }
8416 8436 }
8417 8437 }
8418 8438 if (result) { Py_DECREF(result); }
8419 8439 Py_DECREF(obj);
8420 8440 return returnValue;
8421 8441 } else {
8422 8442 PyErr_Clear();
8423 8443 }
8424 8444 }
8425 8445 return genericBinaryFileWidget::eventFilter(arg__1, arg__2);
8426 8446 }
8427 8447 void PythonQtShell_genericBinaryFileWidget::focusInEvent(QFocusEvent* arg__1)
8428 8448 {
8429 8449 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8430 8450 static PyObject* name = PyString_FromString("focusInEvent");
8431 8451 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8432 8452 if (obj) {
8433 8453 static const char* argumentList[] ={"" , "QFocusEvent*"};
8434 8454 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8435 8455 void* args[2] = {NULL, (void*)&arg__1};
8436 8456 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8437 8457 if (result) { Py_DECREF(result); }
8438 8458 Py_DECREF(obj);
8439 8459 return;
8440 8460 } else {
8441 8461 PyErr_Clear();
8442 8462 }
8443 8463 }
8444 8464 genericBinaryFileWidget::focusInEvent(arg__1);
8445 8465 }
8446 8466 bool PythonQtShell_genericBinaryFileWidget::focusNextPrevChild(bool next0)
8447 8467 {
8448 8468 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8449 8469 static PyObject* name = PyString_FromString("focusNextPrevChild");
8450 8470 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8451 8471 if (obj) {
8452 8472 static const char* argumentList[] ={"bool" , "bool"};
8453 8473 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8454 8474 bool returnValue;
8455 8475 void* args[2] = {NULL, (void*)&next0};
8456 8476 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8457 8477 if (result) {
8458 8478 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8459 8479 if (args[0]!=&returnValue) {
8460 8480 if (args[0]==NULL) {
8461 8481 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
8462 8482 } else {
8463 8483 returnValue = *((bool*)args[0]);
8464 8484 }
8465 8485 }
8466 8486 }
8467 8487 if (result) { Py_DECREF(result); }
8468 8488 Py_DECREF(obj);
8469 8489 return returnValue;
8470 8490 } else {
8471 8491 PyErr_Clear();
8472 8492 }
8473 8493 }
8474 8494 return genericBinaryFileWidget::focusNextPrevChild(next0);
8475 8495 }
8476 8496 void PythonQtShell_genericBinaryFileWidget::focusOutEvent(QFocusEvent* arg__1)
8477 8497 {
8478 8498 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8479 8499 static PyObject* name = PyString_FromString("focusOutEvent");
8480 8500 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8481 8501 if (obj) {
8482 8502 static const char* argumentList[] ={"" , "QFocusEvent*"};
8483 8503 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8484 8504 void* args[2] = {NULL, (void*)&arg__1};
8485 8505 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8486 8506 if (result) { Py_DECREF(result); }
8487 8507 Py_DECREF(obj);
8488 8508 return;
8489 8509 } else {
8490 8510 PyErr_Clear();
8491 8511 }
8492 8512 }
8493 8513 genericBinaryFileWidget::focusOutEvent(arg__1);
8494 8514 }
8495 8515 bool PythonQtShell_genericBinaryFileWidget::hasHeightForWidth() const
8496 8516 {
8497 8517 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8498 8518 static PyObject* name = PyString_FromString("hasHeightForWidth");
8499 8519 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8500 8520 if (obj) {
8501 8521 static const char* argumentList[] ={"bool"};
8502 8522 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8503 8523 bool returnValue;
8504 8524 void* args[1] = {NULL};
8505 8525 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8506 8526 if (result) {
8507 8527 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8508 8528 if (args[0]!=&returnValue) {
8509 8529 if (args[0]==NULL) {
8510 8530 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
8511 8531 } else {
8512 8532 returnValue = *((bool*)args[0]);
8513 8533 }
8514 8534 }
8515 8535 }
8516 8536 if (result) { Py_DECREF(result); }
8517 8537 Py_DECREF(obj);
8518 8538 return returnValue;
8519 8539 } else {
8520 8540 PyErr_Clear();
8521 8541 }
8522 8542 }
8523 8543 return genericBinaryFileWidget::hasHeightForWidth();
8524 8544 }
8525 8545 int PythonQtShell_genericBinaryFileWidget::heightForWidth(int arg__1) const
8526 8546 {
8527 8547 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8528 8548 static PyObject* name = PyString_FromString("heightForWidth");
8529 8549 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8530 8550 if (obj) {
8531 8551 static const char* argumentList[] ={"int" , "int"};
8532 8552 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8533 8553 int returnValue;
8534 8554 void* args[2] = {NULL, (void*)&arg__1};
8535 8555 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8536 8556 if (result) {
8537 8557 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8538 8558 if (args[0]!=&returnValue) {
8539 8559 if (args[0]==NULL) {
8540 8560 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
8541 8561 } else {
8542 8562 returnValue = *((int*)args[0]);
8543 8563 }
8544 8564 }
8545 8565 }
8546 8566 if (result) { Py_DECREF(result); }
8547 8567 Py_DECREF(obj);
8548 8568 return returnValue;
8549 8569 } else {
8550 8570 PyErr_Clear();
8551 8571 }
8552 8572 }
8553 8573 return genericBinaryFileWidget::heightForWidth(arg__1);
8554 8574 }
8555 8575 void PythonQtShell_genericBinaryFileWidget::hideEvent(QHideEvent* arg__1)
8556 8576 {
8557 8577 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8558 8578 static PyObject* name = PyString_FromString("hideEvent");
8559 8579 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8560 8580 if (obj) {
8561 8581 static const char* argumentList[] ={"" , "QHideEvent*"};
8562 8582 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8563 8583 void* args[2] = {NULL, (void*)&arg__1};
8564 8584 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8565 8585 if (result) { Py_DECREF(result); }
8566 8586 Py_DECREF(obj);
8567 8587 return;
8568 8588 } else {
8569 8589 PyErr_Clear();
8570 8590 }
8571 8591 }
8572 8592 genericBinaryFileWidget::hideEvent(arg__1);
8573 8593 }
8574 8594 void PythonQtShell_genericBinaryFileWidget::initPainter(QPainter* painter0) const
8575 8595 {
8576 8596 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8577 8597 static PyObject* name = PyString_FromString("initPainter");
8578 8598 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8579 8599 if (obj) {
8580 8600 static const char* argumentList[] ={"" , "QPainter*"};
8581 8601 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8582 8602 void* args[2] = {NULL, (void*)&painter0};
8583 8603 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8584 8604 if (result) { Py_DECREF(result); }
8585 8605 Py_DECREF(obj);
8586 8606 return;
8587 8607 } else {
8588 8608 PyErr_Clear();
8589 8609 }
8590 8610 }
8591 8611 genericBinaryFileWidget::initPainter(painter0);
8592 8612 }
8593 8613 void PythonQtShell_genericBinaryFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
8594 8614 {
8595 8615 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8596 8616 static PyObject* name = PyString_FromString("inputMethodEvent");
8597 8617 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8598 8618 if (obj) {
8599 8619 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
8600 8620 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8601 8621 void* args[2] = {NULL, (void*)&arg__1};
8602 8622 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8603 8623 if (result) { Py_DECREF(result); }
8604 8624 Py_DECREF(obj);
8605 8625 return;
8606 8626 } else {
8607 8627 PyErr_Clear();
8608 8628 }
8609 8629 }
8610 8630 genericBinaryFileWidget::inputMethodEvent(arg__1);
8611 8631 }
8612 8632 QVariant PythonQtShell_genericBinaryFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
8613 8633 {
8614 8634 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8615 8635 static PyObject* name = PyString_FromString("inputMethodQuery");
8616 8636 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8617 8637 if (obj) {
8618 8638 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
8619 8639 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8620 8640 QVariant returnValue;
8621 8641 void* args[2] = {NULL, (void*)&arg__1};
8622 8642 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8623 8643 if (result) {
8624 8644 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8625 8645 if (args[0]!=&returnValue) {
8626 8646 if (args[0]==NULL) {
8627 8647 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
8628 8648 } else {
8629 8649 returnValue = *((QVariant*)args[0]);
8630 8650 }
8631 8651 }
8632 8652 }
8633 8653 if (result) { Py_DECREF(result); }
8634 8654 Py_DECREF(obj);
8635 8655 return returnValue;
8636 8656 } else {
8637 8657 PyErr_Clear();
8638 8658 }
8639 8659 }
8640 8660 return genericBinaryFileWidget::inputMethodQuery(arg__1);
8641 8661 }
8642 8662 void PythonQtShell_genericBinaryFileWidget::keyPressEvent(QKeyEvent* arg__1)
8643 8663 {
8644 8664 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8645 8665 static PyObject* name = PyString_FromString("keyPressEvent");
8646 8666 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8647 8667 if (obj) {
8648 8668 static const char* argumentList[] ={"" , "QKeyEvent*"};
8649 8669 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8650 8670 void* args[2] = {NULL, (void*)&arg__1};
8651 8671 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8652 8672 if (result) { Py_DECREF(result); }
8653 8673 Py_DECREF(obj);
8654 8674 return;
8655 8675 } else {
8656 8676 PyErr_Clear();
8657 8677 }
8658 8678 }
8659 8679 genericBinaryFileWidget::keyPressEvent(arg__1);
8660 8680 }
8661 8681 void PythonQtShell_genericBinaryFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
8662 8682 {
8663 8683 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8664 8684 static PyObject* name = PyString_FromString("keyReleaseEvent");
8665 8685 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8666 8686 if (obj) {
8667 8687 static const char* argumentList[] ={"" , "QKeyEvent*"};
8668 8688 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8669 8689 void* args[2] = {NULL, (void*)&arg__1};
8670 8690 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8671 8691 if (result) { Py_DECREF(result); }
8672 8692 Py_DECREF(obj);
8673 8693 return;
8674 8694 } else {
8675 8695 PyErr_Clear();
8676 8696 }
8677 8697 }
8678 8698 genericBinaryFileWidget::keyReleaseEvent(arg__1);
8679 8699 }
8680 8700 void PythonQtShell_genericBinaryFileWidget::leaveEvent(QEvent* arg__1)
8681 8701 {
8682 8702 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8683 8703 static PyObject* name = PyString_FromString("leaveEvent");
8684 8704 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8685 8705 if (obj) {
8686 8706 static const char* argumentList[] ={"" , "QEvent*"};
8687 8707 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8688 8708 void* args[2] = {NULL, (void*)&arg__1};
8689 8709 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8690 8710 if (result) { Py_DECREF(result); }
8691 8711 Py_DECREF(obj);
8692 8712 return;
8693 8713 } else {
8694 8714 PyErr_Clear();
8695 8715 }
8696 8716 }
8697 8717 genericBinaryFileWidget::leaveEvent(arg__1);
8698 8718 }
8699 8719 int PythonQtShell_genericBinaryFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
8700 8720 {
8701 8721 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8702 8722 static PyObject* name = PyString_FromString("metric");
8703 8723 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8704 8724 if (obj) {
8705 8725 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
8706 8726 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8707 8727 int returnValue;
8708 8728 void* args[2] = {NULL, (void*)&arg__1};
8709 8729 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8710 8730 if (result) {
8711 8731 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8712 8732 if (args[0]!=&returnValue) {
8713 8733 if (args[0]==NULL) {
8714 8734 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
8715 8735 } else {
8716 8736 returnValue = *((int*)args[0]);
8717 8737 }
8718 8738 }
8719 8739 }
8720 8740 if (result) { Py_DECREF(result); }
8721 8741 Py_DECREF(obj);
8722 8742 return returnValue;
8723 8743 } else {
8724 8744 PyErr_Clear();
8725 8745 }
8726 8746 }
8727 8747 return genericBinaryFileWidget::metric(arg__1);
8728 8748 }
8729 8749 QSize PythonQtShell_genericBinaryFileWidget::minimumSizeHint() const
8730 8750 {
8731 8751 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8732 8752 static PyObject* name = PyString_FromString("getMinimumSizeHint");
8733 8753 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8734 8754 if (obj) {
8735 8755 static const char* argumentList[] ={"QSize"};
8736 8756 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8737 8757 QSize returnValue;
8738 8758 void* args[1] = {NULL};
8739 8759 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8740 8760 if (result) {
8741 8761 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8742 8762 if (args[0]!=&returnValue) {
8743 8763 if (args[0]==NULL) {
8744 8764 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
8745 8765 } else {
8746 8766 returnValue = *((QSize*)args[0]);
8747 8767 }
8748 8768 }
8749 8769 }
8750 8770 if (result) { Py_DECREF(result); }
8751 8771 Py_DECREF(obj);
8752 8772 return returnValue;
8753 8773 } else {
8754 8774 PyErr_Clear();
8755 8775 }
8756 8776 }
8757 8777 return genericBinaryFileWidget::minimumSizeHint();
8758 8778 }
8759 8779 void PythonQtShell_genericBinaryFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
8760 8780 {
8761 8781 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8762 8782 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
8763 8783 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8764 8784 if (obj) {
8765 8785 static const char* argumentList[] ={"" , "QMouseEvent*"};
8766 8786 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8767 8787 void* args[2] = {NULL, (void*)&arg__1};
8768 8788 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8769 8789 if (result) { Py_DECREF(result); }
8770 8790 Py_DECREF(obj);
8771 8791 return;
8772 8792 } else {
8773 8793 PyErr_Clear();
8774 8794 }
8775 8795 }
8776 8796 genericBinaryFileWidget::mouseDoubleClickEvent(arg__1);
8777 8797 }
8778 8798 void PythonQtShell_genericBinaryFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
8779 8799 {
8780 8800 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8781 8801 static PyObject* name = PyString_FromString("mouseMoveEvent");
8782 8802 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8783 8803 if (obj) {
8784 8804 static const char* argumentList[] ={"" , "QMouseEvent*"};
8785 8805 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8786 8806 void* args[2] = {NULL, (void*)&arg__1};
8787 8807 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8788 8808 if (result) { Py_DECREF(result); }
8789 8809 Py_DECREF(obj);
8790 8810 return;
8791 8811 } else {
8792 8812 PyErr_Clear();
8793 8813 }
8794 8814 }
8795 8815 genericBinaryFileWidget::mouseMoveEvent(arg__1);
8796 8816 }
8797 8817 void PythonQtShell_genericBinaryFileWidget::mousePressEvent(QMouseEvent* arg__1)
8798 8818 {
8799 8819 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8800 8820 static PyObject* name = PyString_FromString("mousePressEvent");
8801 8821 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8802 8822 if (obj) {
8803 8823 static const char* argumentList[] ={"" , "QMouseEvent*"};
8804 8824 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8805 8825 void* args[2] = {NULL, (void*)&arg__1};
8806 8826 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8807 8827 if (result) { Py_DECREF(result); }
8808 8828 Py_DECREF(obj);
8809 8829 return;
8810 8830 } else {
8811 8831 PyErr_Clear();
8812 8832 }
8813 8833 }
8814 8834 genericBinaryFileWidget::mousePressEvent(arg__1);
8815 8835 }
8816 8836 void PythonQtShell_genericBinaryFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
8817 8837 {
8818 8838 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8819 8839 static PyObject* name = PyString_FromString("mouseReleaseEvent");
8820 8840 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8821 8841 if (obj) {
8822 8842 static const char* argumentList[] ={"" , "QMouseEvent*"};
8823 8843 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8824 8844 void* args[2] = {NULL, (void*)&arg__1};
8825 8845 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8826 8846 if (result) { Py_DECREF(result); }
8827 8847 Py_DECREF(obj);
8828 8848 return;
8829 8849 } else {
8830 8850 PyErr_Clear();
8831 8851 }
8832 8852 }
8833 8853 genericBinaryFileWidget::mouseReleaseEvent(arg__1);
8834 8854 }
8835 8855 void PythonQtShell_genericBinaryFileWidget::moveEvent(QMoveEvent* arg__1)
8836 8856 {
8837 8857 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8838 8858 static PyObject* name = PyString_FromString("moveEvent");
8839 8859 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8840 8860 if (obj) {
8841 8861 static const char* argumentList[] ={"" , "QMoveEvent*"};
8842 8862 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8843 8863 void* args[2] = {NULL, (void*)&arg__1};
8844 8864 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8845 8865 if (result) { Py_DECREF(result); }
8846 8866 Py_DECREF(obj);
8847 8867 return;
8848 8868 } else {
8849 8869 PyErr_Clear();
8850 8870 }
8851 8871 }
8852 8872 genericBinaryFileWidget::moveEvent(arg__1);
8853 8873 }
8854 8874 bool PythonQtShell_genericBinaryFileWidget::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
8855 8875 {
8856 8876 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8857 8877 static PyObject* name = PyString_FromString("nativeEvent");
8858 8878 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8859 8879 if (obj) {
8860 8880 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
8861 8881 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
8862 8882 bool returnValue;
8863 8883 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
8864 8884 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8865 8885 if (result) {
8866 8886 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8867 8887 if (args[0]!=&returnValue) {
8868 8888 if (args[0]==NULL) {
8869 8889 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
8870 8890 } else {
8871 8891 returnValue = *((bool*)args[0]);
8872 8892 }
8873 8893 }
8874 8894 }
8875 8895 if (result) { Py_DECREF(result); }
8876 8896 Py_DECREF(obj);
8877 8897 return returnValue;
8878 8898 } else {
8879 8899 PyErr_Clear();
8880 8900 }
8881 8901 }
8882 8902 return genericBinaryFileWidget::nativeEvent(eventType0, message1, result2);
8883 8903 }
8884 8904 QPaintEngine* PythonQtShell_genericBinaryFileWidget::paintEngine() const
8885 8905 {
8886 8906 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8887 8907 static PyObject* name = PyString_FromString("paintEngine");
8888 8908 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8889 8909 if (obj) {
8890 8910 static const char* argumentList[] ={"QPaintEngine*"};
8891 8911 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8892 8912 QPaintEngine* returnValue;
8893 8913 void* args[1] = {NULL};
8894 8914 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8895 8915 if (result) {
8896 8916 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8897 8917 if (args[0]!=&returnValue) {
8898 8918 if (args[0]==NULL) {
8899 8919 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
8900 8920 } else {
8901 8921 returnValue = *((QPaintEngine**)args[0]);
8902 8922 }
8903 8923 }
8904 8924 }
8905 8925 if (result) { Py_DECREF(result); }
8906 8926 Py_DECREF(obj);
8907 8927 return returnValue;
8908 8928 } else {
8909 8929 PyErr_Clear();
8910 8930 }
8911 8931 }
8912 8932 return genericBinaryFileWidget::paintEngine();
8913 8933 }
8914 8934 void PythonQtShell_genericBinaryFileWidget::paintEvent(QPaintEvent* arg__1)
8915 8935 {
8916 8936 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8917 8937 static PyObject* name = PyString_FromString("paintEvent");
8918 8938 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8919 8939 if (obj) {
8920 8940 static const char* argumentList[] ={"" , "QPaintEvent*"};
8921 8941 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8922 8942 void* args[2] = {NULL, (void*)&arg__1};
8923 8943 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8924 8944 if (result) { Py_DECREF(result); }
8925 8945 Py_DECREF(obj);
8926 8946 return;
8927 8947 } else {
8928 8948 PyErr_Clear();
8929 8949 }
8930 8950 }
8931 8951 genericBinaryFileWidget::paintEvent(arg__1);
8932 8952 }
8933 8953 QPaintDevice* PythonQtShell_genericBinaryFileWidget::redirected(QPoint* offset0) const
8934 8954 {
8935 8955 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8936 8956 static PyObject* name = PyString_FromString("redirected");
8937 8957 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8938 8958 if (obj) {
8939 8959 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
8940 8960 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8941 8961 QPaintDevice* returnValue;
8942 8962 void* args[2] = {NULL, (void*)&offset0};
8943 8963 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8944 8964 if (result) {
8945 8965 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8946 8966 if (args[0]!=&returnValue) {
8947 8967 if (args[0]==NULL) {
8948 8968 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
8949 8969 } else {
8950 8970 returnValue = *((QPaintDevice**)args[0]);
8951 8971 }
8952 8972 }
8953 8973 }
8954 8974 if (result) { Py_DECREF(result); }
8955 8975 Py_DECREF(obj);
8956 8976 return returnValue;
8957 8977 } else {
8958 8978 PyErr_Clear();
8959 8979 }
8960 8980 }
8961 8981 return genericBinaryFileWidget::redirected(offset0);
8962 8982 }
8963 8983 void PythonQtShell_genericBinaryFileWidget::resizeEvent(QResizeEvent* arg__1)
8964 8984 {
8965 8985 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8966 8986 static PyObject* name = PyString_FromString("resizeEvent");
8967 8987 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8968 8988 if (obj) {
8969 8989 static const char* argumentList[] ={"" , "QResizeEvent*"};
8970 8990 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8971 8991 void* args[2] = {NULL, (void*)&arg__1};
8972 8992 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8973 8993 if (result) { Py_DECREF(result); }
8974 8994 Py_DECREF(obj);
8975 8995 return;
8976 8996 } else {
8977 8997 PyErr_Clear();
8978 8998 }
8979 8999 }
8980 9000 genericBinaryFileWidget::resizeEvent(arg__1);
8981 9001 }
8982 9002 QPainter* PythonQtShell_genericBinaryFileWidget::sharedPainter() const
8983 9003 {
8984 9004 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8985 9005 static PyObject* name = PyString_FromString("sharedPainter");
8986 9006 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8987 9007 if (obj) {
8988 9008 static const char* argumentList[] ={"QPainter*"};
8989 9009 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8990 9010 QPainter* returnValue;
8991 9011 void* args[1] = {NULL};
8992 9012 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8993 9013 if (result) {
8994 9014 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8995 9015 if (args[0]!=&returnValue) {
8996 9016 if (args[0]==NULL) {
8997 9017 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
8998 9018 } else {
8999 9019 returnValue = *((QPainter**)args[0]);
9000 9020 }
9001 9021 }
9002 9022 }
9003 9023 if (result) { Py_DECREF(result); }
9004 9024 Py_DECREF(obj);
9005 9025 return returnValue;
9006 9026 } else {
9007 9027 PyErr_Clear();
9008 9028 }
9009 9029 }
9010 9030 return genericBinaryFileWidget::sharedPainter();
9011 9031 }
9012 9032 void PythonQtShell_genericBinaryFileWidget::showEvent(QShowEvent* arg__1)
9013 9033 {
9014 9034 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9015 9035 static PyObject* name = PyString_FromString("showEvent");
9016 9036 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9017 9037 if (obj) {
9018 9038 static const char* argumentList[] ={"" , "QShowEvent*"};
9019 9039 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9020 9040 void* args[2] = {NULL, (void*)&arg__1};
9021 9041 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9022 9042 if (result) { Py_DECREF(result); }
9023 9043 Py_DECREF(obj);
9024 9044 return;
9025 9045 } else {
9026 9046 PyErr_Clear();
9027 9047 }
9028 9048 }
9029 9049 genericBinaryFileWidget::showEvent(arg__1);
9030 9050 }
9031 9051 QSize PythonQtShell_genericBinaryFileWidget::sizeHint() const
9032 9052 {
9033 9053 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9034 9054 static PyObject* name = PyString_FromString("getSizeHint");
9035 9055 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9036 9056 if (obj) {
9037 9057 static const char* argumentList[] ={"QSize"};
9038 9058 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9039 9059 QSize returnValue;
9040 9060 void* args[1] = {NULL};
9041 9061 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9042 9062 if (result) {
9043 9063 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9044 9064 if (args[0]!=&returnValue) {
9045 9065 if (args[0]==NULL) {
9046 9066 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
9047 9067 } else {
9048 9068 returnValue = *((QSize*)args[0]);
9049 9069 }
9050 9070 }
9051 9071 }
9052 9072 if (result) { Py_DECREF(result); }
9053 9073 Py_DECREF(obj);
9054 9074 return returnValue;
9055 9075 } else {
9056 9076 PyErr_Clear();
9057 9077 }
9058 9078 }
9059 9079 return genericBinaryFileWidget::sizeHint();
9060 9080 }
9061 9081 void PythonQtShell_genericBinaryFileWidget::tabletEvent(QTabletEvent* arg__1)
9062 9082 {
9063 9083 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9064 9084 static PyObject* name = PyString_FromString("tabletEvent");
9065 9085 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9066 9086 if (obj) {
9067 9087 static const char* argumentList[] ={"" , "QTabletEvent*"};
9068 9088 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9069 9089 void* args[2] = {NULL, (void*)&arg__1};
9070 9090 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9071 9091 if (result) { Py_DECREF(result); }
9072 9092 Py_DECREF(obj);
9073 9093 return;
9074 9094 } else {
9075 9095 PyErr_Clear();
9076 9096 }
9077 9097 }
9078 9098 genericBinaryFileWidget::tabletEvent(arg__1);
9079 9099 }
9080 9100 void PythonQtShell_genericBinaryFileWidget::timerEvent(QTimerEvent* arg__1)
9081 9101 {
9082 9102 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9083 9103 static PyObject* name = PyString_FromString("timerEvent");
9084 9104 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9085 9105 if (obj) {
9086 9106 static const char* argumentList[] ={"" , "QTimerEvent*"};
9087 9107 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9088 9108 void* args[2] = {NULL, (void*)&arg__1};
9089 9109 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9090 9110 if (result) { Py_DECREF(result); }
9091 9111 Py_DECREF(obj);
9092 9112 return;
9093 9113 } else {
9094 9114 PyErr_Clear();
9095 9115 }
9096 9116 }
9097 9117 genericBinaryFileWidget::timerEvent(arg__1);
9098 9118 }
9099 9119 void PythonQtShell_genericBinaryFileWidget::wheelEvent(QWheelEvent* arg__1)
9100 9120 {
9101 9121 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9102 9122 static PyObject* name = PyString_FromString("wheelEvent");
9103 9123 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9104 9124 if (obj) {
9105 9125 static const char* argumentList[] ={"" , "QWheelEvent*"};
9106 9126 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9107 9127 void* args[2] = {NULL, (void*)&arg__1};
9108 9128 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9109 9129 if (result) { Py_DECREF(result); }
9110 9130 Py_DECREF(obj);
9111 9131 return;
9112 9132 } else {
9113 9133 PyErr_Clear();
9114 9134 }
9115 9135 }
9116 9136 genericBinaryFileWidget::wheelEvent(arg__1);
9117 9137 }
9118 9138 genericBinaryFileWidget* PythonQtWrapper_genericBinaryFileWidget::new_genericBinaryFileWidget(QWidget* parent)
9119 9139 {
9120 9140 return new PythonQtShell_genericBinaryFileWidget(parent); }
9121 9141
9122 9142
9123 9143
9124 9144 PythonQtShell_srecFile::~PythonQtShell_srecFile() {
9125 9145 PythonQtPrivate* priv = PythonQt::priv();
9126 9146 if (priv) { priv->shellClassDeleted(this); }
9127 9147 }
9128 9148 int PythonQtShell_srecFile::closeFile()
9129 9149 {
9130 9150 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9131 9151 static PyObject* name = PyString_FromString("closeFile");
9132 9152 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9133 9153 if (obj) {
9134 9154 static const char* argumentList[] ={"int"};
9135 9155 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9136 9156 int returnValue;
9137 9157 void* args[1] = {NULL};
9138 9158 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9139 9159 if (result) {
9140 9160 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9141 9161 if (args[0]!=&returnValue) {
9142 9162 if (args[0]==NULL) {
9143 9163 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
9144 9164 } else {
9145 9165 returnValue = *((int*)args[0]);
9146 9166 }
9147 9167 }
9148 9168 }
9149 9169 if (result) { Py_DECREF(result); }
9150 9170 Py_DECREF(obj);
9151 9171 return returnValue;
9152 9172 } else {
9153 9173 PyErr_Clear();
9154 9174 }
9155 9175 }
9156 9176 return srecFile::closeFile();
9157 9177 }
9158 9178 QList<codeFragment* > PythonQtShell_srecFile::getFragments()
9159 9179 {
9160 9180 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9161 9181 static PyObject* name = PyString_FromString("getFragments");
9162 9182 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9163 9183 if (obj) {
9164 9184 static const char* argumentList[] ={"QList<codeFragment* >"};
9165 9185 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9166 9186 QList<codeFragment* > returnValue;
9167 9187 void* args[1] = {NULL};
9168 9188 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9169 9189 if (result) {
9170 9190 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9171 9191 if (args[0]!=&returnValue) {
9172 9192 if (args[0]==NULL) {
9173 9193 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
9174 9194 } else {
9175 9195 returnValue = *((QList<codeFragment* >*)args[0]);
9176 9196 }
9177 9197 }
9178 9198 }
9179 9199 if (result) { Py_DECREF(result); }
9180 9200 Py_DECREF(obj);
9181 9201 return returnValue;
9182 9202 } else {
9183 9203 PyErr_Clear();
9184 9204 }
9185 9205 }
9186 9206 return srecFile::getFragments();
9187 9207 }
9188 9208 bool PythonQtShell_srecFile::isopened()
9189 9209 {
9190 9210 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9191 9211 static PyObject* name = PyString_FromString("isopened");
9192 9212 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9193 9213 if (obj) {
9194 9214 static const char* argumentList[] ={"bool"};
9195 9215 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9196 9216 bool returnValue;
9197 9217 void* args[1] = {NULL};
9198 9218 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9199 9219 if (result) {
9200 9220 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9201 9221 if (args[0]!=&returnValue) {
9202 9222 if (args[0]==NULL) {
9203 9223 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
9204 9224 } else {
9205 9225 returnValue = *((bool*)args[0]);
9206 9226 }
9207 9227 }
9208 9228 }
9209 9229 if (result) { Py_DECREF(result); }
9210 9230 Py_DECREF(obj);
9211 9231 return returnValue;
9212 9232 } else {
9213 9233 PyErr_Clear();
9214 9234 }
9215 9235 }
9216 9236 return srecFile::isopened();
9217 9237 }
9218 9238 bool PythonQtShell_srecFile::openFile(const QString& File0)
9219 9239 {
9220 9240 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9221 9241 static PyObject* name = PyString_FromString("openFile");
9222 9242 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9223 9243 if (obj) {
9224 9244 static const char* argumentList[] ={"bool" , "const QString&"};
9225 9245 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9226 9246 bool returnValue;
9227 9247 void* args[2] = {NULL, (void*)&File0};
9228 9248 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9229 9249 if (result) {
9230 9250 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9231 9251 if (args[0]!=&returnValue) {
9232 9252 if (args[0]==NULL) {
9233 9253 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
9234 9254 } else {
9235 9255 returnValue = *((bool*)args[0]);
9236 9256 }
9237 9257 }
9238 9258 }
9239 9259 if (result) { Py_DECREF(result); }
9240 9260 Py_DECREF(obj);
9241 9261 return returnValue;
9242 9262 } else {
9243 9263 PyErr_Clear();
9244 9264 }
9245 9265 }
9246 9266 return srecFile::openFile(File0);
9247 9267 }
9248 9268 bool PythonQtShell_srecFile::toBinary(const QString& File0)
9249 9269 {
9250 9270 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9251 9271 static PyObject* name = PyString_FromString("toBinary");
9252 9272 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9253 9273 if (obj) {
9254 9274 static const char* argumentList[] ={"bool" , "const QString&"};
9255 9275 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9256 9276 bool returnValue;
9257 9277 void* args[2] = {NULL, (void*)&File0};
9258 9278 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9259 9279 if (result) {
9260 9280 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9261 9281 if (args[0]!=&returnValue) {
9262 9282 if (args[0]==NULL) {
9263 9283 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
9264 9284 } else {
9265 9285 returnValue = *((bool*)args[0]);
9266 9286 }
9267 9287 }
9268 9288 }
9269 9289 if (result) { Py_DECREF(result); }
9270 9290 Py_DECREF(obj);
9271 9291 return returnValue;
9272 9292 } else {
9273 9293 PyErr_Clear();
9274 9294 }
9275 9295 }
9276 9296 return srecFile::toBinary(File0);
9277 9297 }
9278 9298 bool PythonQtShell_srecFile::toSrec(const QString& File0)
9279 9299 {
9280 9300 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9281 9301 static PyObject* name = PyString_FromString("toSrec");
9282 9302 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9283 9303 if (obj) {
9284 9304 static const char* argumentList[] ={"bool" , "const QString&"};
9285 9305 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9286 9306 bool returnValue;
9287 9307 void* args[2] = {NULL, (void*)&File0};
9288 9308 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9289 9309 if (result) {
9290 9310 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9291 9311 if (args[0]!=&returnValue) {
9292 9312 if (args[0]==NULL) {
9293 9313 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
9294 9314 } else {
9295 9315 returnValue = *((bool*)args[0]);
9296 9316 }
9297 9317 }
9298 9318 }
9299 9319 if (result) { Py_DECREF(result); }
9300 9320 Py_DECREF(obj);
9301 9321 return returnValue;
9302 9322 } else {
9303 9323 PyErr_Clear();
9304 9324 }
9305 9325 }
9306 9326 return srecFile::toSrec(File0);
9307 9327 }
9308 9328 srecFile* PythonQtWrapper_srecFile::new_srecFile()
9309 9329 {
9310 9330 return new PythonQtShell_srecFile(); }
9311 9331
9312 9332 srecFile* PythonQtWrapper_srecFile::new_srecFile(const QString& File)
9313 9333 {
9314 9334 return new PythonQtShell_srecFile(File); }
9315 9335
9316 9336 srecFile* PythonQtWrapper_srecFile::new_srecFile(const QStringList& Files)
9317 9337 {
9318 9338 return new PythonQtShell_srecFile(Files); }
9319 9339
9320 9340 bool PythonQtWrapper_srecFile::static_srecFile_checkSum(const QString& line)
9321 9341 {
9322 9342 return (srecFile::checkSum(line));
9323 9343 }
9324 9344
9325 9345 int PythonQtWrapper_srecFile::closeFile(srecFile* theWrappedObject)
9326 9346 {
9327 9347 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_closeFile());
9328 9348 }
9329 9349
9330 9350 codeFragment* PythonQtWrapper_srecFile::getFragment(srecFile* theWrappedObject, int index)
9331 9351 {
9332 9352 return ( theWrappedObject->getFragment(index));
9333 9353 }
9334 9354
9335 9355 int PythonQtWrapper_srecFile::getFragmentAddress(srecFile* theWrappedObject, int index)
9336 9356 {
9337 9357 return ( theWrappedObject->getFragmentAddress(index));
9338 9358 }
9339 9359
9340 9360 bool PythonQtWrapper_srecFile::getFragmentData(srecFile* theWrappedObject, int index, char** buffer)
9341 9361 {
9342 9362 return ( theWrappedObject->getFragmentData(index, buffer));
9343 9363 }
9344 9364
9345 9365 QString PythonQtWrapper_srecFile::getFragmentHeader(srecFile* theWrappedObject, int index)
9346 9366 {
9347 9367 return ( theWrappedObject->getFragmentHeader(index));
9348 9368 }
9349 9369
9350 9370 int PythonQtWrapper_srecFile::getFragmentSize(srecFile* theWrappedObject, int index)
9351 9371 {
9352 9372 return ( theWrappedObject->getFragmentSize(index));
9353 9373 }
9354 9374
9355 9375 QList<codeFragment* > PythonQtWrapper_srecFile::getFragments(srecFile* theWrappedObject)
9356 9376 {
9357 9377 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_getFragments());
9358 9378 }
9359 9379
9360 9380 int PythonQtWrapper_srecFile::getFragmentsCount(srecFile* theWrappedObject)
9361 9381 {
9362 9382 return ( theWrappedObject->getFragmentsCount());
9363 9383 }
9364 9384
9365 9385 bool PythonQtWrapper_srecFile::isSREC(srecFile* theWrappedObject)
9366 9386 {
9367 9387 return ( theWrappedObject->isSREC());
9368 9388 }
9369 9389
9370 9390 bool PythonQtWrapper_srecFile::static_srecFile_isSREC(const QString& File)
9371 9391 {
9372 9392 return (srecFile::isSREC(File));
9373 9393 }
9374 9394
9375 9395 bool PythonQtWrapper_srecFile::isopened(srecFile* theWrappedObject)
9376 9396 {
9377 9397 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_isopened());
9378 9398 }
9379 9399
9380 9400 int PythonQtWrapper_srecFile::lineCount(srecFile* theWrappedObject)
9381 9401 {
9382 9402 return ( theWrappedObject->lineCount());
9383 9403 }
9384 9404
9385 9405 bool PythonQtWrapper_srecFile::mergingRecords(srecFile* theWrappedObject)
9386 9406 {
9387 9407 return ( theWrappedObject->mergingRecords());
9388 9408 }
9389 9409
9390 9410 bool PythonQtWrapper_srecFile::openFile(srecFile* theWrappedObject, const QString& File)
9391 9411 {
9392 9412 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_openFile(File));
9393 9413 }
9394 9414
9395 9415 bool PythonQtWrapper_srecFile::openFiles(srecFile* theWrappedObject, const QStringList& Files)
9396 9416 {
9397 9417 return ( theWrappedObject->openFiles(Files));
9398 9418 }
9399 9419
9400 9420 void PythonQtWrapper_srecFile::setMergingRecords(srecFile* theWrappedObject, bool enabled)
9401 9421 {
9402 9422 ( theWrappedObject->setMergingRecords(enabled));
9403 9423 }
9404 9424
9405 9425 bool PythonQtWrapper_srecFile::toBinary(srecFile* theWrappedObject, const QString& File)
9406 9426 {
9407 9427 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_toBinary(File));
9408 9428 }
9409 9429
9410 9430 bool PythonQtWrapper_srecFile::static_srecFile_toSrec(QList<codeFragment* > fragments, const QString& File)
9411 9431 {
9412 9432 return (srecFile::toSrec(fragments, File));
9413 9433 }
9414 9434
9415 9435 bool PythonQtWrapper_srecFile::toSrec(srecFile* theWrappedObject, const QString& File)
9416 9436 {
9417 9437 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_toSrec(File));
9418 9438 }
9419 9439
9420 9440
9421 9441
9422 9442 PythonQtShell_srecFileWidget::~PythonQtShell_srecFileWidget() {
9423 9443 PythonQtPrivate* priv = PythonQt::priv();
9424 9444 if (priv) { priv->shellClassDeleted(this); }
9425 9445 }
9426 9446 void PythonQtShell_srecFileWidget::reloadFile()
9427 9447 {
9428 9448 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9429 9449 static PyObject* name = PyString_FromString("reloadFile");
9430 9450 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9431 9451 if (obj) {
9432 9452 static const char* argumentList[] ={""};
9433 9453 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9434 9454 void* args[1] = {NULL};
9435 9455 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9436 9456 if (result) { Py_DECREF(result); }
9437 9457 Py_DECREF(obj);
9438 9458 return;
9439 9459 } else {
9440 9460 PyErr_Clear();
9441 9461 }
9442 9462 }
9443 9463 srecFileWidget::reloadFile();
9444 9464 }
9445 9465 void PythonQtShell_srecFileWidget::setFile(abstractBinFile* file0)
9446 9466 {
9447 9467 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9448 9468 static PyObject* name = PyString_FromString("setFile");
9449 9469 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9450 9470 if (obj) {
9451 9471 static const char* argumentList[] ={"" , "abstractBinFile*"};
9452 9472 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9453 9473 void* args[2] = {NULL, (void*)&file0};
9454 9474 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9455 9475 if (result) { Py_DECREF(result); }
9456 9476 Py_DECREF(obj);
9457 9477 return;
9458 9478 } else {
9459 9479 PyErr_Clear();
9460 9480 }
9461 9481 }
9462 9482 srecFileWidget::setFile(file0);
9463 9483 }
9464 9484 srecFileWidget* PythonQtWrapper_srecFileWidget::new_srecFileWidget(QWidget* parent)
9465 9485 {
9466 9486 return new PythonQtShell_srecFileWidget(parent); }
9467 9487
9468 9488 void PythonQtWrapper_srecFileWidget::reloadFile(srecFileWidget* theWrappedObject)
9469 9489 {
9470 9490 ( ((PythonQtPublicPromoter_srecFileWidget*)theWrappedObject)->promoted_reloadFile());
9471 9491 }
9472 9492
9473 9493 void PythonQtWrapper_srecFileWidget::setFile(srecFileWidget* theWrappedObject, abstractBinFile* file)
9474 9494 {
9475 9495 ( ((PythonQtPublicPromoter_srecFileWidget*)theWrappedObject)->promoted_setFile(file));
9476 9496 }
9477 9497
9478 9498
Show file before | Show file after | Hide comments
@@ -1,1121 +1,1125
1 1 #include <PythonQt.h>
2 2 #include <QObject>
3 3 #include <QVariant>
4 4 #include <SocExplorerPlot.h>
5 5 #include <abstractbinfile.h>
6 6 #include <binaryfile.h>
7 7 #include <binaryfilewidget.h>
8 8 #include <elffile.h>
9 9 #include <elffilewidget.h>
10 10 #include <elfinfowdgt.h>
11 11 #include <elfparser.h>
12 12 #include <genericbinaryfilewidget.h>
13 13 #include <memsizewdgt.h>
14 14 #include <qaction.h>
15 15 #include <qbackingstore.h>
16 16 #include <qbitmap.h>
17 17 #include <qbytearray.h>
18 18 #include <qcolor.h>
19 19 #include <qcoreevent.h>
20 20 #include <qcursor.h>
21 21 #include <qevent.h>
22 22 #include <qfile.h>
23 23 #include <qfont.h>
24 24 #include <qgraphicseffect.h>
25 25 #include <qgraphicsproxywidget.h>
26 26 #include <qhexedit.h>
27 27 #include <qhexspinbox.h>
28 28 #include <qicon.h>
29 29 #include <qkeysequence.h>
30 30 #include <qlayout.h>
31 31 #include <qlineedit.h>
32 32 #include <qlist.h>
33 33 #include <qlocale.h>
34 34 #include <qmargins.h>
35 35 #include <qmetaobject.h>
36 36 #include <qobject.h>
37 37 #include <qpaintdevice.h>
38 38 #include <qpaintengine.h>
39 39 #include <qpainter.h>
40 40 #include <qpalette.h>
41 41 #include <qpen.h>
42 42 #include <qpixmap.h>
43 43 #include <qpoint.h>
44 44 #include <qrect.h>
45 45 #include <qregion.h>
46 46 #include <qscrollarea.h>
47 47 #include <qscrollbar.h>
48 48 #include <qsize.h>
49 49 #include <qsizepolicy.h>
50 50 #include <qspinbox.h>
51 51 #include <qstringlist.h>
52 52 #include <qstyle.h>
53 53 #include <qstyleoption.h>
54 54 #include <qwidget.h>
55 55 #include <qwindow.h>
56 56 #include <srecfile.h>
57 57 #include <srecfilewidget.h>
58 58 #include <tcp_terminal_client.h>
59 59 #include <xbytearray.h>
60 60
61 61
62 62
63 63 class PythonQtShell_ElfFile : public ElfFile
64 64 {
65 65 public:
66 66 PythonQtShell_ElfFile():ElfFile(),_wrapper(NULL) { };
67 67 PythonQtShell_ElfFile(const QString& File):ElfFile(File),_wrapper(NULL) { };
68 68
69 69 ~PythonQtShell_ElfFile();
70 70
71 71 virtual int closeFile();
72 72 virtual QList<codeFragment* > getFragments();
73 73 virtual bool isopened();
74 74 virtual bool openFile(const QString& File);
75 75 virtual bool toBinary(const QString& File);
76 76 virtual bool toSrec(const QString& File);
77 77
78 78 PythonQtInstanceWrapper* _wrapper;
79 79 };
80 80
81 81 class PythonQtPublicPromoter_ElfFile : public ElfFile
82 82 { public:
83 83 inline int promoted_closeFile() { return ElfFile::closeFile(); }
84 84 inline QList<codeFragment* > promoted_getFragments() { return ElfFile::getFragments(); }
85 85 inline bool promoted_isopened() { return ElfFile::isopened(); }
86 86 inline bool promoted_openFile(const QString& File) { return ElfFile::openFile(File); }
87 87 inline bool promoted_toBinary(const QString& File) { return ElfFile::toBinary(File); }
88 88 inline bool promoted_toSrec(const QString& File) { return ElfFile::toSrec(File); }
89 89 };
90 90
91 91 class PythonQtWrapper_ElfFile : public QObject
92 92 { Q_OBJECT
93 93 public:
94 94 public slots:
95 95 ElfFile* new_ElfFile();
96 96 ElfFile* new_ElfFile(const QString& File);
97 97 void delete_ElfFile(ElfFile* obj) { delete obj; }
98 98 int closeFile(ElfFile* theWrappedObject);
99 99 QString getABI(ElfFile* theWrappedObject);
100 100 QString getArchitecture(ElfFile* theWrappedObject);
101 101 QString getClass(ElfFile* theWrappedObject);
102 102 QString getEndianness(ElfFile* theWrappedObject);
103 103 qint64 getEntryPointAddress(ElfFile* theWrappedObject);
104 104 QList<codeFragment* > getFragments(ElfFile* theWrappedObject);
105 105 QList<codeFragment* > getFragments(ElfFile* theWrappedObject, QStringList fragmentList);
106 106 int getSectionCount(ElfFile* theWrappedObject);
107 107 bool getSectionData(ElfFile* theWrappedObject, int index, char** buffer);
108 108 qint64 getSectionDatasz(ElfFile* theWrappedObject, int index);
109 109 int getSectionIndex(ElfFile* theWrappedObject, QString name);
110 110 qint64 getSectionMemsz(ElfFile* theWrappedObject, int index);
111 111 QString getSectionName(ElfFile* theWrappedObject, int index);
112 112 qint64 getSectionPaddr(ElfFile* theWrappedObject, int index);
113 113 QString getSectionType(ElfFile* theWrappedObject, int index);
114 114 int getSegmentCount(ElfFile* theWrappedObject);
115 115 qint64 getSegmentFilesz(ElfFile* theWrappedObject, int index);
116 116 QString getSegmentFlags(ElfFile* theWrappedObject, int index);
117 117 qint64 getSegmentMemsz(ElfFile* theWrappedObject, int index);
118 118 qint64 getSegmentOffset(ElfFile* theWrappedObject, int index);
119 119 qint64 getSegmentPaddr(ElfFile* theWrappedObject, int index);
120 120 QString getSegmentType(ElfFile* theWrappedObject, int index);
121 121 qint64 getSegmentVaddr(ElfFile* theWrappedObject, int index);
122 122 quint64 getSymbolAddress(ElfFile* theWrappedObject, int index);
123 123 int getSymbolCount(ElfFile* theWrappedObject);
124 124 QString getSymbolLinkType(ElfFile* theWrappedObject, int index);
125 125 QString getSymbolName(ElfFile* theWrappedObject, int index);
126 126 int getSymbolSectionIndex(ElfFile* theWrappedObject, int index);
127 127 QString getSymbolSectionName(ElfFile* theWrappedObject, int index);
128 128 quint64 getSymbolSize(ElfFile* theWrappedObject, int index);
129 129 QString getSymbolType(ElfFile* theWrappedObject, int index);
130 130 QString getType(ElfFile* theWrappedObject);
131 131 qint64 getVersion(ElfFile* theWrappedObject);
132 132 bool isBigEndian(ElfFile* theWrappedObject);
133 133 bool static_ElfFile_isElf(const QString& File);
134 134 bool isLitleEndian(ElfFile* theWrappedObject);
135 135 bool iself(ElfFile* theWrappedObject);
136 136 bool isopened(ElfFile* theWrappedObject);
137 137 bool openFile(ElfFile* theWrappedObject, const QString& File);
138 138 bool sectionIsNobits(ElfFile* theWrappedObject, int index);
139 139 bool toBinary(ElfFile* theWrappedObject, const QString& File);
140 140 bool toSrec(ElfFile* theWrappedObject, const QString& File);
141 141 };
142 142
143 143
144 144
145 145
146 146
147 147 class PythonQtShell_MemSizeWdgt : public MemSizeWdgt
148 148 {
149 149 public:
150 150 PythonQtShell_MemSizeWdgt(QWidget* parent = 0):MemSizeWdgt(parent),_wrapper(NULL) { };
151 151 PythonQtShell_MemSizeWdgt(int defaultSize, QWidget* parent = 0):MemSizeWdgt(defaultSize, parent),_wrapper(NULL) { };
152 152
153 153 ~PythonQtShell_MemSizeWdgt();
154 154
155 155 virtual void actionEvent(QActionEvent* arg__1);
156 156 virtual void changeEvent(QEvent* arg__1);
157 157 virtual void childEvent(QChildEvent* arg__1);
158 158 virtual void closeEvent(QCloseEvent* arg__1);
159 159 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
160 160 virtual void customEvent(QEvent* arg__1);
161 161 virtual int devType() const;
162 162 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
163 163 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
164 164 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
165 165 virtual void dropEvent(QDropEvent* arg__1);
166 166 virtual void enterEvent(QEvent* arg__1);
167 167 virtual bool event(QEvent* arg__1);
168 168 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
169 169 virtual void focusInEvent(QFocusEvent* arg__1);
170 170 virtual bool focusNextPrevChild(bool next);
171 171 virtual void focusOutEvent(QFocusEvent* arg__1);
172 172 virtual bool hasHeightForWidth() const;
173 173 virtual int heightForWidth(int arg__1) const;
174 174 virtual void hideEvent(QHideEvent* arg__1);
175 175 virtual void initPainter(QPainter* painter) const;
176 176 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
177 177 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
178 178 virtual void keyPressEvent(QKeyEvent* arg__1);
179 179 virtual void keyReleaseEvent(QKeyEvent* arg__1);
180 180 virtual void leaveEvent(QEvent* arg__1);
181 181 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
182 182 virtual QSize minimumSizeHint() const;
183 183 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
184 184 virtual void mouseMoveEvent(QMouseEvent* arg__1);
185 185 virtual void mousePressEvent(QMouseEvent* arg__1);
186 186 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
187 187 virtual void moveEvent(QMoveEvent* arg__1);
188 188 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
189 189 virtual QPaintEngine* paintEngine() const;
190 190 virtual void paintEvent(QPaintEvent* arg__1);
191 191 virtual QPaintDevice* redirected(QPoint* offset) const;
192 192 virtual void resizeEvent(QResizeEvent* arg__1);
193 193 virtual QPainter* sharedPainter() const;
194 194 virtual void showEvent(QShowEvent* arg__1);
195 195 virtual QSize sizeHint() const;
196 196 virtual void tabletEvent(QTabletEvent* arg__1);
197 197 virtual void timerEvent(QTimerEvent* arg__1);
198 198 virtual void wheelEvent(QWheelEvent* arg__1);
199 199
200 200 PythonQtInstanceWrapper* _wrapper;
201 201 };
202 202
203 203 class PythonQtWrapper_MemSizeWdgt : public QObject
204 204 { Q_OBJECT
205 205 public:
206 206 public slots:
207 207 MemSizeWdgt* new_MemSizeWdgt(QWidget* parent = 0);
208 208 MemSizeWdgt* new_MemSizeWdgt(int defaultSize, QWidget* parent = 0);
209 209 void delete_MemSizeWdgt(MemSizeWdgt* obj) { delete obj; }
210 210 int getsize(MemSizeWdgt* theWrappedObject);
211 211 void setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max);
212 212 void show(MemSizeWdgt* theWrappedObject);
213 213 void updateSizeValue(MemSizeWdgt* theWrappedObject);
214 214 };
215 215
216 216
217 217
218 218
219 219
220 220 class PythonQtShell_QHexEdit : public QHexEdit
221 221 {
222 222 public:
223 223 PythonQtShell_QHexEdit(QWidget* parent = 0):QHexEdit(parent),_wrapper(NULL) { };
224 224
225 225 ~PythonQtShell_QHexEdit();
226 226
227 227 virtual void actionEvent(QActionEvent* arg__1);
228 228 virtual void changeEvent(QEvent* arg__1);
229 229 virtual void childEvent(QChildEvent* arg__1);
230 230 virtual void closeEvent(QCloseEvent* arg__1);
231 231 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
232 232 virtual void customEvent(QEvent* arg__1);
233 233 virtual int devType() const;
234 234 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
235 235 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
236 236 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
237 237 virtual void dropEvent(QDropEvent* arg__1);
238 238 virtual void enterEvent(QEvent* arg__1);
239 239 virtual bool event(QEvent* arg__1);
240 240 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
241 241 virtual void focusInEvent(QFocusEvent* arg__1);
242 242 virtual bool focusNextPrevChild(bool next);
243 243 virtual void focusOutEvent(QFocusEvent* arg__1);
244 244 virtual bool hasHeightForWidth() const;
245 245 virtual int heightForWidth(int arg__1) const;
246 246 virtual void hideEvent(QHideEvent* arg__1);
247 247 virtual void initPainter(QPainter* painter) const;
248 248 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
249 249 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
250 250 virtual void keyPressEvent(QKeyEvent* arg__1);
251 251 virtual void keyReleaseEvent(QKeyEvent* arg__1);
252 252 virtual void leaveEvent(QEvent* arg__1);
253 253 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
254 254 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
255 255 virtual void mouseMoveEvent(QMouseEvent* arg__1);
256 256 virtual void mousePressEvent(QMouseEvent* arg__1);
257 257 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
258 258 virtual void moveEvent(QMoveEvent* arg__1);
259 259 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
260 260 virtual QPaintEngine* paintEngine() const;
261 261 virtual void paintEvent(QPaintEvent* arg__1);
262 262 virtual QPaintDevice* redirected(QPoint* offset) const;
263 263 virtual void resizeEvent(QResizeEvent* arg__1);
264 264 virtual void scrollContentsBy(int dx, int dy);
265 265 virtual void setupViewport(QWidget* viewport);
266 266 virtual QPainter* sharedPainter() const;
267 267 virtual void showEvent(QShowEvent* arg__1);
268 268 virtual void tabletEvent(QTabletEvent* arg__1);
269 269 virtual void timerEvent(QTimerEvent* arg__1);
270 270 virtual bool viewportEvent(QEvent* arg__1);
271 271 virtual QSize viewportSizeHint() const;
272 272 virtual void wheelEvent(QWheelEvent* arg__1);
273 273
274 274 PythonQtInstanceWrapper* _wrapper;
275 275 };
276 276
277 277 class PythonQtWrapper_QHexEdit : public QObject
278 278 { Q_OBJECT
279 279 public:
280 280 public slots:
281 281 QHexEdit* new_QHexEdit(QWidget* parent = 0);
282 282 void delete_QHexEdit(QHexEdit* obj) { delete obj; }
283 283 QColor addressAreaColor(QHexEdit* theWrappedObject);
284 284 int addressOffset(QHexEdit* theWrappedObject);
285 285 int cursorPosition(QHexEdit* theWrappedObject);
286 286 QByteArray data(QHexEdit* theWrappedObject);
287 287 const QFont* font(QHexEdit* theWrappedObject) const;
288 288 int getSelectionBegin(QHexEdit* theWrappedObject);
289 289 int getSelectionEnd(QHexEdit* theWrappedObject);
290 290 QColor highlightingColor(QHexEdit* theWrappedObject);
291 291 int indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
292 292 void insert(QHexEdit* theWrappedObject, int i, char ch);
293 293 void insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba);
294 294 bool isReadOnly(QHexEdit* theWrappedObject);
295 295 int lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
296 296 bool overwriteMode(QHexEdit* theWrappedObject);
297 297 void remove(QHexEdit* theWrappedObject, int pos, int len = 1);
298 298 void replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after);
299 299 void resetSelection(QHexEdit* theWrappedObject);
300 300 void resetSelection(QHexEdit* theWrappedObject, int pos);
301 301 QColor selectionColor(QHexEdit* theWrappedObject);
302 302 QString selectionToReadableString(QHexEdit* theWrappedObject);
303 303 void setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color);
304 304 void setAddressOffset(QHexEdit* theWrappedObject, int offset);
305 305 void setCursorPosition(QHexEdit* theWrappedObject, int cusorPos);
306 306 void setData(QHexEdit* theWrappedObject, const QByteArray& data);
307 307 void setFont(QHexEdit* theWrappedObject, const QFont& arg__1);
308 308 void setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color);
309 309 void setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1);
310 310 void setReadOnly(QHexEdit* theWrappedObject, bool arg__1);
311 311 void setSelection(QHexEdit* theWrappedObject, int pos);
312 312 void setSelectionColor(QHexEdit* theWrappedObject, const QColor& color);
313 313 QString toReadableString(QHexEdit* theWrappedObject);
314 314 };
315 315
316 316
317 317
318 318
319 319
320 320 class PythonQtShell_QHexSpinBox : public QHexSpinBox
321 321 {
322 322 public:
323 323 PythonQtShell_QHexSpinBox(QWidget* parent = 0):QHexSpinBox(parent),_wrapper(NULL) { };
324 324
325 325 ~PythonQtShell_QHexSpinBox();
326 326
327 327 virtual void actionEvent(QActionEvent* arg__1);
328 328 virtual void changeEvent(QEvent* event);
329 329 virtual void childEvent(QChildEvent* arg__1);
330 330 virtual void clear();
331 331 virtual void closeEvent(QCloseEvent* event);
332 332 virtual void contextMenuEvent(QContextMenuEvent* event);
333 333 virtual void customEvent(QEvent* arg__1);
334 334 virtual int devType() const;
335 335 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
336 336 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
337 337 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
338 338 virtual void dropEvent(QDropEvent* arg__1);
339 339 virtual void enterEvent(QEvent* arg__1);
340 340 virtual bool event(QEvent* event);
341 341 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
342 342 virtual void fixup(QString& str) const;
343 343 virtual void focusInEvent(QFocusEvent* event);
344 344 virtual bool focusNextPrevChild(bool next);
345 345 virtual void focusOutEvent(QFocusEvent* event);
346 346 virtual bool hasHeightForWidth() const;
347 347 virtual int heightForWidth(int arg__1) const;
348 348 virtual void hideEvent(QHideEvent* event);
349 349 virtual void initPainter(QPainter* painter) const;
350 350 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
351 351 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
352 352 virtual void keyPressEvent(QKeyEvent* event);
353 353 virtual void keyReleaseEvent(QKeyEvent* event);
354 354 virtual void leaveEvent(QEvent* arg__1);
355 355 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
356 356 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
357 357 virtual void mouseMoveEvent(QMouseEvent* event);
358 358 virtual void mousePressEvent(QMouseEvent* event);
359 359 virtual void mouseReleaseEvent(QMouseEvent* event);
360 360 virtual void moveEvent(QMoveEvent* arg__1);
361 361 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
362 362 virtual QPaintEngine* paintEngine() const;
363 363 virtual void paintEvent(QPaintEvent* event);
364 364 virtual QPaintDevice* redirected(QPoint* offset) const;
365 365 virtual void resizeEvent(QResizeEvent* event);
366 366 virtual QPainter* sharedPainter() const;
367 367 virtual void showEvent(QShowEvent* event);
368 368 virtual void stepBy(int steps);
369 369 virtual QAbstractSpinBox::StepEnabled stepEnabled() const;
370 370 virtual void tabletEvent(QTabletEvent* arg__1);
371 371 virtual QString textFromValue(int value) const;
372 372 virtual void timerEvent(QTimerEvent* event);
373 373 virtual QValidator::State validate(QString& input, int& pos) const;
374 374 virtual int valueFromText(const QString& text) const;
375 375 virtual void wheelEvent(QWheelEvent* event);
376 376
377 377 PythonQtInstanceWrapper* _wrapper;
378 378 };
379 379
380 380 class PythonQtPublicPromoter_QHexSpinBox : public QHexSpinBox
381 381 { public:
382 382 inline QString promoted_textFromValue(int value) const { return QHexSpinBox::textFromValue(value); }
383 383 inline QValidator::State promoted_validate(QString& input, int& pos) const { return QHexSpinBox::validate(input, pos); }
384 384 inline int promoted_valueFromText(const QString& text) const { return QHexSpinBox::valueFromText(text); }
385 385 };
386 386
387 387 class PythonQtWrapper_QHexSpinBox : public QObject
388 388 { Q_OBJECT
389 389 public:
390 390 public slots:
391 391 QHexSpinBox* new_QHexSpinBox(QWidget* parent = 0);
392 392 void delete_QHexSpinBox(QHexSpinBox* obj) { delete obj; }
393 393 void show(QHexSpinBox* theWrappedObject);
394 394 QString textFromValue(QHexSpinBox* theWrappedObject, int value) const;
395 395 QValidator::State validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const;
396 396 int valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const;
397 397 };
398 398
399 399
400 400
401 401
402 402
403 403 class PythonQtShell_SocExplorerPlot : public SocExplorerPlot
404 404 {
405 405 public:
406 406 PythonQtShell_SocExplorerPlot(QWidget* parent = 0):SocExplorerPlot(parent),_wrapper(NULL) { };
407 407
408 408 ~PythonQtShell_SocExplorerPlot();
409 409
410 410 virtual void actionEvent(QActionEvent* arg__1);
411 411 virtual void changeEvent(QEvent* arg__1);
412 412 virtual void childEvent(QChildEvent* arg__1);
413 413 virtual void closeEvent(QCloseEvent* arg__1);
414 414 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
415 415 virtual void customEvent(QEvent* arg__1);
416 416 virtual int devType() const;
417 417 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
418 418 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
419 419 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
420 420 virtual void dropEvent(QDropEvent* arg__1);
421 421 virtual void enterEvent(QEvent* arg__1);
422 422 virtual bool event(QEvent* arg__1);
423 423 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
424 424 virtual void focusInEvent(QFocusEvent* arg__1);
425 425 virtual bool focusNextPrevChild(bool next);
426 426 virtual void focusOutEvent(QFocusEvent* arg__1);
427 427 virtual bool hasHeightForWidth() const;
428 428 virtual int heightForWidth(int arg__1) const;
429 429 virtual void hideEvent(QHideEvent* arg__1);
430 430 virtual void initPainter(QPainter* painter) const;
431 431 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
432 432 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
433 433 virtual void keyPressEvent(QKeyEvent* arg__1);
434 434 virtual void keyReleaseEvent(QKeyEvent* arg__1);
435 435 virtual void leaveEvent(QEvent* arg__1);
436 436 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
437 437 virtual QSize minimumSizeHint() const;
438 438 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
439 439 virtual void mouseMoveEvent(QMouseEvent* arg__1);
440 440 virtual void mousePressEvent(QMouseEvent* arg__1);
441 441 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
442 442 virtual void moveEvent(QMoveEvent* arg__1);
443 443 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
444 444 virtual QPaintEngine* paintEngine() const;
445 445 virtual void paintEvent(QPaintEvent* arg__1);
446 446 virtual QPaintDevice* redirected(QPoint* offset) const;
447 447 virtual void resizeEvent(QResizeEvent* arg__1);
448 448 virtual QPainter* sharedPainter() const;
449 449 virtual void showEvent(QShowEvent* arg__1);
450 450 virtual QSize sizeHint() const;
451 451 virtual void tabletEvent(QTabletEvent* arg__1);
452 452 virtual void timerEvent(QTimerEvent* arg__1);
453 453 virtual void wheelEvent(QWheelEvent* arg__1);
454 454
455 455 PythonQtInstanceWrapper* _wrapper;
456 456 };
457 457
458 458 class PythonQtPublicPromoter_SocExplorerPlot : public SocExplorerPlot
459 459 { public:
460 460 inline void promoted_keyPressEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyPressEvent(arg__1); }
461 461 inline void promoted_keyReleaseEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyReleaseEvent(arg__1); }
462 462 inline void promoted_mouseMoveEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseMoveEvent(arg__1); }
463 463 inline void promoted_mousePressEvent(QMouseEvent* arg__1) { SocExplorerPlot::mousePressEvent(arg__1); }
464 464 inline void promoted_mouseReleaseEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseReleaseEvent(arg__1); }
465 465 inline void promoted_wheelEvent(QWheelEvent* arg__1) { SocExplorerPlot::wheelEvent(arg__1); }
466 466 };
467 467
468 468 class PythonQtWrapper_SocExplorerPlot : public QObject
469 469 { Q_OBJECT
470 470 public:
471 471 public slots:
472 472 SocExplorerPlot* new_SocExplorerPlot(QWidget* parent = 0);
473 473 void delete_SocExplorerPlot(SocExplorerPlot* obj) { delete obj; }
474 474 int addGraph(SocExplorerPlot* theWrappedObject);
475 475 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
476 476 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y);
477 477 QPen getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex);
478 478 void keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
479 479 void keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
480 480 void mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
481 481 void mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
482 482 void mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
483 void removeAllGraphs(SocExplorerPlot* theWrappedObject);
484 bool removeGraph(SocExplorerPlot* theWrappedObject, int graphIndex);
485 void replot(SocExplorerPlot* theWrappedObject);
483 486 void rescaleAxis(SocExplorerPlot* theWrappedObject);
484 487 void setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable);
485 488 void setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
486 489 void setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle);
487 490 void setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name);
488 491 void setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen);
489 492 void setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle);
490 493 void setLegendFont(SocExplorerPlot* theWrappedObject, QFont font);
491 494 void setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font);
492 495 void setTitle(SocExplorerPlot* theWrappedObject, QString title);
496 void setXaxisDateTimeFormat(SocExplorerPlot* theWrappedObject, const QString& format);
493 497 void setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
494 498 void setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
495 499 void setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
496 500 void setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
497 501 void show(SocExplorerPlot* theWrappedObject);
498 502 void wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1);
499 503 };
500 504
501 505
502 506
503 507
504 508
505 509 class PythonQtShell_TCP_Terminal_Client : public TCP_Terminal_Client
506 510 {
507 511 public:
508 512 PythonQtShell_TCP_Terminal_Client(QObject* parent = 0):TCP_Terminal_Client(parent),_wrapper(NULL) { };
509 513
510 514 ~PythonQtShell_TCP_Terminal_Client();
511 515
512 516 virtual void childEvent(QChildEvent* arg__1);
513 517 virtual void customEvent(QEvent* arg__1);
514 518 virtual bool event(QEvent* arg__1);
515 519 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
516 520 virtual void timerEvent(QTimerEvent* arg__1);
517 521
518 522 PythonQtInstanceWrapper* _wrapper;
519 523 };
520 524
521 525 class PythonQtWrapper_TCP_Terminal_Client : public QObject
522 526 { Q_OBJECT
523 527 public:
524 528 public slots:
525 529 TCP_Terminal_Client* new_TCP_Terminal_Client(QObject* parent = 0);
526 530 void delete_TCP_Terminal_Client(TCP_Terminal_Client* obj) { delete obj; }
527 531 void connectToServer(TCP_Terminal_Client* theWrappedObject);
528 532 void connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port);
529 533 bool isConnected(TCP_Terminal_Client* theWrappedObject);
530 534 void sendText(TCP_Terminal_Client* theWrappedObject, const QString& text);
531 535 void startServer(TCP_Terminal_Client* theWrappedObject);
532 536 void startServer(TCP_Terminal_Client* theWrappedObject, int port);
533 537 };
534 538
535 539
536 540
537 541
538 542
539 543 class PythonQtWrapper_XByteArray : public QObject
540 544 { Q_OBJECT
541 545 public:
542 546 public slots:
543 547 XByteArray* new_XByteArray();
544 548 void delete_XByteArray(XByteArray* obj) { delete obj; }
545 549 int addressOffset(XByteArray* theWrappedObject);
546 550 int addressWidth(XByteArray* theWrappedObject);
547 551 QChar asciiChar(XByteArray* theWrappedObject, int index);
548 552 QByteArray* data(XByteArray* theWrappedObject);
549 553 bool dataChanged(XByteArray* theWrappedObject, int i);
550 554 QByteArray dataChanged(XByteArray* theWrappedObject, int i, int len);
551 555 QByteArray* insert(XByteArray* theWrappedObject, int i, char ch);
552 556 QByteArray* insert(XByteArray* theWrappedObject, int i, const QByteArray& ba);
553 557 int realAddressNumbers(XByteArray* theWrappedObject);
554 558 QByteArray* remove(XByteArray* theWrappedObject, int pos, int len);
555 559 QByteArray* replace(XByteArray* theWrappedObject, int index, char ch);
556 560 QByteArray* replace(XByteArray* theWrappedObject, int index, const QByteArray& ba);
557 561 QByteArray* replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba);
558 562 void setAddressOffset(XByteArray* theWrappedObject, int offset);
559 563 void setAddressWidth(XByteArray* theWrappedObject, int width);
560 564 void setData(XByteArray* theWrappedObject, QByteArray data);
561 565 void setDataChanged(XByteArray* theWrappedObject, int i, bool state);
562 566 void setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state);
563 567 int size(XByteArray* theWrappedObject);
564 568 QString toRedableString(XByteArray* theWrappedObject, int start = 0, int end = -1);
565 569 };
566 570
567 571
568 572
569 573
570 574
571 575 class PythonQtShell_abstractBinFile : public abstractBinFile
572 576 {
573 577 public:
574 578 PythonQtShell_abstractBinFile():abstractBinFile(),_wrapper(NULL) { };
575 579
576 580 ~PythonQtShell_abstractBinFile();
577 581
578 582 virtual void childEvent(QChildEvent* arg__1);
579 583 virtual int closeFile();
580 584 virtual void customEvent(QEvent* arg__1);
581 585 virtual bool event(QEvent* arg__1);
582 586 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
583 587 virtual QList<codeFragment* > getFragments();
584 588 virtual bool isopened();
585 589 virtual bool openFile(const QString& File);
586 590 virtual void timerEvent(QTimerEvent* arg__1);
587 591 virtual bool toBinary(const QString& File);
588 592 virtual bool toSrec(const QString& File);
589 593
590 594 PythonQtInstanceWrapper* _wrapper;
591 595 };
592 596
593 597 class PythonQtPublicPromoter_abstractBinFile : public abstractBinFile
594 598 { public:
595 599 inline int promoted_closeFile() { return closeFile(); }
596 600 inline QList<codeFragment* > promoted_getFragments() { return getFragments(); }
597 601 inline bool promoted_isopened() { return isopened(); }
598 602 inline bool promoted_openFile(const QString& File) { return openFile(File); }
599 603 inline bool promoted_toBinary(const QString& File) { return toBinary(File); }
600 604 inline bool promoted_toSrec(const QString& File) { return toSrec(File); }
601 605 };
602 606
603 607 class PythonQtWrapper_abstractBinFile : public QObject
604 608 { Q_OBJECT
605 609 public:
606 610 public slots:
607 611 abstractBinFile* new_abstractBinFile();
608 612 void delete_abstractBinFile(abstractBinFile* obj) { delete obj; }
609 613 int closeFile(abstractBinFile* theWrappedObject);
610 614 QList<codeFragment* > getFragments(abstractBinFile* theWrappedObject);
611 615 bool isopened(abstractBinFile* theWrappedObject);
612 616 bool openFile(abstractBinFile* theWrappedObject, const QString& File);
613 617 bool toBinary(abstractBinFile* theWrappedObject, const QString& File);
614 618 bool toSrec(abstractBinFile* theWrappedObject, const QString& File);
615 619 void py_set_litleendian(abstractBinFile* theWrappedObject, bool litleendian){ theWrappedObject->litleendian = litleendian; }
616 620 bool py_get_litleendian(abstractBinFile* theWrappedObject){ return theWrappedObject->litleendian; }
617 621 };
618 622
619 623
620 624
621 625
622 626
623 627 class PythonQtShell_abstractBinFileWidget : public abstractBinFileWidget
624 628 {
625 629 public:
626 630 PythonQtShell_abstractBinFileWidget(QWidget* parent = 0):abstractBinFileWidget(parent),_wrapper(NULL) { };
627 631
628 632 ~PythonQtShell_abstractBinFileWidget();
629 633
630 634 virtual void actionEvent(QActionEvent* arg__1);
631 635 virtual void changeEvent(QEvent* arg__1);
632 636 virtual void childEvent(QChildEvent* arg__1);
633 637 virtual void closeEvent(QCloseEvent* arg__1);
634 638 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
635 639 virtual void customEvent(QEvent* arg__1);
636 640 virtual int devType() const;
637 641 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
638 642 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
639 643 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
640 644 virtual void dropEvent(QDropEvent* arg__1);
641 645 virtual void enterEvent(QEvent* arg__1);
642 646 virtual bool event(QEvent* arg__1);
643 647 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
644 648 virtual void focusInEvent(QFocusEvent* arg__1);
645 649 virtual bool focusNextPrevChild(bool next);
646 650 virtual void focusOutEvent(QFocusEvent* arg__1);
647 651 virtual bool hasHeightForWidth() const;
648 652 virtual int heightForWidth(int arg__1) const;
649 653 virtual void hideEvent(QHideEvent* arg__1);
650 654 virtual void initPainter(QPainter* painter) const;
651 655 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
652 656 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
653 657 virtual void keyPressEvent(QKeyEvent* arg__1);
654 658 virtual void keyReleaseEvent(QKeyEvent* arg__1);
655 659 virtual void leaveEvent(QEvent* arg__1);
656 660 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
657 661 virtual QSize minimumSizeHint() const;
658 662 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
659 663 virtual void mouseMoveEvent(QMouseEvent* arg__1);
660 664 virtual void mousePressEvent(QMouseEvent* arg__1);
661 665 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
662 666 virtual void moveEvent(QMoveEvent* arg__1);
663 667 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
664 668 virtual QPaintEngine* paintEngine() const;
665 669 virtual void paintEvent(QPaintEvent* arg__1);
666 670 virtual QPaintDevice* redirected(QPoint* offset) const;
667 671 virtual void reloadFile();
668 672 virtual void resizeEvent(QResizeEvent* arg__1);
669 673 virtual void setFile(abstractBinFile* file);
670 674 virtual QPainter* sharedPainter() const;
671 675 virtual void showEvent(QShowEvent* arg__1);
672 676 virtual QSize sizeHint() const;
673 677 virtual void tabletEvent(QTabletEvent* arg__1);
674 678 virtual void timerEvent(QTimerEvent* arg__1);
675 679 virtual void wheelEvent(QWheelEvent* arg__1);
676 680
677 681 PythonQtInstanceWrapper* _wrapper;
678 682 };
679 683
680 684 class PythonQtPublicPromoter_abstractBinFileWidget : public abstractBinFileWidget
681 685 { public:
682 686 inline void promoted_reloadFile() { reloadFile(); }
683 687 inline void promoted_setFile(abstractBinFile* file) { setFile(file); }
684 688 };
685 689
686 690 class PythonQtWrapper_abstractBinFileWidget : public QObject
687 691 { Q_OBJECT
688 692 public:
689 693 public slots:
690 694 abstractBinFileWidget* new_abstractBinFileWidget(QWidget* parent = 0);
691 695 void delete_abstractBinFileWidget(abstractBinFileWidget* obj) { delete obj; }
692 696 void reloadFile(abstractBinFileWidget* theWrappedObject);
693 697 void setFile(abstractBinFileWidget* theWrappedObject, abstractBinFile* file);
694 698 };
695 699
696 700
697 701
698 702
699 703
700 704 class PythonQtShell_binaryFile : public binaryFile
701 705 {
702 706 public:
703 707 PythonQtShell_binaryFile():binaryFile(),_wrapper(NULL) { };
704 708 PythonQtShell_binaryFile(const QString& File):binaryFile(File),_wrapper(NULL) { };
705 709 PythonQtShell_binaryFile(const QStringList& Files):binaryFile(Files),_wrapper(NULL) { };
706 710
707 711 ~PythonQtShell_binaryFile();
708 712
709 713 virtual int closeFile();
710 714 virtual QList<codeFragment* > getFragments();
711 715 virtual bool isopened();
712 716 virtual bool openFile(const QString& File);
713 717 virtual bool toBinary(const QString& fileName);
714 718 virtual bool toSrec(const QString& fileName);
715 719
716 720 PythonQtInstanceWrapper* _wrapper;
717 721 };
718 722
719 723 class PythonQtPublicPromoter_binaryFile : public binaryFile
720 724 { public:
721 725 inline int promoted_closeFile() { return binaryFile::closeFile(); }
722 726 inline QList<codeFragment* > promoted_getFragments() { return binaryFile::getFragments(); }
723 727 inline bool promoted_isopened() { return binaryFile::isopened(); }
724 728 inline bool promoted_openFile(const QString& File) { return binaryFile::openFile(File); }
725 729 inline bool promoted_toBinary(const QString& fileName) { return binaryFile::toBinary(fileName); }
726 730 inline bool promoted_toSrec(const QString& fileName) { return binaryFile::toSrec(fileName); }
727 731 };
728 732
729 733 class PythonQtWrapper_binaryFile : public QObject
730 734 { Q_OBJECT
731 735 public:
732 736 public slots:
733 737 binaryFile* new_binaryFile();
734 738 binaryFile* new_binaryFile(const QString& File);
735 739 binaryFile* new_binaryFile(const QStringList& Files);
736 740 void delete_binaryFile(binaryFile* obj) { delete obj; }
737 741 int closeFile(binaryFile* theWrappedObject);
738 742 codeFragment* getFragment(binaryFile* theWrappedObject, int index);
739 743 int getFragmentAddress(binaryFile* theWrappedObject, int index);
740 744 bool getFragmentData(binaryFile* theWrappedObject, int index, char** buffer);
741 745 QString getFragmentHeader(binaryFile* theWrappedObject, int index);
742 746 int getFragmentSize(binaryFile* theWrappedObject, int index);
743 747 QList<codeFragment* > getFragments(binaryFile* theWrappedObject);
744 748 int getFragmentsCount(binaryFile* theWrappedObject);
745 749 bool isopened(binaryFile* theWrappedObject);
746 750 bool openFile(binaryFile* theWrappedObject, const QString& File);
747 751 bool openFiles(binaryFile* theWrappedObject, const QStringList& Files);
748 752 bool static_binaryFile_toBinary(QList<codeFragment* > fragments, const QString& File);
749 753 bool toBinary(binaryFile* theWrappedObject, const QString& fileName);
750 754 bool toSrec(binaryFile* theWrappedObject, const QString& fileName);
751 755 };
752 756
753 757
754 758
755 759
756 760
757 761 class PythonQtShell_binaryFileWidget : public binaryFileWidget
758 762 {
759 763 public:
760 764 PythonQtShell_binaryFileWidget(QWidget* parent = 0):binaryFileWidget(parent),_wrapper(NULL) { };
761 765
762 766 ~PythonQtShell_binaryFileWidget();
763 767
764 768 virtual void reloadFile();
765 769 virtual void setFile(abstractBinFile* file);
766 770
767 771 PythonQtInstanceWrapper* _wrapper;
768 772 };
769 773
770 774 class PythonQtPublicPromoter_binaryFileWidget : public binaryFileWidget
771 775 { public:
772 776 inline void promoted_reloadFile() { binaryFileWidget::reloadFile(); }
773 777 inline void promoted_setFile(abstractBinFile* file) { binaryFileWidget::setFile(file); }
774 778 };
775 779
776 780 class PythonQtWrapper_binaryFileWidget : public QObject
777 781 { Q_OBJECT
778 782 public:
779 783 public slots:
780 784 binaryFileWidget* new_binaryFileWidget(QWidget* parent = 0);
781 785 void delete_binaryFileWidget(binaryFileWidget* obj) { delete obj; }
782 786 void reloadFile(binaryFileWidget* theWrappedObject);
783 787 void setFile(binaryFileWidget* theWrappedObject, abstractBinFile* file);
784 788 };
785 789
786 790
787 791
788 792
789 793
790 794 class PythonQtShell_codeFragment : public codeFragment
791 795 {
792 796 public:
793 797 PythonQtShell_codeFragment():codeFragment(),_wrapper(NULL) { };
794 798 PythonQtShell_codeFragment(char* data, quint64 size, quint64 address):codeFragment(data, size, address),_wrapper(NULL) { };
795 799
796 800 ~PythonQtShell_codeFragment();
797 801
798 802
799 803 PythonQtInstanceWrapper* _wrapper;
800 804 };
801 805
802 806 class PythonQtWrapper_codeFragment : public QObject
803 807 { Q_OBJECT
804 808 public:
805 809 public slots:
806 810 codeFragment* new_codeFragment();
807 811 codeFragment* new_codeFragment(char* data, quint64 size, quint64 address);
808 812 void delete_codeFragment(codeFragment* obj) { delete obj; }
809 813 void py_set_address(codeFragment* theWrappedObject, quint64 address){ theWrappedObject->address = address; }
810 814 quint64 py_get_address(codeFragment* theWrappedObject){ return theWrappedObject->address; }
811 815 void py_set_data(codeFragment* theWrappedObject, char* data){ theWrappedObject->data = data; }
812 816 char* py_get_data(codeFragment* theWrappedObject){ return theWrappedObject->data; }
813 817 void py_set_header(codeFragment* theWrappedObject, QString header){ theWrappedObject->header = header; }
814 818 QString py_get_header(codeFragment* theWrappedObject){ return theWrappedObject->header; }
815 819 void py_set_size(codeFragment* theWrappedObject, quint64 size){ theWrappedObject->size = size; }
816 820 quint64 py_get_size(codeFragment* theWrappedObject){ return theWrappedObject->size; }
817 821 };
818 822
819 823
820 824
821 825
822 826
823 827 class PythonQtShell_elfFileWidget : public elfFileWidget
824 828 {
825 829 public:
826 830 PythonQtShell_elfFileWidget(QWidget* parent = 0):elfFileWidget(parent),_wrapper(NULL) { };
827 831
828 832 ~PythonQtShell_elfFileWidget();
829 833
830 834 virtual void reloadFile();
831 835 virtual void setFile(abstractBinFile* file);
832 836
833 837 PythonQtInstanceWrapper* _wrapper;
834 838 };
835 839
836 840 class PythonQtPublicPromoter_elfFileWidget : public elfFileWidget
837 841 { public:
838 842 inline void promoted_reloadFile() { elfFileWidget::reloadFile(); }
839 843 inline void promoted_setFile(abstractBinFile* file) { elfFileWidget::setFile(file); }
840 844 };
841 845
842 846 class PythonQtWrapper_elfFileWidget : public QObject
843 847 { Q_OBJECT
844 848 public:
845 849 public slots:
846 850 elfFileWidget* new_elfFileWidget(QWidget* parent = 0);
847 851 void delete_elfFileWidget(elfFileWidget* obj) { delete obj; }
848 852 void reloadFile(elfFileWidget* theWrappedObject);
849 853 void setFile(elfFileWidget* theWrappedObject, abstractBinFile* file);
850 854 };
851 855
852 856
853 857
854 858
855 859
856 860 class PythonQtShell_elfInfoWdgt : public elfInfoWdgt
857 861 {
858 862 public:
859 863 PythonQtShell_elfInfoWdgt(QWidget* parent = 0):elfInfoWdgt(parent),_wrapper(NULL) { };
860 864
861 865 ~PythonQtShell_elfInfoWdgt();
862 866
863 867 virtual void actionEvent(QActionEvent* arg__1);
864 868 virtual void changeEvent(QEvent* arg__1);
865 869 virtual void childEvent(QChildEvent* arg__1);
866 870 virtual void closeEvent(QCloseEvent* arg__1);
867 871 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
868 872 virtual void customEvent(QEvent* arg__1);
869 873 virtual int devType() const;
870 874 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
871 875 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
872 876 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
873 877 virtual void dropEvent(QDropEvent* arg__1);
874 878 virtual void enterEvent(QEvent* arg__1);
875 879 virtual bool event(QEvent* arg__1);
876 880 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
877 881 virtual void focusInEvent(QFocusEvent* arg__1);
878 882 virtual bool focusNextPrevChild(bool next);
879 883 virtual void focusOutEvent(QFocusEvent* arg__1);
880 884 virtual bool hasHeightForWidth() const;
881 885 virtual int heightForWidth(int arg__1) const;
882 886 virtual void hideEvent(QHideEvent* arg__1);
883 887 virtual void initPainter(QPainter* painter) const;
884 888 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
885 889 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
886 890 virtual void keyPressEvent(QKeyEvent* arg__1);
887 891 virtual void keyReleaseEvent(QKeyEvent* arg__1);
888 892 virtual void leaveEvent(QEvent* arg__1);
889 893 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
890 894 virtual QSize minimumSizeHint() const;
891 895 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
892 896 virtual void mouseMoveEvent(QMouseEvent* arg__1);
893 897 virtual void mousePressEvent(QMouseEvent* arg__1);
894 898 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
895 899 virtual void moveEvent(QMoveEvent* arg__1);
896 900 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
897 901 virtual QPaintEngine* paintEngine() const;
898 902 virtual void paintEvent(QPaintEvent* arg__1);
899 903 virtual QPaintDevice* redirected(QPoint* offset) const;
900 904 virtual void resizeEvent(QResizeEvent* arg__1);
901 905 virtual QPainter* sharedPainter() const;
902 906 virtual void showEvent(QShowEvent* arg__1);
903 907 virtual QSize sizeHint() const;
904 908 virtual void tabletEvent(QTabletEvent* arg__1);
905 909 virtual void timerEvent(QTimerEvent* arg__1);
906 910 virtual void wheelEvent(QWheelEvent* arg__1);
907 911
908 912 PythonQtInstanceWrapper* _wrapper;
909 913 };
910 914
911 915 class PythonQtWrapper_elfInfoWdgt : public QObject
912 916 { Q_OBJECT
913 917 public:
914 918 public slots:
915 919 elfInfoWdgt* new_elfInfoWdgt(QWidget* parent = 0);
916 920 void delete_elfInfoWdgt(elfInfoWdgt* obj) { delete obj; }
917 921 };
918 922
919 923
920 924
921 925
922 926
923 927 class PythonQtWrapper_elfparser : public QObject
924 928 { Q_OBJECT
925 929 public:
926 930 public slots:
927 931 elfparser* new_elfparser();
928 932 void delete_elfparser(elfparser* obj) { delete obj; }
929 933 int closeFile(elfparser* theWrappedObject);
930 934 QString getABI(elfparser* theWrappedObject);
931 935 QString getArchitecture(elfparser* theWrappedObject);
932 936 QString getClass(elfparser* theWrappedObject);
933 937 QString getEndianness(elfparser* theWrappedObject);
934 938 qint64 getEntryPointAddress(elfparser* theWrappedObject);
935 939 bool getSectionData(elfparser* theWrappedObject, int index, char** buffer);
936 940 qint64 getSectionDatasz(elfparser* theWrappedObject, int index);
937 941 qint64 getSectionMemsz(elfparser* theWrappedObject, int index);
938 942 QString getSectionName(elfparser* theWrappedObject, int index);
939 943 qint64 getSectionPaddr(elfparser* theWrappedObject, int index);
940 944 QString getSectionType(elfparser* theWrappedObject, int index);
941 945 int getSectioncount(elfparser* theWrappedObject);
942 946 qint64 getSegmentFilesz(elfparser* theWrappedObject, int index);
943 947 QString getSegmentFlags(elfparser* theWrappedObject, int index);
944 948 qint64 getSegmentMemsz(elfparser* theWrappedObject, int index);
945 949 qint64 getSegmentOffset(elfparser* theWrappedObject, int index);
946 950 qint64 getSegmentPaddr(elfparser* theWrappedObject, int index);
947 951 QString getSegmentType(elfparser* theWrappedObject, int index);
948 952 qint64 getSegmentVaddr(elfparser* theWrappedObject, int index);
949 953 int getSegmentcount(elfparser* theWrappedObject);
950 954 QString getType(elfparser* theWrappedObject);
951 955 qint64 getVersion(elfparser* theWrappedObject);
952 956 bool static_elfparser_isElf(const QString& File);
953 957 bool iself(elfparser* theWrappedObject);
954 958 bool isopened(elfparser* theWrappedObject);
955 959 int setFilename(elfparser* theWrappedObject, const QString& name);
956 960 };
957 961
958 962
959 963
960 964
961 965
962 966 class PythonQtShell_genericBinaryFileWidget : public genericBinaryFileWidget
963 967 {
964 968 public:
965 969 PythonQtShell_genericBinaryFileWidget(QWidget* parent = 0):genericBinaryFileWidget(parent),_wrapper(NULL) { };
966 970
967 971 ~PythonQtShell_genericBinaryFileWidget();
968 972
969 973 virtual void actionEvent(QActionEvent* arg__1);
970 974 virtual void changeEvent(QEvent* arg__1);
971 975 virtual void childEvent(QChildEvent* arg__1);
972 976 virtual void closeEvent(QCloseEvent* arg__1);
973 977 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
974 978 virtual void customEvent(QEvent* arg__1);
975 979 virtual int devType() const;
976 980 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
977 981 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
978 982 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
979 983 virtual void dropEvent(QDropEvent* arg__1);
980 984 virtual void enterEvent(QEvent* arg__1);
981 985 virtual bool event(QEvent* arg__1);
982 986 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
983 987 virtual void focusInEvent(QFocusEvent* arg__1);
984 988 virtual bool focusNextPrevChild(bool next);
985 989 virtual void focusOutEvent(QFocusEvent* arg__1);
986 990 virtual bool hasHeightForWidth() const;
987 991 virtual int heightForWidth(int arg__1) const;
988 992 virtual void hideEvent(QHideEvent* arg__1);
989 993 virtual void initPainter(QPainter* painter) const;
990 994 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
991 995 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
992 996 virtual void keyPressEvent(QKeyEvent* arg__1);
993 997 virtual void keyReleaseEvent(QKeyEvent* arg__1);
994 998 virtual void leaveEvent(QEvent* arg__1);
995 999 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
996 1000 virtual QSize minimumSizeHint() const;
997 1001 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
998 1002 virtual void mouseMoveEvent(QMouseEvent* arg__1);
999 1003 virtual void mousePressEvent(QMouseEvent* arg__1);
1000 1004 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
1001 1005 virtual void moveEvent(QMoveEvent* arg__1);
1002 1006 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
1003 1007 virtual QPaintEngine* paintEngine() const;
1004 1008 virtual void paintEvent(QPaintEvent* arg__1);
1005 1009 virtual QPaintDevice* redirected(QPoint* offset) const;
1006 1010 virtual void resizeEvent(QResizeEvent* arg__1);
1007 1011 virtual QPainter* sharedPainter() const;
1008 1012 virtual void showEvent(QShowEvent* arg__1);
1009 1013 virtual QSize sizeHint() const;
1010 1014 virtual void tabletEvent(QTabletEvent* arg__1);
1011 1015 virtual void timerEvent(QTimerEvent* arg__1);
1012 1016 virtual void wheelEvent(QWheelEvent* arg__1);
1013 1017
1014 1018 PythonQtInstanceWrapper* _wrapper;
1015 1019 };
1016 1020
1017 1021 class PythonQtWrapper_genericBinaryFileWidget : public QObject
1018 1022 { Q_OBJECT
1019 1023 public:
1020 1024 public slots:
1021 1025 genericBinaryFileWidget* new_genericBinaryFileWidget(QWidget* parent = 0);
1022 1026 void delete_genericBinaryFileWidget(genericBinaryFileWidget* obj) { delete obj; }
1023 1027 };
1024 1028
1025 1029
1026 1030
1027 1031
1028 1032
1029 1033 class PythonQtShell_srecFile : public srecFile
1030 1034 {
1031 1035 public:
1032 1036 PythonQtShell_srecFile():srecFile(),_wrapper(NULL) { };
1033 1037 PythonQtShell_srecFile(const QString& File):srecFile(File),_wrapper(NULL) { };
1034 1038 PythonQtShell_srecFile(const QStringList& Files):srecFile(Files),_wrapper(NULL) { };
1035 1039
1036 1040 ~PythonQtShell_srecFile();
1037 1041
1038 1042 virtual int closeFile();
1039 1043 virtual QList<codeFragment* > getFragments();
1040 1044 virtual bool isopened();
1041 1045 virtual bool openFile(const QString& File);
1042 1046 virtual bool toBinary(const QString& File);
1043 1047 virtual bool toSrec(const QString& File);
1044 1048
1045 1049 PythonQtInstanceWrapper* _wrapper;
1046 1050 };
1047 1051
1048 1052 class PythonQtPublicPromoter_srecFile : public srecFile
1049 1053 { public:
1050 1054 inline int promoted_closeFile() { return srecFile::closeFile(); }
1051 1055 inline QList<codeFragment* > promoted_getFragments() { return srecFile::getFragments(); }
1052 1056 inline bool promoted_isopened() { return srecFile::isopened(); }
1053 1057 inline bool promoted_openFile(const QString& File) { return srecFile::openFile(File); }
1054 1058 inline bool promoted_toBinary(const QString& File) { return srecFile::toBinary(File); }
1055 1059 inline bool promoted_toSrec(const QString& File) { return srecFile::toSrec(File); }
1056 1060 };
1057 1061
1058 1062 class PythonQtWrapper_srecFile : public QObject
1059 1063 { Q_OBJECT
1060 1064 public:
1061 1065 public slots:
1062 1066 srecFile* new_srecFile();
1063 1067 srecFile* new_srecFile(const QString& File);
1064 1068 srecFile* new_srecFile(const QStringList& Files);
1065 1069 void delete_srecFile(srecFile* obj) { delete obj; }
1066 1070 bool static_srecFile_checkSum(const QString& line);
1067 1071 int closeFile(srecFile* theWrappedObject);
1068 1072 codeFragment* getFragment(srecFile* theWrappedObject, int index);
1069 1073 int getFragmentAddress(srecFile* theWrappedObject, int index);
1070 1074 bool getFragmentData(srecFile* theWrappedObject, int index, char** buffer);
1071 1075 QString getFragmentHeader(srecFile* theWrappedObject, int index);
1072 1076 int getFragmentSize(srecFile* theWrappedObject, int index);
1073 1077 QList<codeFragment* > getFragments(srecFile* theWrappedObject);
1074 1078 int getFragmentsCount(srecFile* theWrappedObject);
1075 1079 bool isSREC(srecFile* theWrappedObject);
1076 1080 bool static_srecFile_isSREC(const QString& File);
1077 1081 bool isopened(srecFile* theWrappedObject);
1078 1082 int lineCount(srecFile* theWrappedObject);
1079 1083 bool mergingRecords(srecFile* theWrappedObject);
1080 1084 bool openFile(srecFile* theWrappedObject, const QString& File);
1081 1085 bool openFiles(srecFile* theWrappedObject, const QStringList& Files);
1082 1086 void setMergingRecords(srecFile* theWrappedObject, bool enabled);
1083 1087 bool toBinary(srecFile* theWrappedObject, const QString& File);
1084 1088 bool static_srecFile_toSrec(QList<codeFragment* > fragments, const QString& File);
1085 1089 bool toSrec(srecFile* theWrappedObject, const QString& File);
1086 1090 };
1087 1091
1088 1092
1089 1093
1090 1094
1091 1095
1092 1096 class PythonQtShell_srecFileWidget : public srecFileWidget
1093 1097 {
1094 1098 public:
1095 1099 PythonQtShell_srecFileWidget(QWidget* parent = 0):srecFileWidget(parent),_wrapper(NULL) { };
1096 1100
1097 1101 ~PythonQtShell_srecFileWidget();
1098 1102
1099 1103 virtual void reloadFile();
1100 1104 virtual void setFile(abstractBinFile* file);
1101 1105
1102 1106 PythonQtInstanceWrapper* _wrapper;
1103 1107 };
1104 1108
1105 1109 class PythonQtPublicPromoter_srecFileWidget : public srecFileWidget
1106 1110 { public:
1107 1111 inline void promoted_reloadFile() { srecFileWidget::reloadFile(); }
1108 1112 inline void promoted_setFile(abstractBinFile* file) { srecFileWidget::setFile(file); }
1109 1113 };
1110 1114
1111 1115 class PythonQtWrapper_srecFileWidget : public QObject
1112 1116 { Q_OBJECT
1113 1117 public:
1114 1118 public slots:
1115 1119 srecFileWidget* new_srecFileWidget(QWidget* parent = 0);
1116 1120 void delete_srecFileWidget(srecFileWidget* obj) { delete obj; }
1117 1121 void reloadFile(srecFileWidget* theWrappedObject);
1118 1122 void setFile(srecFileWidget* theWrappedObject, abstractBinFile* file);
1119 1123 };
1120 1124
1121 1125
Show file before | Show file after | Hide comments
@@ -1,113 +1,123
1 1 #-------------------------------------------------
2 2 #
3 3 # Project created by QtCreator 2011-09-19T22:52:10
4 4 #
5 5 #-------------------------------------------------
6 6 SOCEXPLORER_ROOT = $${PWD}/..
7 7 include(../build_cfg/socexplorer.pri)
8 8
9 9 TARGET = socexplorer$${DEBUG_EXT}
10 10 TEMPLATE = app
11 11 CONFIG += pythonqt
12 12
13 13
14 14 QMAKE_LFLAGS_RELEASE += --enable-auto-import -mstackrealign
15 15 QMAKE_LFLAGS_DEBUG += --enable-auto-import -mstackrealign
16 16
17 17 include ( common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer.pri )
18 18 include ( SocExplorerEngine/pythonQtOut/generated_cpp/PySocExplorerEngine/PySocExplorerEngine.pri )
19 19 include ( SocExplorerEngine/plugins/socexplorerplugin.prf )
20 20
21 21 INCLUDEPATH+=$${PWD} \
22 22 $${PWD}/common \
23 23 $${PWD}/common/qhexedit \
24 24 $${PWD}/common/QCustomPlot \
25 25 $${PWD}/common/genericBinaryFiles \
26 26 $${PWD}/common/genericBinaryFiles/elf \
27 27 $${PWD}/common/genericBinaryFiles/srec \
28 28 $${PWD}/common/genericBinaryFiles/BinFile \
29 29 SocExplorerEngine/engine \
30 30 SocExplorerEngine/pluginloader \
31 31 SocExplorerEngine/pluginsInterface \
32 32 SocExplorerEngine/proxy \
33 33 SocExplorerEngine/pluginManagerWdgt \
34 34 SocExplorerEngine/plugins \
35 35 SocExplorerEngine/RegisterMVS \
36 36 SocExplorerEngine/XmlEngine \
37 37 SocExplorerEngine/SOC \
38 38 SocExplorerEngine/PeripheralWidget/src \
39 39 SocExplorerEngine/memtester
40 40
41 41 win32:INCLUDEPATH+= \
42 42 $${PWD}/common/genericBinaryFiles/elf/libelfWin32/include \
43 43 $${PWD}/common/genericBinaryFiles/elf/libelfWin32/include/libelf \
44 44
45 45
46 46 RC_FILE = ../win32cfg/socexplorer.rc
47 47
48 48
49 49 unix:LIBS+=-L$${SOCEXPLORER_ROOT}/bin/linux -lsocexplorercommon$${DEBUG_EXT} -L$${SOCEXPLORER_ROOT}/bin/linux -lsocexplorerengine$${DEBUG_EXT}
50 50
51 51 win32-g++:LIBS += $${SOCEXPLORER_ROOT}/bin/win32/socexplorercommon$${DEBUG_EXT}.dll $${SOCEXPLORER_ROOT}/bin/win32/socexplorerengine$${DEBUG_EXT}.dll
52 52
53 53
54 54 unix{
55 55 translation.files = $${SOCEXPLORER_ROOT}/translations/socexplorer_fr.qm \
56 56 $${SOCEXPLORER_ROOT}/translations/socexplorer_en.qm
57 57 translation.path = $${SOCEXPLORER_TRANSLATION_INSTALL_PATH}
58 58 target.path = /usr/bin
59 59 INSTALLS += translation target
60 60 }
61 61
62 62 header.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common
63 63 header.files = \
64 64 socexplorer.h
65 65 INSTALLS += header
66 66
67 67
68 68 SOURCES += main.cpp\
69 69 mainwindow.cpp \
70 70 PyWdgt/pythonconsole.cpp \
71 71 PyWdgt/pythonqtscriptingconsoledandd.cpp \
72 72 dockablepluginmanager.cpp \
73 73 toolbar.cpp \
74 74 toolbarcontainer.cpp \
75 75 aboutsocexplorer.cpp \
76 76 regsExplorer/regsexplorer.cpp
77 77
78 78 HEADERS += mainwindow.h \
79 79 PyWdgt/pythonconsole.h \
80 80 PyWdgt/pythonqtscriptingconsoledandd.h \
81 81 dockablepluginmanager.h \
82 82 toolbar.h \
83 83 toolbarcontainer.h \
84 84 socexplorer.h \
85 85 SocExplorerEngine/plugins/socexplorerplugin.h \
86 86 aboutsocexplorer.h \
87 87 regsExplorer/regsexplorer.h
88 88
89 89
90 90 include ( NicePyConsole/NicePyConsole.pri)
91 91
92 92 win32{
93 93 RESOURCES = ../ressources/SocExplorer.qrc
94 94 }
95 95
96 96 unix{
97 97 RESOURCES = ../ressources/SocExplorer.qrc
98 98 }
99 99
100 100 TRANSLATIONS = ../translations/socexplorer_fr.ts \
101 101 ../translations/socexplorer_en.ts
102 102
103 103 FORMS += \
104 104 regsExplorer/regsexplorernew.ui
105 105
106 DISTFILES += \
107 ../doc/PythonExamples/LEON3_LOAD.py \
108 ../doc/PythonExamples/PythonPlugin.py \
109 ../doc/PythonExamples/simpledemo1.py \
110 ../doc/PythonExamples/SocExplorerPlot.py \
111 ../doc/PythonExamples/SocExplorerPlot2.py \
112 ../doc/PythonExamples/SocExplorerPlot3.py \
113 ../doc/PythonExamples/tcpterminaldemo.py \
114 ../doc/PythonExamples/tcpterminaldemo2.py
106 115
107 116
108 117
109 118
110 119
111 120
112 121
113 122
123
General Comments 0
You need to be logged in to leave comments. Login now