##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » SocExplorer
RSS
SREC file perser WIP.
jeandet -
r44:81145171ec94 default
parent child
Show More
Show file before | Show file after | Hide comments
@@ -0,0 +1,154
1 #include "srecfile.h"
2
3 srecFile::srecFile()
4 {
5 }
6
7 srecFile::srecFile(const QString &File)
8 {
9 openFile(File);
10 }
11
12 srecFile::srecFile(const QStringList &Files)
13 {
14 openFiles(Files);
15 }
16
17 srecFile::~srecFile()
18 {
19
20 }
21
22 bool srecFile::openFile(const QString &File)
23 {
24 openFiles(QStringList()<<File);
25 }
26
27 bool srecFile::openFiles(const QStringList &Files)
28 {
29 this->p_fileNames.clear();
30 this->p_fileNames.append(Files);
31 for(int i=0;i<p_files.count();i++)
32 {
33 delete p_files.at(i);
34 }
35 this->p_files.clear();
36 for(int i=0;i<Files.count();i++)
37 {
38 this->p_files.append(new QFile(Files.at(i)));
39 this->p_files.at(i)->open(QIODevice::ReadOnly);
40 parseFile(this->p_files.at(i));
41 }
42 }
43
44 bool srecFile::isopened()
45 {
46 bool opened = true;
47 for(int i=0;i<this->p_files.count();i++)
48 {
49 opened &= p_files.at(i)->isOpen();
50 }
51 return opened;
52 }
53
54 int srecFile::closeFile()
55 {
56
57 }
58
59 QList<codeFragment *> srecFile::getFragments()
60 {
61 return p_fragments;
62 }
63
64 void srecFile::parseFile(QFile *file)
65 {
66 if(file->isOpen())
67 {
68 file->seek(0);
69 codeFragment* fragment=NULL;
70 QByteArray data;
71 quint32 size=0;
72 quint32 address=0;
73 while (!file->atEnd())
74 {
75 QString line = file->readLine();
76 if(line.count()>4)
77 {
78 if(line.at(0)=='S')
79 {
80 bool ok;
81 int count = line.mid(2,2).toInt(&ok,16);
82 if(line.at(1)=='0')
83 {
84 }
85 if(line.at(1)=='1')
86 {
87 }
88 if(line.at(1)=='2')
89 {
90
91 }
92 if(line.at(1)=='3')
93 {
94 int naddress =line.mid(4,8).toInt(&ok,16);
95 if(address !=naddress)
96 {
97 if(fragment!=NULL)
98 {
99 fragment->size = data.size();
100 fragment->data = (char*)malloc(data.size());
101 for(int i =0;i<data.size();i++)
102 {
103 fragment->data[i]=data.at(i);
104 }
105 data.clear();
106 p_fragments.append(fragment);
107 }
108 fragment = new codeFragment();
109 fragment->address = naddress;
110 }
111 address = naddress+count-5;
112 for(int i=0;i<(count-5);i++)
113 {
114 data.append((char)line.mid((2*i)+8,2).toInt(&ok,16));
115 }
116 }
117 if(line.at(1)=='5')
118 {
119
120 }
121 if(line.at(1)=='6')
122 {
123
124 }
125 if(line.at(1)=='7')
126 {
127
128 }
129 if(line.at(1)=='8')
130 {
131
132 }
133 if(line.at(1)=='9')
134 {
135
136 }
137 }
138 }
139 }
140 if(data.size()!=0)
141 {
142 fragment->size = data.size();
143 fragment->data = (char*)malloc(data.size());
144 for(int i =0;i<data.size();i++)
145 {
146 fragment->data[i]=data.at(i);
147 }
148 data.clear();
149 p_fragments.append(fragment);
150 }
151
152 }
153 }
154
Show file before | Show file after | Hide comments
@@ -0,0 +1,34
1 #ifndef SRECFILE_H
2 #define SRECFILE_H
3
4 #include <QObject>
5 #include <abstractexecfile.h>
6 #include <QFile>
7 #include <QStringList>
8
9 class srecFile : public abstractExecFile
10 {
11 Q_OBJECT
12 public:
13 explicit srecFile();
14 srecFile(const QString& File);
15 srecFile(const QStringList& Files);
16 ~srecFile();
17 bool openFile(const QString& File);
18 bool openFiles(const QStringList& Files);
19 bool isopened();
20 int closeFile();
21 QList<codeFragment*> getFragments();
22
23 signals:
24
25 public slots:
26 private:
27 void parseFile(QFile* file);
28 QStringList p_fileNames;
29 QList<QFile*>p_files;
30 QList<codeFragment*> p_fragments;
31
32 };
33
34 #endif // SRECFILE_H
Show file before | Show file after | Hide comments
@@ -1,13 +1,14
1 1 #include <QtCore/QObject>
2 2 #include <QtWidgets/QtWidgets>
3 3 #include "qhexspinbox.h"
4 4 #include "memsizewdgt.h"
5 5 #include "qhexedit/qhexedit.h"
6 6 #include "SocExplorerPlot.h"
7 7 #include "tcp_terminal_client.h"
8 8 #include "elf/elfparser.h"
9 9 #include "abstractexecfile.h"
10 10 #include "elf/elffile.h"
11 11 #include "elf/elffilewidget.h"
12 12 #include "elf/elfinfowdgt.h"
13 13 #include "QCustomPlot/qcustomplot.h"
14 #include "srec/srecfile.h"
Show file before | Show file after | Hide comments
@@ -1,51 +1,51
1 1 /*------------------------------------------------------------------------------
2 2 -- This file is a part of the SocExplorer Software
3 3 -- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
4 4 --
5 5 -- This program is free software; you can redistribute it and/or modify
6 6 -- it under the terms of the GNU General Public License as published by
7 7 -- the Free Software Foundation; either version 2 of the License, or
8 8 -- (at your option) any later version.
9 9 --
10 10 -- This program is distributed in the hope that it will be useful,
11 11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 13 -- GNU General Public License for more details.
14 14 --
15 15 -- You should have received a copy of the GNU General Public License
16 16 -- along with this program; if not, write to the Free Software
17 17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 18 -------------------------------------------------------------------------------*/
19 19 /*-- Author : Alexis Jeandet
20 20 -- Mail : alexis.jeandet@member.fsf.org
21 21 ----------------------------------------------------------------------------*/
22 22 #ifndef ABSTRACTEXECFILE_H
23 23 #define ABSTRACTEXECFILE_H
24 24
25 25 #include <QtCore/QObject>
26 26
27 27 class codeFragment
28 28 {
29 29 public:
30 30 codeFragment();
31 31 codeFragment(char* data, quint32 size, quint32 address):data(data),size(size),address(address){}
32 32 char* data;
33 33 quint32 size;
34 34 quint32 address;
35 35 };
36 36
37 37 class abstractExecFile : public QObject
38 38 {
39 39 Q_OBJECT
40 40 public:
41 41 // virtual abstractExecFile()=0;
42 42 virtual bool openFile(const QString& File)=0;
43 43 virtual bool isopened()=0;
44 44 virtual int closeFile()=0;
45 45 virtual QList<codeFragment*> getFragments()=0;
46 46
47 47 protected:
48 QString p_fileName;
48 QString p_fileName;
49 49 };
50 50
51 51 #endif // ABSTRACTEXECFILE_H
Show file before | Show file after | Hide comments
@@ -1,120 +1,123
1 1 SOCEXPLORER_ROOT = \"$${PWD}/../..\"
2 2 include($${PWD}/../../build_cfg/socexplorer.pri)
3 3 include($${PWD}/lppserial/lppserial.pri)
4 4
5 5 TEMPLATE = lib
6 6 TARGET = socexplorercommon$${DEBUG_EXT}
7 7
8 8 win32:CONFIG += dll
9 9 win32:CONFIG -= static
10 10
11 11 win32:INCLUDEPATH += $${PWD}/elf/libelfWin32/include
12 12 win32:INCLUDEPATH += $${PWD}/elf/libelfWin32/include/libelf
13 13 win32:DEFINES+=_ELF_WINDOWS_
14 14 DEFINES+=RS232_debug
15 15
16 16 win32:LIBS += $${PWD}/elf/libelfWin32/bin/libelf.a
17 17 unix:LIBS += -lelf
18 18
19 19 QMAKE_LFLAGS_RELEASE += --enable-auto-import
20 20 QMAKE_LFLAGS_DEBUG += --enable-auto-import
21 21
22 22 target.path = $$[QT_INSTALL_LIBS]
23 23 isEmpty(target.path) {
24 24 error(can\'t get QT_INSTALL_LIBS)
25 25 }
26 26
27 27 header.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common
28 28 header.files = \
29 29 memsizewdgt.h \
30 30 qhexspinbox.h \
31 31 qsvgicon.h \
32 32 qhexedit/qhexedit_p.h \
33 33 qhexedit/qhexedit.h \
34 34 qhexedit/xbytearray.h \
35 35 QCustomPlot/qcustomplot.h \
36 36 SocExplorerPlot.h \
37 37 tcp_terminal_client.h \
38 38 elf/elfinfowdgt.h \
39 39 elf/elfparser.h \
40 40 elf/elffile.h \
41 41 elf/elffilewidget.h \
42 42 qipdialogbox.h \
43 43 lppserial/src/RS232.h \
44 qtablewidgetintitem.h
44 qtablewidgetintitem.h \
45 srec/srecfile.h
45 46
46 47 win32{
47 48 elfheader.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common/libelf
48 49 elfheader.files += \
49 50 elf/libelfWin32/include/libelf/byteswap.h \
50 51 elf/libelfWin32/include/libelf/errors.h \
51 52 elf/libelfWin32/include/libelf/gelf.h \
52 53 elf/libelfWin32/include/libelf/nlist.h \
53 54 elf/libelfWin32/include/libelf/sys_elf.h \
54 55 elf/libelfWin32/include/libelf/verneed.h \
55 56 elf/libelfWin32/include/libelf/elf_repl.h \
56 57 elf/libelfWin32/include/libelf/ext_types.h \
57 58 elf/libelfWin32/include/libelf/libelf.h \
58 59 elf/libelfWin32/include/libelf/private.h \
59 60 elf/libelfWin32/include/libelf/verdef.h
60 61 INSTALLS += elfheader
61 62 }
62 63
63 64
64 65 isEmpty(header.path) {
65 66 error(can\'t get QT_INSTALL_HEADERS)
66 67 }
67 68
68 69 INSTALLS += target header
69 70
70 71 INCLUDEPATH += QCustomPlot qhexedit
71 72
72 73 HEADERS += \
73 74 memsizewdgt.h \
74 75 qhexspinbox.h \
75 76 qsvgicon.h \
76 77 qhexedit/qhexedit_p.h \
77 78 qhexedit/qhexedit.h \
78 79 qhexedit/xbytearray.h \
79 80 qhexedit/commands.h \
80 81 QCustomPlot/qcustomplot.h \
81 82 tcp_terminal_client.h \
82 83 elf/elfinfowdgt.h \
83 84 elf/elfparser.h \
84 85 abstractexecfile.h \
85 86 elf/elffile.h \
86 87 qipdialogbox.h \
87 88 PySocExplorer.h \
88 89 SocExplorerPlot.h \
89 90 elf/elffilewidget.h \
90 qtablewidgetintitem.h
91 qtablewidgetintitem.h \
92 srec/srecfile.h
91 93
92 94
93 95 SOURCES += \
94 96 memsizewdgt.cpp \
95 97 qhexspinbox.cpp \
96 98 qsvgicon.cpp \
97 99 qhexedit/qhexedit_p.cpp \
98 100 qhexedit/qhexedit.cpp \
99 101 qhexedit/xbytearray.cpp \
100 102 qhexedit/commands.cpp \
101 103 QCustomPlot/qcustomplot.cpp \
102 104 tcp_terminal_client.cpp \
103 105 elf/elfinfowdgt.cpp \
104 106 elf/elfparser.cpp \
105 107 abstractexecfile.cpp \
106 108 elf/elffile.cpp \
107 109 qipdialogbox.cpp \
108 110 SocExplorerPlot.cpp \
109 111 elf/elffilewidget.cpp \
110 qtablewidgetintitem.cpp
112 qtablewidgetintitem.cpp \
113 srec/srecfile.cpp
111 114
112 115 FORMS += \
113 116 elf/elffilewidget.ui
114 117
115 118 OTHER_FILES += \
116 119 ./pythongenerator.sh \
117 120 ./pythonQtgeneratorCfg.txt
118 121
119 122
120 123
Show file before | Show file after | Hide comments
@@ -1,6912 +1,7068
1 1 #include "PySocExplorer0.h"
2 2 #include <PythonQtConversion.h>
3 3 #include <PythonQtMethodInfo.h>
4 4 #include <PythonQtSignalReceiver.h>
5 5 #include <QIconEngine>
6 6 #include <QObject>
7 7 #include <QSpinBox>
8 8 #include <QVariant>
9 9 #include <QWidget>
10 10 #include <abstractexecfile.h>
11 11 #include <elffile.h>
12 12 #include <elfparser.h>
13 13 #include <qaction.h>
14 14 #include <qbitmap.h>
15 15 #include <qbytearray.h>
16 16 #include <qcolor.h>
17 17 #include <qcoreevent.h>
18 18 #include <qcursor.h>
19 19 #include <qevent.h>
20 #include <qfile.h>
20 21 #include <qfont.h>
21 22 #include <qgraphicseffect.h>
22 23 #include <qgraphicsproxywidget.h>
23 24 #include <qkeysequence.h>
24 25 #include <qlayout.h>
25 26 #include <qlineedit.h>
26 27 #include <qlist.h>
27 28 #include <qlocale.h>
28 29 #include <qmargins.h>
29 30 #include <qobject.h>
30 31 #include <qpaintdevice.h>
31 32 #include <qpaintengine.h>
32 33 #include <qpainter.h>
33 34 #include <qpalette.h>
34 35 #include <qpen.h>
35 36 #include <qpixmap.h>
36 37 #include <qpoint.h>
37 38 #include <qrect.h>
38 39 #include <qregion.h>
39 40 #include <qscrollarea.h>
40 41 #include <qscrollbar.h>
41 42 #include <qsize.h>
42 43 #include <qsizepolicy.h>
43 44 #include <qspinbox.h>
44 45 #include <qstringlist.h>
45 46 #include <qstyle.h>
46 47 #include <qstyleoption.h>
47 48 #include <qwidget.h>
48 49
49 50 PythonQtShell_ElfFile::~PythonQtShell_ElfFile() {
50 51 PythonQtPrivate* priv = PythonQt::priv();
51 52 if (priv) { priv->shellClassDeleted(this); }
52 53 }
53 54 int PythonQtShell_ElfFile::closeFile()
54 55 {
55 56 if (_wrapper) {
56 57 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
57 58 PyErr_Clear();
58 59 if (obj && !PythonQtSlotFunction_Check(obj)) {
59 60 static const char* argumentList[] ={"int"};
60 61 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
61 62 int returnValue;
62 63 void* args[1] = {NULL};
63 64 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
64 65 if (result) {
65 66 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
66 67 if (args[0]!=&returnValue) {
67 68 if (args[0]==NULL) {
68 69 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
69 70 } else {
70 71 returnValue = *((int*)args[0]);
71 72 }
72 73 }
73 74 }
74 75 if (result) { Py_DECREF(result); }
75 76 Py_DECREF(obj);
76 77 return returnValue;
77 78 }
78 79 }
79 80 return ElfFile::closeFile();
80 81 }
81 82 QList<codeFragment* > PythonQtShell_ElfFile::getFragments()
82 83 {
83 84 if (_wrapper) {
84 85 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
85 86 PyErr_Clear();
86 87 if (obj && !PythonQtSlotFunction_Check(obj)) {
87 88 static const char* argumentList[] ={"QList<codeFragment* >"};
88 89 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
89 90 QList<codeFragment* > returnValue;
90 91 void* args[1] = {NULL};
91 92 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
92 93 if (result) {
93 94 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
94 95 if (args[0]!=&returnValue) {
95 96 if (args[0]==NULL) {
96 97 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
97 98 } else {
98 99 returnValue = *((QList<codeFragment* >*)args[0]);
99 100 }
100 101 }
101 102 }
102 103 if (result) { Py_DECREF(result); }
103 104 Py_DECREF(obj);
104 105 return returnValue;
105 106 }
106 107 }
107 108 return ElfFile::getFragments();
108 109 }
109 110 bool PythonQtShell_ElfFile::isopened()
110 111 {
111 112 if (_wrapper) {
112 113 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
113 114 PyErr_Clear();
114 115 if (obj && !PythonQtSlotFunction_Check(obj)) {
115 116 static const char* argumentList[] ={"bool"};
116 117 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
117 118 bool returnValue;
118 119 void* args[1] = {NULL};
119 120 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
120 121 if (result) {
121 122 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
122 123 if (args[0]!=&returnValue) {
123 124 if (args[0]==NULL) {
124 125 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
125 126 } else {
126 127 returnValue = *((bool*)args[0]);
127 128 }
128 129 }
129 130 }
130 131 if (result) { Py_DECREF(result); }
131 132 Py_DECREF(obj);
132 133 return returnValue;
133 134 }
134 135 }
135 136 return ElfFile::isopened();
136 137 }
137 138 bool PythonQtShell_ElfFile::openFile(const QString& File)
138 139 {
139 140 if (_wrapper) {
140 141 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
141 142 PyErr_Clear();
142 143 if (obj && !PythonQtSlotFunction_Check(obj)) {
143 144 static const char* argumentList[] ={"bool" , "const QString&"};
144 145 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
145 146 bool returnValue;
146 147 void* args[2] = {NULL, (void*)&File};
147 148 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
148 149 if (result) {
149 150 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
150 151 if (args[0]!=&returnValue) {
151 152 if (args[0]==NULL) {
152 153 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
153 154 } else {
154 155 returnValue = *((bool*)args[0]);
155 156 }
156 157 }
157 158 }
158 159 if (result) { Py_DECREF(result); }
159 160 Py_DECREF(obj);
160 161 return returnValue;
161 162 }
162 163 }
163 164 return ElfFile::openFile(File);
164 165 }
165 166 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile()
166 167 {
167 168 return new PythonQtShell_ElfFile(); }
168 169
169 170 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile(const QString& File)
170 171 {
171 172 return new PythonQtShell_ElfFile(File); }
172 173
173 174 int PythonQtWrapper_ElfFile::closeFile(ElfFile* theWrappedObject)
174 175 {
175 176 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_closeFile());
176 177 }
177 178
178 179 QString PythonQtWrapper_ElfFile::getABI(ElfFile* theWrappedObject)
179 180 {
180 181 return ( theWrappedObject->getABI());
181 182 }
182 183
183 184 QString PythonQtWrapper_ElfFile::getArchitecture(ElfFile* theWrappedObject)
184 185 {
185 186 return ( theWrappedObject->getArchitecture());
186 187 }
187 188
188 189 QString PythonQtWrapper_ElfFile::getClass(ElfFile* theWrappedObject)
189 190 {
190 191 return ( theWrappedObject->getClass());
191 192 }
192 193
193 194 QString PythonQtWrapper_ElfFile::getEndianness(ElfFile* theWrappedObject)
194 195 {
195 196 return ( theWrappedObject->getEndianness());
196 197 }
197 198
198 199 qint64 PythonQtWrapper_ElfFile::getEntryPointAddress(ElfFile* theWrappedObject)
199 200 {
200 201 return ( theWrappedObject->getEntryPointAddress());
201 202 }
202 203
203 204 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject)
204 205 {
205 206 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_getFragments());
206 207 }
207 208
208 209 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject, QStringList fragmentList)
209 210 {
210 211 return ( theWrappedObject->getFragments(fragmentList));
211 212 }
212 213
213 214 int PythonQtWrapper_ElfFile::getSectionCount(ElfFile* theWrappedObject)
214 215 {
215 216 return ( theWrappedObject->getSectionCount());
216 217 }
217 218
218 219 bool PythonQtWrapper_ElfFile::getSectionData(ElfFile* theWrappedObject, int index, char** buffer)
219 220 {
220 221 return ( theWrappedObject->getSectionData(index, buffer));
221 222 }
222 223
223 224 qint64 PythonQtWrapper_ElfFile::getSectionDatasz(ElfFile* theWrappedObject, int index)
224 225 {
225 226 return ( theWrappedObject->getSectionDatasz(index));
226 227 }
227 228
228 229 int PythonQtWrapper_ElfFile::getSectionIndex(ElfFile* theWrappedObject, QString name)
229 230 {
230 231 return ( theWrappedObject->getSectionIndex(name));
231 232 }
232 233
233 234 qint64 PythonQtWrapper_ElfFile::getSectionMemsz(ElfFile* theWrappedObject, int index)
234 235 {
235 236 return ( theWrappedObject->getSectionMemsz(index));
236 237 }
237 238
238 239 QString PythonQtWrapper_ElfFile::getSectionName(ElfFile* theWrappedObject, int index)
239 240 {
240 241 return ( theWrappedObject->getSectionName(index));
241 242 }
242 243
243 244 qint64 PythonQtWrapper_ElfFile::getSectionPaddr(ElfFile* theWrappedObject, int index)
244 245 {
245 246 return ( theWrappedObject->getSectionPaddr(index));
246 247 }
247 248
248 249 QString PythonQtWrapper_ElfFile::getSectionType(ElfFile* theWrappedObject, int index)
249 250 {
250 251 return ( theWrappedObject->getSectionType(index));
251 252 }
252 253
253 254 int PythonQtWrapper_ElfFile::getSegmentCount(ElfFile* theWrappedObject)
254 255 {
255 256 return ( theWrappedObject->getSegmentCount());
256 257 }
257 258
258 259 qint64 PythonQtWrapper_ElfFile::getSegmentFilesz(ElfFile* theWrappedObject, int index)
259 260 {
260 261 return ( theWrappedObject->getSegmentFilesz(index));
261 262 }
262 263
263 264 QString PythonQtWrapper_ElfFile::getSegmentFlags(ElfFile* theWrappedObject, int index)
264 265 {
265 266 return ( theWrappedObject->getSegmentFlags(index));
266 267 }
267 268
268 269 qint64 PythonQtWrapper_ElfFile::getSegmentMemsz(ElfFile* theWrappedObject, int index)
269 270 {
270 271 return ( theWrappedObject->getSegmentMemsz(index));
271 272 }
272 273
273 274 qint64 PythonQtWrapper_ElfFile::getSegmentOffset(ElfFile* theWrappedObject, int index)
274 275 {
275 276 return ( theWrappedObject->getSegmentOffset(index));
276 277 }
277 278
278 279 qint64 PythonQtWrapper_ElfFile::getSegmentPaddr(ElfFile* theWrappedObject, int index)
279 280 {
280 281 return ( theWrappedObject->getSegmentPaddr(index));
281 282 }
282 283
283 284 QString PythonQtWrapper_ElfFile::getSegmentType(ElfFile* theWrappedObject, int index)
284 285 {
285 286 return ( theWrappedObject->getSegmentType(index));
286 287 }
287 288
288 289 qint64 PythonQtWrapper_ElfFile::getSegmentVaddr(ElfFile* theWrappedObject, int index)
289 290 {
290 291 return ( theWrappedObject->getSegmentVaddr(index));
291 292 }
292 293
293 294 quint64 PythonQtWrapper_ElfFile::getSymbolAddress(ElfFile* theWrappedObject, int index)
294 295 {
295 296 return ( theWrappedObject->getSymbolAddress(index));
296 297 }
297 298
298 299 int PythonQtWrapper_ElfFile::getSymbolCount(ElfFile* theWrappedObject)
299 300 {
300 301 return ( theWrappedObject->getSymbolCount());
301 302 }
302 303
303 304 QString PythonQtWrapper_ElfFile::getSymbolLinkType(ElfFile* theWrappedObject, int index)
304 305 {
305 306 return ( theWrappedObject->getSymbolLinkType(index));
306 307 }
307 308
308 309 QString PythonQtWrapper_ElfFile::getSymbolName(ElfFile* theWrappedObject, int index)
309 310 {
310 311 return ( theWrappedObject->getSymbolName(index));
311 312 }
312 313
313 314 int PythonQtWrapper_ElfFile::getSymbolSectionIndex(ElfFile* theWrappedObject, int index)
314 315 {
315 316 return ( theWrappedObject->getSymbolSectionIndex(index));
316 317 }
317 318
318 319 QString PythonQtWrapper_ElfFile::getSymbolSectionName(ElfFile* theWrappedObject, int index)
319 320 {
320 321 return ( theWrappedObject->getSymbolSectionName(index));
321 322 }
322 323
323 324 quint64 PythonQtWrapper_ElfFile::getSymbolSize(ElfFile* theWrappedObject, int index)
324 325 {
325 326 return ( theWrappedObject->getSymbolSize(index));
326 327 }
327 328
328 329 QString PythonQtWrapper_ElfFile::getSymbolType(ElfFile* theWrappedObject, int index)
329 330 {
330 331 return ( theWrappedObject->getSymbolType(index));
331 332 }
332 333
333 334 QString PythonQtWrapper_ElfFile::getType(ElfFile* theWrappedObject)
334 335 {
335 336 return ( theWrappedObject->getType());
336 337 }
337 338
338 339 qint64 PythonQtWrapper_ElfFile::getVersion(ElfFile* theWrappedObject)
339 340 {
340 341 return ( theWrappedObject->getVersion());
341 342 }
342 343
343 344 bool PythonQtWrapper_ElfFile::static_ElfFile_isElf(const QString& File)
344 345 {
345 346 return (ElfFile::isElf(File));
346 347 }
347 348
348 349 bool PythonQtWrapper_ElfFile::iself(ElfFile* theWrappedObject)
349 350 {
350 351 return ( theWrappedObject->iself());
351 352 }
352 353
353 354 bool PythonQtWrapper_ElfFile::isopened(ElfFile* theWrappedObject)
354 355 {
355 356 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_isopened());
356 357 }
357 358
358 359 bool PythonQtWrapper_ElfFile::openFile(ElfFile* theWrappedObject, const QString& File)
359 360 {
360 361 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_openFile(File));
361 362 }
362 363
363 364
364 365
365 366 PythonQtShell_MemSizeWdgt::~PythonQtShell_MemSizeWdgt() {
366 367 PythonQtPrivate* priv = PythonQt::priv();
367 368 if (priv) { priv->shellClassDeleted(this); }
368 369 }
369 370 void PythonQtShell_MemSizeWdgt::actionEvent(QActionEvent* arg__1)
370 371 {
371 372 if (_wrapper) {
372 373 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
373 374 PyErr_Clear();
374 375 if (obj && !PythonQtSlotFunction_Check(obj)) {
375 376 static const char* argumentList[] ={"" , "QActionEvent*"};
376 377 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
377 378 void* args[2] = {NULL, (void*)&arg__1};
378 379 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
379 380 if (result) { Py_DECREF(result); }
380 381 Py_DECREF(obj);
381 382 return;
382 383 }
383 384 }
384 385 MemSizeWdgt::actionEvent(arg__1);
385 386 }
386 387 void PythonQtShell_MemSizeWdgt::changeEvent(QEvent* arg__1)
387 388 {
388 389 if (_wrapper) {
389 390 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
390 391 PyErr_Clear();
391 392 if (obj && !PythonQtSlotFunction_Check(obj)) {
392 393 static const char* argumentList[] ={"" , "QEvent*"};
393 394 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
394 395 void* args[2] = {NULL, (void*)&arg__1};
395 396 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
396 397 if (result) { Py_DECREF(result); }
397 398 Py_DECREF(obj);
398 399 return;
399 400 }
400 401 }
401 402 MemSizeWdgt::changeEvent(arg__1);
402 403 }
403 404 void PythonQtShell_MemSizeWdgt::childEvent(QChildEvent* arg__1)
404 405 {
405 406 if (_wrapper) {
406 407 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
407 408 PyErr_Clear();
408 409 if (obj && !PythonQtSlotFunction_Check(obj)) {
409 410 static const char* argumentList[] ={"" , "QChildEvent*"};
410 411 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
411 412 void* args[2] = {NULL, (void*)&arg__1};
412 413 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
413 414 if (result) { Py_DECREF(result); }
414 415 Py_DECREF(obj);
415 416 return;
416 417 }
417 418 }
418 419 MemSizeWdgt::childEvent(arg__1);
419 420 }
420 421 void PythonQtShell_MemSizeWdgt::closeEvent(QCloseEvent* arg__1)
421 422 {
422 423 if (_wrapper) {
423 424 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
424 425 PyErr_Clear();
425 426 if (obj && !PythonQtSlotFunction_Check(obj)) {
426 427 static const char* argumentList[] ={"" , "QCloseEvent*"};
427 428 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
428 429 void* args[2] = {NULL, (void*)&arg__1};
429 430 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
430 431 if (result) { Py_DECREF(result); }
431 432 Py_DECREF(obj);
432 433 return;
433 434 }
434 435 }
435 436 MemSizeWdgt::closeEvent(arg__1);
436 437 }
437 438 void PythonQtShell_MemSizeWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
438 439 {
439 440 if (_wrapper) {
440 441 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
441 442 PyErr_Clear();
442 443 if (obj && !PythonQtSlotFunction_Check(obj)) {
443 444 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
444 445 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
445 446 void* args[2] = {NULL, (void*)&arg__1};
446 447 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
447 448 if (result) { Py_DECREF(result); }
448 449 Py_DECREF(obj);
449 450 return;
450 451 }
451 452 }
452 453 MemSizeWdgt::contextMenuEvent(arg__1);
453 454 }
454 455 void PythonQtShell_MemSizeWdgt::customEvent(QEvent* arg__1)
455 456 {
456 457 if (_wrapper) {
457 458 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
458 459 PyErr_Clear();
459 460 if (obj && !PythonQtSlotFunction_Check(obj)) {
460 461 static const char* argumentList[] ={"" , "QEvent*"};
461 462 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
462 463 void* args[2] = {NULL, (void*)&arg__1};
463 464 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
464 465 if (result) { Py_DECREF(result); }
465 466 Py_DECREF(obj);
466 467 return;
467 468 }
468 469 }
469 470 MemSizeWdgt::customEvent(arg__1);
470 471 }
471 472 int PythonQtShell_MemSizeWdgt::devType() const
472 473 {
473 474 if (_wrapper) {
474 475 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
475 476 PyErr_Clear();
476 477 if (obj && !PythonQtSlotFunction_Check(obj)) {
477 478 static const char* argumentList[] ={"int"};
478 479 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
479 480 int returnValue;
480 481 void* args[1] = {NULL};
481 482 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
482 483 if (result) {
483 484 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
484 485 if (args[0]!=&returnValue) {
485 486 if (args[0]==NULL) {
486 487 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
487 488 } else {
488 489 returnValue = *((int*)args[0]);
489 490 }
490 491 }
491 492 }
492 493 if (result) { Py_DECREF(result); }
493 494 Py_DECREF(obj);
494 495 return returnValue;
495 496 }
496 497 }
497 498 return MemSizeWdgt::devType();
498 499 }
499 500 void PythonQtShell_MemSizeWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
500 501 {
501 502 if (_wrapper) {
502 503 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
503 504 PyErr_Clear();
504 505 if (obj && !PythonQtSlotFunction_Check(obj)) {
505 506 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
506 507 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
507 508 void* args[2] = {NULL, (void*)&arg__1};
508 509 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
509 510 if (result) { Py_DECREF(result); }
510 511 Py_DECREF(obj);
511 512 return;
512 513 }
513 514 }
514 515 MemSizeWdgt::dragEnterEvent(arg__1);
515 516 }
516 517 void PythonQtShell_MemSizeWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
517 518 {
518 519 if (_wrapper) {
519 520 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
520 521 PyErr_Clear();
521 522 if (obj && !PythonQtSlotFunction_Check(obj)) {
522 523 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
523 524 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
524 525 void* args[2] = {NULL, (void*)&arg__1};
525 526 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
526 527 if (result) { Py_DECREF(result); }
527 528 Py_DECREF(obj);
528 529 return;
529 530 }
530 531 }
531 532 MemSizeWdgt::dragLeaveEvent(arg__1);
532 533 }
533 534 void PythonQtShell_MemSizeWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
534 535 {
535 536 if (_wrapper) {
536 537 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
537 538 PyErr_Clear();
538 539 if (obj && !PythonQtSlotFunction_Check(obj)) {
539 540 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
540 541 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
541 542 void* args[2] = {NULL, (void*)&arg__1};
542 543 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
543 544 if (result) { Py_DECREF(result); }
544 545 Py_DECREF(obj);
545 546 return;
546 547 }
547 548 }
548 549 MemSizeWdgt::dragMoveEvent(arg__1);
549 550 }
550 551 void PythonQtShell_MemSizeWdgt::dropEvent(QDropEvent* arg__1)
551 552 {
552 553 if (_wrapper) {
553 554 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
554 555 PyErr_Clear();
555 556 if (obj && !PythonQtSlotFunction_Check(obj)) {
556 557 static const char* argumentList[] ={"" , "QDropEvent*"};
557 558 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
558 559 void* args[2] = {NULL, (void*)&arg__1};
559 560 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
560 561 if (result) { Py_DECREF(result); }
561 562 Py_DECREF(obj);
562 563 return;
563 564 }
564 565 }
565 566 MemSizeWdgt::dropEvent(arg__1);
566 567 }
567 568 void PythonQtShell_MemSizeWdgt::enterEvent(QEvent* arg__1)
568 569 {
569 570 if (_wrapper) {
570 571 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
571 572 PyErr_Clear();
572 573 if (obj && !PythonQtSlotFunction_Check(obj)) {
573 574 static const char* argumentList[] ={"" , "QEvent*"};
574 575 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
575 576 void* args[2] = {NULL, (void*)&arg__1};
576 577 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
577 578 if (result) { Py_DECREF(result); }
578 579 Py_DECREF(obj);
579 580 return;
580 581 }
581 582 }
582 583 MemSizeWdgt::enterEvent(arg__1);
583 584 }
584 585 bool PythonQtShell_MemSizeWdgt::event(QEvent* arg__1)
585 586 {
586 587 if (_wrapper) {
587 588 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
588 589 PyErr_Clear();
589 590 if (obj && !PythonQtSlotFunction_Check(obj)) {
590 591 static const char* argumentList[] ={"bool" , "QEvent*"};
591 592 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
592 593 bool returnValue;
593 594 void* args[2] = {NULL, (void*)&arg__1};
594 595 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
595 596 if (result) {
596 597 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
597 598 if (args[0]!=&returnValue) {
598 599 if (args[0]==NULL) {
599 600 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
600 601 } else {
601 602 returnValue = *((bool*)args[0]);
602 603 }
603 604 }
604 605 }
605 606 if (result) { Py_DECREF(result); }
606 607 Py_DECREF(obj);
607 608 return returnValue;
608 609 }
609 610 }
610 611 return MemSizeWdgt::event(arg__1);
611 612 }
612 613 bool PythonQtShell_MemSizeWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
613 614 {
614 615 if (_wrapper) {
615 616 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
616 617 PyErr_Clear();
617 618 if (obj && !PythonQtSlotFunction_Check(obj)) {
618 619 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
619 620 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
620 621 bool returnValue;
621 622 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
622 623 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
623 624 if (result) {
624 625 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
625 626 if (args[0]!=&returnValue) {
626 627 if (args[0]==NULL) {
627 628 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
628 629 } else {
629 630 returnValue = *((bool*)args[0]);
630 631 }
631 632 }
632 633 }
633 634 if (result) { Py_DECREF(result); }
634 635 Py_DECREF(obj);
635 636 return returnValue;
636 637 }
637 638 }
638 639 return MemSizeWdgt::eventFilter(arg__1, arg__2);
639 640 }
640 641 void PythonQtShell_MemSizeWdgt::focusInEvent(QFocusEvent* arg__1)
641 642 {
642 643 if (_wrapper) {
643 644 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
644 645 PyErr_Clear();
645 646 if (obj && !PythonQtSlotFunction_Check(obj)) {
646 647 static const char* argumentList[] ={"" , "QFocusEvent*"};
647 648 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
648 649 void* args[2] = {NULL, (void*)&arg__1};
649 650 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
650 651 if (result) { Py_DECREF(result); }
651 652 Py_DECREF(obj);
652 653 return;
653 654 }
654 655 }
655 656 MemSizeWdgt::focusInEvent(arg__1);
656 657 }
657 658 bool PythonQtShell_MemSizeWdgt::focusNextPrevChild(bool next)
658 659 {
659 660 if (_wrapper) {
660 661 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
661 662 PyErr_Clear();
662 663 if (obj && !PythonQtSlotFunction_Check(obj)) {
663 664 static const char* argumentList[] ={"bool" , "bool"};
664 665 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
665 666 bool returnValue;
666 667 void* args[2] = {NULL, (void*)&next};
667 668 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
668 669 if (result) {
669 670 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
670 671 if (args[0]!=&returnValue) {
671 672 if (args[0]==NULL) {
672 673 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
673 674 } else {
674 675 returnValue = *((bool*)args[0]);
675 676 }
676 677 }
677 678 }
678 679 if (result) { Py_DECREF(result); }
679 680 Py_DECREF(obj);
680 681 return returnValue;
681 682 }
682 683 }
683 684 return MemSizeWdgt::focusNextPrevChild(next);
684 685 }
685 686 void PythonQtShell_MemSizeWdgt::focusOutEvent(QFocusEvent* arg__1)
686 687 {
687 688 if (_wrapper) {
688 689 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
689 690 PyErr_Clear();
690 691 if (obj && !PythonQtSlotFunction_Check(obj)) {
691 692 static const char* argumentList[] ={"" , "QFocusEvent*"};
692 693 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
693 694 void* args[2] = {NULL, (void*)&arg__1};
694 695 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
695 696 if (result) { Py_DECREF(result); }
696 697 Py_DECREF(obj);
697 698 return;
698 699 }
699 700 }
700 701 MemSizeWdgt::focusOutEvent(arg__1);
701 702 }
702 703 bool PythonQtShell_MemSizeWdgt::hasHeightForWidth() const
703 704 {
704 705 if (_wrapper) {
705 706 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
706 707 PyErr_Clear();
707 708 if (obj && !PythonQtSlotFunction_Check(obj)) {
708 709 static const char* argumentList[] ={"bool"};
709 710 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
710 711 bool returnValue;
711 712 void* args[1] = {NULL};
712 713 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
713 714 if (result) {
714 715 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
715 716 if (args[0]!=&returnValue) {
716 717 if (args[0]==NULL) {
717 718 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
718 719 } else {
719 720 returnValue = *((bool*)args[0]);
720 721 }
721 722 }
722 723 }
723 724 if (result) { Py_DECREF(result); }
724 725 Py_DECREF(obj);
725 726 return returnValue;
726 727 }
727 728 }
728 729 return MemSizeWdgt::hasHeightForWidth();
729 730 }
730 731 int PythonQtShell_MemSizeWdgt::heightForWidth(int arg__1) const
731 732 {
732 733 if (_wrapper) {
733 734 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
734 735 PyErr_Clear();
735 736 if (obj && !PythonQtSlotFunction_Check(obj)) {
736 737 static const char* argumentList[] ={"int" , "int"};
737 738 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
738 739 int returnValue;
739 740 void* args[2] = {NULL, (void*)&arg__1};
740 741 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
741 742 if (result) {
742 743 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
743 744 if (args[0]!=&returnValue) {
744 745 if (args[0]==NULL) {
745 746 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
746 747 } else {
747 748 returnValue = *((int*)args[0]);
748 749 }
749 750 }
750 751 }
751 752 if (result) { Py_DECREF(result); }
752 753 Py_DECREF(obj);
753 754 return returnValue;
754 755 }
755 756 }
756 757 return MemSizeWdgt::heightForWidth(arg__1);
757 758 }
758 759 void PythonQtShell_MemSizeWdgt::hideEvent(QHideEvent* arg__1)
759 760 {
760 761 if (_wrapper) {
761 762 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
762 763 PyErr_Clear();
763 764 if (obj && !PythonQtSlotFunction_Check(obj)) {
764 765 static const char* argumentList[] ={"" , "QHideEvent*"};
765 766 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
766 767 void* args[2] = {NULL, (void*)&arg__1};
767 768 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
768 769 if (result) { Py_DECREF(result); }
769 770 Py_DECREF(obj);
770 771 return;
771 772 }
772 773 }
773 774 MemSizeWdgt::hideEvent(arg__1);
774 775 }
775 776 void PythonQtShell_MemSizeWdgt::initPainter(QPainter* painter) const
776 777 {
777 778 if (_wrapper) {
778 779 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
779 780 PyErr_Clear();
780 781 if (obj && !PythonQtSlotFunction_Check(obj)) {
781 782 static const char* argumentList[] ={"" , "QPainter*"};
782 783 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
783 784 void* args[2] = {NULL, (void*)&painter};
784 785 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
785 786 if (result) { Py_DECREF(result); }
786 787 Py_DECREF(obj);
787 788 return;
788 789 }
789 790 }
790 791 MemSizeWdgt::initPainter(painter);
791 792 }
792 793 void PythonQtShell_MemSizeWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
793 794 {
794 795 if (_wrapper) {
795 796 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
796 797 PyErr_Clear();
797 798 if (obj && !PythonQtSlotFunction_Check(obj)) {
798 799 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
799 800 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
800 801 void* args[2] = {NULL, (void*)&arg__1};
801 802 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
802 803 if (result) { Py_DECREF(result); }
803 804 Py_DECREF(obj);
804 805 return;
805 806 }
806 807 }
807 808 MemSizeWdgt::inputMethodEvent(arg__1);
808 809 }
809 810 QVariant PythonQtShell_MemSizeWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
810 811 {
811 812 if (_wrapper) {
812 813 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
813 814 PyErr_Clear();
814 815 if (obj && !PythonQtSlotFunction_Check(obj)) {
815 816 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
816 817 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
817 818 QVariant returnValue;
818 819 void* args[2] = {NULL, (void*)&arg__1};
819 820 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
820 821 if (result) {
821 822 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
822 823 if (args[0]!=&returnValue) {
823 824 if (args[0]==NULL) {
824 825 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
825 826 } else {
826 827 returnValue = *((QVariant*)args[0]);
827 828 }
828 829 }
829 830 }
830 831 if (result) { Py_DECREF(result); }
831 832 Py_DECREF(obj);
832 833 return returnValue;
833 834 }
834 835 }
835 836 return MemSizeWdgt::inputMethodQuery(arg__1);
836 837 }
837 838 void PythonQtShell_MemSizeWdgt::keyPressEvent(QKeyEvent* arg__1)
838 839 {
839 840 if (_wrapper) {
840 841 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
841 842 PyErr_Clear();
842 843 if (obj && !PythonQtSlotFunction_Check(obj)) {
843 844 static const char* argumentList[] ={"" , "QKeyEvent*"};
844 845 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
845 846 void* args[2] = {NULL, (void*)&arg__1};
846 847 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
847 848 if (result) { Py_DECREF(result); }
848 849 Py_DECREF(obj);
849 850 return;
850 851 }
851 852 }
852 853 MemSizeWdgt::keyPressEvent(arg__1);
853 854 }
854 855 void PythonQtShell_MemSizeWdgt::keyReleaseEvent(QKeyEvent* arg__1)
855 856 {
856 857 if (_wrapper) {
857 858 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
858 859 PyErr_Clear();
859 860 if (obj && !PythonQtSlotFunction_Check(obj)) {
860 861 static const char* argumentList[] ={"" , "QKeyEvent*"};
861 862 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
862 863 void* args[2] = {NULL, (void*)&arg__1};
863 864 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
864 865 if (result) { Py_DECREF(result); }
865 866 Py_DECREF(obj);
866 867 return;
867 868 }
868 869 }
869 870 MemSizeWdgt::keyReleaseEvent(arg__1);
870 871 }
871 872 void PythonQtShell_MemSizeWdgt::leaveEvent(QEvent* arg__1)
872 873 {
873 874 if (_wrapper) {
874 875 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
875 876 PyErr_Clear();
876 877 if (obj && !PythonQtSlotFunction_Check(obj)) {
877 878 static const char* argumentList[] ={"" , "QEvent*"};
878 879 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
879 880 void* args[2] = {NULL, (void*)&arg__1};
880 881 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
881 882 if (result) { Py_DECREF(result); }
882 883 Py_DECREF(obj);
883 884 return;
884 885 }
885 886 }
886 887 MemSizeWdgt::leaveEvent(arg__1);
887 888 }
888 889 int PythonQtShell_MemSizeWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
889 890 {
890 891 if (_wrapper) {
891 892 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
892 893 PyErr_Clear();
893 894 if (obj && !PythonQtSlotFunction_Check(obj)) {
894 895 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
895 896 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
896 897 int returnValue;
897 898 void* args[2] = {NULL, (void*)&arg__1};
898 899 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
899 900 if (result) {
900 901 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
901 902 if (args[0]!=&returnValue) {
902 903 if (args[0]==NULL) {
903 904 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
904 905 } else {
905 906 returnValue = *((int*)args[0]);
906 907 }
907 908 }
908 909 }
909 910 if (result) { Py_DECREF(result); }
910 911 Py_DECREF(obj);
911 912 return returnValue;
912 913 }
913 914 }
914 915 return MemSizeWdgt::metric(arg__1);
915 916 }
916 917 QSize PythonQtShell_MemSizeWdgt::minimumSizeHint() const
917 918 {
918 919 if (_wrapper) {
919 920 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
920 921 PyErr_Clear();
921 922 if (obj && !PythonQtSlotFunction_Check(obj)) {
922 923 static const char* argumentList[] ={"QSize"};
923 924 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
924 925 QSize returnValue;
925 926 void* args[1] = {NULL};
926 927 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
927 928 if (result) {
928 929 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
929 930 if (args[0]!=&returnValue) {
930 931 if (args[0]==NULL) {
931 932 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
932 933 } else {
933 934 returnValue = *((QSize*)args[0]);
934 935 }
935 936 }
936 937 }
937 938 if (result) { Py_DECREF(result); }
938 939 Py_DECREF(obj);
939 940 return returnValue;
940 941 }
941 942 }
942 943 return MemSizeWdgt::minimumSizeHint();
943 944 }
944 945 void PythonQtShell_MemSizeWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
945 946 {
946 947 if (_wrapper) {
947 948 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
948 949 PyErr_Clear();
949 950 if (obj && !PythonQtSlotFunction_Check(obj)) {
950 951 static const char* argumentList[] ={"" , "QMouseEvent*"};
951 952 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
952 953 void* args[2] = {NULL, (void*)&arg__1};
953 954 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
954 955 if (result) { Py_DECREF(result); }
955 956 Py_DECREF(obj);
956 957 return;
957 958 }
958 959 }
959 960 MemSizeWdgt::mouseDoubleClickEvent(arg__1);
960 961 }
961 962 void PythonQtShell_MemSizeWdgt::mouseMoveEvent(QMouseEvent* arg__1)
962 963 {
963 964 if (_wrapper) {
964 965 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
965 966 PyErr_Clear();
966 967 if (obj && !PythonQtSlotFunction_Check(obj)) {
967 968 static const char* argumentList[] ={"" , "QMouseEvent*"};
968 969 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
969 970 void* args[2] = {NULL, (void*)&arg__1};
970 971 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
971 972 if (result) { Py_DECREF(result); }
972 973 Py_DECREF(obj);
973 974 return;
974 975 }
975 976 }
976 977 MemSizeWdgt::mouseMoveEvent(arg__1);
977 978 }
978 979 void PythonQtShell_MemSizeWdgt::mousePressEvent(QMouseEvent* arg__1)
979 980 {
980 981 if (_wrapper) {
981 982 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
982 983 PyErr_Clear();
983 984 if (obj && !PythonQtSlotFunction_Check(obj)) {
984 985 static const char* argumentList[] ={"" , "QMouseEvent*"};
985 986 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
986 987 void* args[2] = {NULL, (void*)&arg__1};
987 988 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
988 989 if (result) { Py_DECREF(result); }
989 990 Py_DECREF(obj);
990 991 return;
991 992 }
992 993 }
993 994 MemSizeWdgt::mousePressEvent(arg__1);
994 995 }
995 996 void PythonQtShell_MemSizeWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
996 997 {
997 998 if (_wrapper) {
998 999 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
999 1000 PyErr_Clear();
1000 1001 if (obj && !PythonQtSlotFunction_Check(obj)) {
1001 1002 static const char* argumentList[] ={"" , "QMouseEvent*"};
1002 1003 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1003 1004 void* args[2] = {NULL, (void*)&arg__1};
1004 1005 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1005 1006 if (result) { Py_DECREF(result); }
1006 1007 Py_DECREF(obj);
1007 1008 return;
1008 1009 }
1009 1010 }
1010 1011 MemSizeWdgt::mouseReleaseEvent(arg__1);
1011 1012 }
1012 1013 void PythonQtShell_MemSizeWdgt::moveEvent(QMoveEvent* arg__1)
1013 1014 {
1014 1015 if (_wrapper) {
1015 1016 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
1016 1017 PyErr_Clear();
1017 1018 if (obj && !PythonQtSlotFunction_Check(obj)) {
1018 1019 static const char* argumentList[] ={"" , "QMoveEvent*"};
1019 1020 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1020 1021 void* args[2] = {NULL, (void*)&arg__1};
1021 1022 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1022 1023 if (result) { Py_DECREF(result); }
1023 1024 Py_DECREF(obj);
1024 1025 return;
1025 1026 }
1026 1027 }
1027 1028 MemSizeWdgt::moveEvent(arg__1);
1028 1029 }
1029 1030 bool PythonQtShell_MemSizeWdgt::nativeEvent(const QByteArray& eventType, void* message, long* result)
1030 1031 {
1031 1032 if (_wrapper) {
1032 1033 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
1033 1034 PyErr_Clear();
1034 1035 if (obj && !PythonQtSlotFunction_Check(obj)) {
1035 1036 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
1036 1037 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
1037 1038 bool returnValue;
1038 1039 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
1039 1040 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1040 1041 if (result) {
1041 1042 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1042 1043 if (args[0]!=&returnValue) {
1043 1044 if (args[0]==NULL) {
1044 1045 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
1045 1046 } else {
1046 1047 returnValue = *((bool*)args[0]);
1047 1048 }
1048 1049 }
1049 1050 }
1050 1051 if (result) { Py_DECREF(result); }
1051 1052 Py_DECREF(obj);
1052 1053 return returnValue;
1053 1054 }
1054 1055 }
1055 1056 return MemSizeWdgt::nativeEvent(eventType, message, result);
1056 1057 }
1057 1058 QPaintEngine* PythonQtShell_MemSizeWdgt::paintEngine() const
1058 1059 {
1059 1060 if (_wrapper) {
1060 1061 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
1061 1062 PyErr_Clear();
1062 1063 if (obj && !PythonQtSlotFunction_Check(obj)) {
1063 1064 static const char* argumentList[] ={"QPaintEngine*"};
1064 1065 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1065 1066 QPaintEngine* returnValue;
1066 1067 void* args[1] = {NULL};
1067 1068 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1068 1069 if (result) {
1069 1070 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1070 1071 if (args[0]!=&returnValue) {
1071 1072 if (args[0]==NULL) {
1072 1073 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
1073 1074 } else {
1074 1075 returnValue = *((QPaintEngine**)args[0]);
1075 1076 }
1076 1077 }
1077 1078 }
1078 1079 if (result) { Py_DECREF(result); }
1079 1080 Py_DECREF(obj);
1080 1081 return returnValue;
1081 1082 }
1082 1083 }
1083 1084 return MemSizeWdgt::paintEngine();
1084 1085 }
1085 1086 void PythonQtShell_MemSizeWdgt::paintEvent(QPaintEvent* arg__1)
1086 1087 {
1087 1088 if (_wrapper) {
1088 1089 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
1089 1090 PyErr_Clear();
1090 1091 if (obj && !PythonQtSlotFunction_Check(obj)) {
1091 1092 static const char* argumentList[] ={"" , "QPaintEvent*"};
1092 1093 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1093 1094 void* args[2] = {NULL, (void*)&arg__1};
1094 1095 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1095 1096 if (result) { Py_DECREF(result); }
1096 1097 Py_DECREF(obj);
1097 1098 return;
1098 1099 }
1099 1100 }
1100 1101 MemSizeWdgt::paintEvent(arg__1);
1101 1102 }
1102 1103 QPaintDevice* PythonQtShell_MemSizeWdgt::redirected(QPoint* offset) const
1103 1104 {
1104 1105 if (_wrapper) {
1105 1106 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
1106 1107 PyErr_Clear();
1107 1108 if (obj && !PythonQtSlotFunction_Check(obj)) {
1108 1109 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
1109 1110 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1110 1111 QPaintDevice* returnValue;
1111 1112 void* args[2] = {NULL, (void*)&offset};
1112 1113 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1113 1114 if (result) {
1114 1115 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1115 1116 if (args[0]!=&returnValue) {
1116 1117 if (args[0]==NULL) {
1117 1118 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
1118 1119 } else {
1119 1120 returnValue = *((QPaintDevice**)args[0]);
1120 1121 }
1121 1122 }
1122 1123 }
1123 1124 if (result) { Py_DECREF(result); }
1124 1125 Py_DECREF(obj);
1125 1126 return returnValue;
1126 1127 }
1127 1128 }
1128 1129 return MemSizeWdgt::redirected(offset);
1129 1130 }
1130 1131 void PythonQtShell_MemSizeWdgt::resizeEvent(QResizeEvent* arg__1)
1131 1132 {
1132 1133 if (_wrapper) {
1133 1134 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
1134 1135 PyErr_Clear();
1135 1136 if (obj && !PythonQtSlotFunction_Check(obj)) {
1136 1137 static const char* argumentList[] ={"" , "QResizeEvent*"};
1137 1138 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1138 1139 void* args[2] = {NULL, (void*)&arg__1};
1139 1140 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1140 1141 if (result) { Py_DECREF(result); }
1141 1142 Py_DECREF(obj);
1142 1143 return;
1143 1144 }
1144 1145 }
1145 1146 MemSizeWdgt::resizeEvent(arg__1);
1146 1147 }
1147 1148 QPainter* PythonQtShell_MemSizeWdgt::sharedPainter() const
1148 1149 {
1149 1150 if (_wrapper) {
1150 1151 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
1151 1152 PyErr_Clear();
1152 1153 if (obj && !PythonQtSlotFunction_Check(obj)) {
1153 1154 static const char* argumentList[] ={"QPainter*"};
1154 1155 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1155 1156 QPainter* returnValue;
1156 1157 void* args[1] = {NULL};
1157 1158 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1158 1159 if (result) {
1159 1160 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1160 1161 if (args[0]!=&returnValue) {
1161 1162 if (args[0]==NULL) {
1162 1163 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
1163 1164 } else {
1164 1165 returnValue = *((QPainter**)args[0]);
1165 1166 }
1166 1167 }
1167 1168 }
1168 1169 if (result) { Py_DECREF(result); }
1169 1170 Py_DECREF(obj);
1170 1171 return returnValue;
1171 1172 }
1172 1173 }
1173 1174 return MemSizeWdgt::sharedPainter();
1174 1175 }
1175 1176 void PythonQtShell_MemSizeWdgt::showEvent(QShowEvent* arg__1)
1176 1177 {
1177 1178 if (_wrapper) {
1178 1179 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
1179 1180 PyErr_Clear();
1180 1181 if (obj && !PythonQtSlotFunction_Check(obj)) {
1181 1182 static const char* argumentList[] ={"" , "QShowEvent*"};
1182 1183 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1183 1184 void* args[2] = {NULL, (void*)&arg__1};
1184 1185 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1185 1186 if (result) { Py_DECREF(result); }
1186 1187 Py_DECREF(obj);
1187 1188 return;
1188 1189 }
1189 1190 }
1190 1191 MemSizeWdgt::showEvent(arg__1);
1191 1192 }
1192 1193 QSize PythonQtShell_MemSizeWdgt::sizeHint() const
1193 1194 {
1194 1195 if (_wrapper) {
1195 1196 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
1196 1197 PyErr_Clear();
1197 1198 if (obj && !PythonQtSlotFunction_Check(obj)) {
1198 1199 static const char* argumentList[] ={"QSize"};
1199 1200 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1200 1201 QSize returnValue;
1201 1202 void* args[1] = {NULL};
1202 1203 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1203 1204 if (result) {
1204 1205 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1205 1206 if (args[0]!=&returnValue) {
1206 1207 if (args[0]==NULL) {
1207 1208 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
1208 1209 } else {
1209 1210 returnValue = *((QSize*)args[0]);
1210 1211 }
1211 1212 }
1212 1213 }
1213 1214 if (result) { Py_DECREF(result); }
1214 1215 Py_DECREF(obj);
1215 1216 return returnValue;
1216 1217 }
1217 1218 }
1218 1219 return MemSizeWdgt::sizeHint();
1219 1220 }
1220 1221 void PythonQtShell_MemSizeWdgt::tabletEvent(QTabletEvent* arg__1)
1221 1222 {
1222 1223 if (_wrapper) {
1223 1224 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
1224 1225 PyErr_Clear();
1225 1226 if (obj && !PythonQtSlotFunction_Check(obj)) {
1226 1227 static const char* argumentList[] ={"" , "QTabletEvent*"};
1227 1228 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1228 1229 void* args[2] = {NULL, (void*)&arg__1};
1229 1230 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1230 1231 if (result) { Py_DECREF(result); }
1231 1232 Py_DECREF(obj);
1232 1233 return;
1233 1234 }
1234 1235 }
1235 1236 MemSizeWdgt::tabletEvent(arg__1);
1236 1237 }
1237 1238 void PythonQtShell_MemSizeWdgt::timerEvent(QTimerEvent* arg__1)
1238 1239 {
1239 1240 if (_wrapper) {
1240 1241 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
1241 1242 PyErr_Clear();
1242 1243 if (obj && !PythonQtSlotFunction_Check(obj)) {
1243 1244 static const char* argumentList[] ={"" , "QTimerEvent*"};
1244 1245 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1245 1246 void* args[2] = {NULL, (void*)&arg__1};
1246 1247 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1247 1248 if (result) { Py_DECREF(result); }
1248 1249 Py_DECREF(obj);
1249 1250 return;
1250 1251 }
1251 1252 }
1252 1253 MemSizeWdgt::timerEvent(arg__1);
1253 1254 }
1254 1255 void PythonQtShell_MemSizeWdgt::wheelEvent(QWheelEvent* arg__1)
1255 1256 {
1256 1257 if (_wrapper) {
1257 1258 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
1258 1259 PyErr_Clear();
1259 1260 if (obj && !PythonQtSlotFunction_Check(obj)) {
1260 1261 static const char* argumentList[] ={"" , "QWheelEvent*"};
1261 1262 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1262 1263 void* args[2] = {NULL, (void*)&arg__1};
1263 1264 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1264 1265 if (result) { Py_DECREF(result); }
1265 1266 Py_DECREF(obj);
1266 1267 return;
1267 1268 }
1268 1269 }
1269 1270 MemSizeWdgt::wheelEvent(arg__1);
1270 1271 }
1271 1272 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(QWidget* parent)
1272 1273 {
1273 1274 return new PythonQtShell_MemSizeWdgt(parent); }
1274 1275
1275 1276 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(int defaultSize, QWidget* parent)
1276 1277 {
1277 1278 return new PythonQtShell_MemSizeWdgt(defaultSize, parent); }
1278 1279
1279 1280 int PythonQtWrapper_MemSizeWdgt::getsize(MemSizeWdgt* theWrappedObject)
1280 1281 {
1281 1282 return ( theWrappedObject->getsize());
1282 1283 }
1283 1284
1284 1285 void PythonQtWrapper_MemSizeWdgt::setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max)
1285 1286 {
1286 1287 ( theWrappedObject->setMaximum(max));
1287 1288 }
1288 1289
1289 1290 void PythonQtWrapper_MemSizeWdgt::show(MemSizeWdgt* theWrappedObject)
1290 1291 {
1291 1292 ( theWrappedObject->show());
1292 1293 }
1293 1294
1294 1295 void PythonQtWrapper_MemSizeWdgt::updateSizeValue(MemSizeWdgt* theWrappedObject)
1295 1296 {
1296 1297 ( theWrappedObject->updateSizeValue());
1297 1298 }
1298 1299
1299 1300
1300 1301
1301 1302 PythonQtShell_QHexEdit::~PythonQtShell_QHexEdit() {
1302 1303 PythonQtPrivate* priv = PythonQt::priv();
1303 1304 if (priv) { priv->shellClassDeleted(this); }
1304 1305 }
1305 1306 void PythonQtShell_QHexEdit::actionEvent(QActionEvent* arg__1)
1306 1307 {
1307 1308 if (_wrapper) {
1308 1309 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
1309 1310 PyErr_Clear();
1310 1311 if (obj && !PythonQtSlotFunction_Check(obj)) {
1311 1312 static const char* argumentList[] ={"" , "QActionEvent*"};
1312 1313 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1313 1314 void* args[2] = {NULL, (void*)&arg__1};
1314 1315 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1315 1316 if (result) { Py_DECREF(result); }
1316 1317 Py_DECREF(obj);
1317 1318 return;
1318 1319 }
1319 1320 }
1320 1321 QHexEdit::actionEvent(arg__1);
1321 1322 }
1322 1323 void PythonQtShell_QHexEdit::changeEvent(QEvent* arg__1)
1323 1324 {
1324 1325 if (_wrapper) {
1325 1326 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
1326 1327 PyErr_Clear();
1327 1328 if (obj && !PythonQtSlotFunction_Check(obj)) {
1328 1329 static const char* argumentList[] ={"" , "QEvent*"};
1329 1330 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1330 1331 void* args[2] = {NULL, (void*)&arg__1};
1331 1332 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1332 1333 if (result) { Py_DECREF(result); }
1333 1334 Py_DECREF(obj);
1334 1335 return;
1335 1336 }
1336 1337 }
1337 1338 QHexEdit::changeEvent(arg__1);
1338 1339 }
1339 1340 void PythonQtShell_QHexEdit::childEvent(QChildEvent* arg__1)
1340 1341 {
1341 1342 if (_wrapper) {
1342 1343 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
1343 1344 PyErr_Clear();
1344 1345 if (obj && !PythonQtSlotFunction_Check(obj)) {
1345 1346 static const char* argumentList[] ={"" , "QChildEvent*"};
1346 1347 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1347 1348 void* args[2] = {NULL, (void*)&arg__1};
1348 1349 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1349 1350 if (result) { Py_DECREF(result); }
1350 1351 Py_DECREF(obj);
1351 1352 return;
1352 1353 }
1353 1354 }
1354 1355 QHexEdit::childEvent(arg__1);
1355 1356 }
1356 1357 void PythonQtShell_QHexEdit::closeEvent(QCloseEvent* arg__1)
1357 1358 {
1358 1359 if (_wrapper) {
1359 1360 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
1360 1361 PyErr_Clear();
1361 1362 if (obj && !PythonQtSlotFunction_Check(obj)) {
1362 1363 static const char* argumentList[] ={"" , "QCloseEvent*"};
1363 1364 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1364 1365 void* args[2] = {NULL, (void*)&arg__1};
1365 1366 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1366 1367 if (result) { Py_DECREF(result); }
1367 1368 Py_DECREF(obj);
1368 1369 return;
1369 1370 }
1370 1371 }
1371 1372 QHexEdit::closeEvent(arg__1);
1372 1373 }
1373 1374 void PythonQtShell_QHexEdit::contextMenuEvent(QContextMenuEvent* arg__1)
1374 1375 {
1375 1376 if (_wrapper) {
1376 1377 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
1377 1378 PyErr_Clear();
1378 1379 if (obj && !PythonQtSlotFunction_Check(obj)) {
1379 1380 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
1380 1381 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1381 1382 void* args[2] = {NULL, (void*)&arg__1};
1382 1383 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1383 1384 if (result) { Py_DECREF(result); }
1384 1385 Py_DECREF(obj);
1385 1386 return;
1386 1387 }
1387 1388 }
1388 1389 QHexEdit::contextMenuEvent(arg__1);
1389 1390 }
1390 1391 void PythonQtShell_QHexEdit::customEvent(QEvent* arg__1)
1391 1392 {
1392 1393 if (_wrapper) {
1393 1394 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
1394 1395 PyErr_Clear();
1395 1396 if (obj && !PythonQtSlotFunction_Check(obj)) {
1396 1397 static const char* argumentList[] ={"" , "QEvent*"};
1397 1398 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1398 1399 void* args[2] = {NULL, (void*)&arg__1};
1399 1400 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1400 1401 if (result) { Py_DECREF(result); }
1401 1402 Py_DECREF(obj);
1402 1403 return;
1403 1404 }
1404 1405 }
1405 1406 QHexEdit::customEvent(arg__1);
1406 1407 }
1407 1408 int PythonQtShell_QHexEdit::devType() const
1408 1409 {
1409 1410 if (_wrapper) {
1410 1411 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
1411 1412 PyErr_Clear();
1412 1413 if (obj && !PythonQtSlotFunction_Check(obj)) {
1413 1414 static const char* argumentList[] ={"int"};
1414 1415 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1415 1416 int returnValue;
1416 1417 void* args[1] = {NULL};
1417 1418 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1418 1419 if (result) {
1419 1420 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1420 1421 if (args[0]!=&returnValue) {
1421 1422 if (args[0]==NULL) {
1422 1423 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
1423 1424 } else {
1424 1425 returnValue = *((int*)args[0]);
1425 1426 }
1426 1427 }
1427 1428 }
1428 1429 if (result) { Py_DECREF(result); }
1429 1430 Py_DECREF(obj);
1430 1431 return returnValue;
1431 1432 }
1432 1433 }
1433 1434 return QHexEdit::devType();
1434 1435 }
1435 1436 void PythonQtShell_QHexEdit::dragEnterEvent(QDragEnterEvent* arg__1)
1436 1437 {
1437 1438 if (_wrapper) {
1438 1439 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
1439 1440 PyErr_Clear();
1440 1441 if (obj && !PythonQtSlotFunction_Check(obj)) {
1441 1442 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
1442 1443 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1443 1444 void* args[2] = {NULL, (void*)&arg__1};
1444 1445 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1445 1446 if (result) { Py_DECREF(result); }
1446 1447 Py_DECREF(obj);
1447 1448 return;
1448 1449 }
1449 1450 }
1450 1451 QHexEdit::dragEnterEvent(arg__1);
1451 1452 }
1452 1453 void PythonQtShell_QHexEdit::dragLeaveEvent(QDragLeaveEvent* arg__1)
1453 1454 {
1454 1455 if (_wrapper) {
1455 1456 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
1456 1457 PyErr_Clear();
1457 1458 if (obj && !PythonQtSlotFunction_Check(obj)) {
1458 1459 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
1459 1460 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1460 1461 void* args[2] = {NULL, (void*)&arg__1};
1461 1462 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1462 1463 if (result) { Py_DECREF(result); }
1463 1464 Py_DECREF(obj);
1464 1465 return;
1465 1466 }
1466 1467 }
1467 1468 QHexEdit::dragLeaveEvent(arg__1);
1468 1469 }
1469 1470 void PythonQtShell_QHexEdit::dragMoveEvent(QDragMoveEvent* arg__1)
1470 1471 {
1471 1472 if (_wrapper) {
1472 1473 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
1473 1474 PyErr_Clear();
1474 1475 if (obj && !PythonQtSlotFunction_Check(obj)) {
1475 1476 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
1476 1477 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1477 1478 void* args[2] = {NULL, (void*)&arg__1};
1478 1479 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1479 1480 if (result) { Py_DECREF(result); }
1480 1481 Py_DECREF(obj);
1481 1482 return;
1482 1483 }
1483 1484 }
1484 1485 QHexEdit::dragMoveEvent(arg__1);
1485 1486 }
1486 1487 void PythonQtShell_QHexEdit::dropEvent(QDropEvent* arg__1)
1487 1488 {
1488 1489 if (_wrapper) {
1489 1490 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
1490 1491 PyErr_Clear();
1491 1492 if (obj && !PythonQtSlotFunction_Check(obj)) {
1492 1493 static const char* argumentList[] ={"" , "QDropEvent*"};
1493 1494 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1494 1495 void* args[2] = {NULL, (void*)&arg__1};
1495 1496 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1496 1497 if (result) { Py_DECREF(result); }
1497 1498 Py_DECREF(obj);
1498 1499 return;
1499 1500 }
1500 1501 }
1501 1502 QHexEdit::dropEvent(arg__1);
1502 1503 }
1503 1504 void PythonQtShell_QHexEdit::enterEvent(QEvent* arg__1)
1504 1505 {
1505 1506 if (_wrapper) {
1506 1507 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
1507 1508 PyErr_Clear();
1508 1509 if (obj && !PythonQtSlotFunction_Check(obj)) {
1509 1510 static const char* argumentList[] ={"" , "QEvent*"};
1510 1511 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1511 1512 void* args[2] = {NULL, (void*)&arg__1};
1512 1513 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1513 1514 if (result) { Py_DECREF(result); }
1514 1515 Py_DECREF(obj);
1515 1516 return;
1516 1517 }
1517 1518 }
1518 1519 QHexEdit::enterEvent(arg__1);
1519 1520 }
1520 1521 bool PythonQtShell_QHexEdit::event(QEvent* arg__1)
1521 1522 {
1522 1523 if (_wrapper) {
1523 1524 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
1524 1525 PyErr_Clear();
1525 1526 if (obj && !PythonQtSlotFunction_Check(obj)) {
1526 1527 static const char* argumentList[] ={"bool" , "QEvent*"};
1527 1528 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1528 1529 bool returnValue;
1529 1530 void* args[2] = {NULL, (void*)&arg__1};
1530 1531 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1531 1532 if (result) {
1532 1533 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1533 1534 if (args[0]!=&returnValue) {
1534 1535 if (args[0]==NULL) {
1535 1536 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
1536 1537 } else {
1537 1538 returnValue = *((bool*)args[0]);
1538 1539 }
1539 1540 }
1540 1541 }
1541 1542 if (result) { Py_DECREF(result); }
1542 1543 Py_DECREF(obj);
1543 1544 return returnValue;
1544 1545 }
1545 1546 }
1546 1547 return QHexEdit::event(arg__1);
1547 1548 }
1548 1549 bool PythonQtShell_QHexEdit::eventFilter(QObject* arg__1, QEvent* arg__2)
1549 1550 {
1550 1551 if (_wrapper) {
1551 1552 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
1552 1553 PyErr_Clear();
1553 1554 if (obj && !PythonQtSlotFunction_Check(obj)) {
1554 1555 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
1555 1556 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
1556 1557 bool returnValue;
1557 1558 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
1558 1559 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1559 1560 if (result) {
1560 1561 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1561 1562 if (args[0]!=&returnValue) {
1562 1563 if (args[0]==NULL) {
1563 1564 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
1564 1565 } else {
1565 1566 returnValue = *((bool*)args[0]);
1566 1567 }
1567 1568 }
1568 1569 }
1569 1570 if (result) { Py_DECREF(result); }
1570 1571 Py_DECREF(obj);
1571 1572 return returnValue;
1572 1573 }
1573 1574 }
1574 1575 return QHexEdit::eventFilter(arg__1, arg__2);
1575 1576 }
1576 1577 void PythonQtShell_QHexEdit::focusInEvent(QFocusEvent* arg__1)
1577 1578 {
1578 1579 if (_wrapper) {
1579 1580 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
1580 1581 PyErr_Clear();
1581 1582 if (obj && !PythonQtSlotFunction_Check(obj)) {
1582 1583 static const char* argumentList[] ={"" , "QFocusEvent*"};
1583 1584 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1584 1585 void* args[2] = {NULL, (void*)&arg__1};
1585 1586 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1586 1587 if (result) { Py_DECREF(result); }
1587 1588 Py_DECREF(obj);
1588 1589 return;
1589 1590 }
1590 1591 }
1591 1592 QHexEdit::focusInEvent(arg__1);
1592 1593 }
1593 1594 bool PythonQtShell_QHexEdit::focusNextPrevChild(bool next)
1594 1595 {
1595 1596 if (_wrapper) {
1596 1597 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
1597 1598 PyErr_Clear();
1598 1599 if (obj && !PythonQtSlotFunction_Check(obj)) {
1599 1600 static const char* argumentList[] ={"bool" , "bool"};
1600 1601 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1601 1602 bool returnValue;
1602 1603 void* args[2] = {NULL, (void*)&next};
1603 1604 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1604 1605 if (result) {
1605 1606 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1606 1607 if (args[0]!=&returnValue) {
1607 1608 if (args[0]==NULL) {
1608 1609 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
1609 1610 } else {
1610 1611 returnValue = *((bool*)args[0]);
1611 1612 }
1612 1613 }
1613 1614 }
1614 1615 if (result) { Py_DECREF(result); }
1615 1616 Py_DECREF(obj);
1616 1617 return returnValue;
1617 1618 }
1618 1619 }
1619 1620 return QHexEdit::focusNextPrevChild(next);
1620 1621 }
1621 1622 void PythonQtShell_QHexEdit::focusOutEvent(QFocusEvent* arg__1)
1622 1623 {
1623 1624 if (_wrapper) {
1624 1625 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
1625 1626 PyErr_Clear();
1626 1627 if (obj && !PythonQtSlotFunction_Check(obj)) {
1627 1628 static const char* argumentList[] ={"" , "QFocusEvent*"};
1628 1629 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1629 1630 void* args[2] = {NULL, (void*)&arg__1};
1630 1631 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1631 1632 if (result) { Py_DECREF(result); }
1632 1633 Py_DECREF(obj);
1633 1634 return;
1634 1635 }
1635 1636 }
1636 1637 QHexEdit::focusOutEvent(arg__1);
1637 1638 }
1638 1639 bool PythonQtShell_QHexEdit::hasHeightForWidth() const
1639 1640 {
1640 1641 if (_wrapper) {
1641 1642 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
1642 1643 PyErr_Clear();
1643 1644 if (obj && !PythonQtSlotFunction_Check(obj)) {
1644 1645 static const char* argumentList[] ={"bool"};
1645 1646 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1646 1647 bool returnValue;
1647 1648 void* args[1] = {NULL};
1648 1649 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1649 1650 if (result) {
1650 1651 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1651 1652 if (args[0]!=&returnValue) {
1652 1653 if (args[0]==NULL) {
1653 1654 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
1654 1655 } else {
1655 1656 returnValue = *((bool*)args[0]);
1656 1657 }
1657 1658 }
1658 1659 }
1659 1660 if (result) { Py_DECREF(result); }
1660 1661 Py_DECREF(obj);
1661 1662 return returnValue;
1662 1663 }
1663 1664 }
1664 1665 return QHexEdit::hasHeightForWidth();
1665 1666 }
1666 1667 int PythonQtShell_QHexEdit::heightForWidth(int arg__1) const
1667 1668 {
1668 1669 if (_wrapper) {
1669 1670 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
1670 1671 PyErr_Clear();
1671 1672 if (obj && !PythonQtSlotFunction_Check(obj)) {
1672 1673 static const char* argumentList[] ={"int" , "int"};
1673 1674 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1674 1675 int returnValue;
1675 1676 void* args[2] = {NULL, (void*)&arg__1};
1676 1677 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1677 1678 if (result) {
1678 1679 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1679 1680 if (args[0]!=&returnValue) {
1680 1681 if (args[0]==NULL) {
1681 1682 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
1682 1683 } else {
1683 1684 returnValue = *((int*)args[0]);
1684 1685 }
1685 1686 }
1686 1687 }
1687 1688 if (result) { Py_DECREF(result); }
1688 1689 Py_DECREF(obj);
1689 1690 return returnValue;
1690 1691 }
1691 1692 }
1692 1693 return QHexEdit::heightForWidth(arg__1);
1693 1694 }
1694 1695 void PythonQtShell_QHexEdit::hideEvent(QHideEvent* arg__1)
1695 1696 {
1696 1697 if (_wrapper) {
1697 1698 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
1698 1699 PyErr_Clear();
1699 1700 if (obj && !PythonQtSlotFunction_Check(obj)) {
1700 1701 static const char* argumentList[] ={"" , "QHideEvent*"};
1701 1702 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1702 1703 void* args[2] = {NULL, (void*)&arg__1};
1703 1704 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1704 1705 if (result) { Py_DECREF(result); }
1705 1706 Py_DECREF(obj);
1706 1707 return;
1707 1708 }
1708 1709 }
1709 1710 QHexEdit::hideEvent(arg__1);
1710 1711 }
1711 1712 void PythonQtShell_QHexEdit::initPainter(QPainter* painter) const
1712 1713 {
1713 1714 if (_wrapper) {
1714 1715 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
1715 1716 PyErr_Clear();
1716 1717 if (obj && !PythonQtSlotFunction_Check(obj)) {
1717 1718 static const char* argumentList[] ={"" , "QPainter*"};
1718 1719 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1719 1720 void* args[2] = {NULL, (void*)&painter};
1720 1721 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1721 1722 if (result) { Py_DECREF(result); }
1722 1723 Py_DECREF(obj);
1723 1724 return;
1724 1725 }
1725 1726 }
1726 1727 QHexEdit::initPainter(painter);
1727 1728 }
1728 1729 void PythonQtShell_QHexEdit::inputMethodEvent(QInputMethodEvent* arg__1)
1729 1730 {
1730 1731 if (_wrapper) {
1731 1732 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
1732 1733 PyErr_Clear();
1733 1734 if (obj && !PythonQtSlotFunction_Check(obj)) {
1734 1735 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
1735 1736 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1736 1737 void* args[2] = {NULL, (void*)&arg__1};
1737 1738 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1738 1739 if (result) { Py_DECREF(result); }
1739 1740 Py_DECREF(obj);
1740 1741 return;
1741 1742 }
1742 1743 }
1743 1744 QHexEdit::inputMethodEvent(arg__1);
1744 1745 }
1745 1746 QVariant PythonQtShell_QHexEdit::inputMethodQuery(Qt::InputMethodQuery arg__1) const
1746 1747 {
1747 1748 if (_wrapper) {
1748 1749 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
1749 1750 PyErr_Clear();
1750 1751 if (obj && !PythonQtSlotFunction_Check(obj)) {
1751 1752 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
1752 1753 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1753 1754 QVariant returnValue;
1754 1755 void* args[2] = {NULL, (void*)&arg__1};
1755 1756 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1756 1757 if (result) {
1757 1758 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1758 1759 if (args[0]!=&returnValue) {
1759 1760 if (args[0]==NULL) {
1760 1761 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
1761 1762 } else {
1762 1763 returnValue = *((QVariant*)args[0]);
1763 1764 }
1764 1765 }
1765 1766 }
1766 1767 if (result) { Py_DECREF(result); }
1767 1768 Py_DECREF(obj);
1768 1769 return returnValue;
1769 1770 }
1770 1771 }
1771 1772 return QHexEdit::inputMethodQuery(arg__1);
1772 1773 }
1773 1774 void PythonQtShell_QHexEdit::keyPressEvent(QKeyEvent* arg__1)
1774 1775 {
1775 1776 if (_wrapper) {
1776 1777 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
1777 1778 PyErr_Clear();
1778 1779 if (obj && !PythonQtSlotFunction_Check(obj)) {
1779 1780 static const char* argumentList[] ={"" , "QKeyEvent*"};
1780 1781 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1781 1782 void* args[2] = {NULL, (void*)&arg__1};
1782 1783 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1783 1784 if (result) { Py_DECREF(result); }
1784 1785 Py_DECREF(obj);
1785 1786 return;
1786 1787 }
1787 1788 }
1788 1789 QHexEdit::keyPressEvent(arg__1);
1789 1790 }
1790 1791 void PythonQtShell_QHexEdit::keyReleaseEvent(QKeyEvent* arg__1)
1791 1792 {
1792 1793 if (_wrapper) {
1793 1794 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
1794 1795 PyErr_Clear();
1795 1796 if (obj && !PythonQtSlotFunction_Check(obj)) {
1796 1797 static const char* argumentList[] ={"" , "QKeyEvent*"};
1797 1798 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1798 1799 void* args[2] = {NULL, (void*)&arg__1};
1799 1800 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1800 1801 if (result) { Py_DECREF(result); }
1801 1802 Py_DECREF(obj);
1802 1803 return;
1803 1804 }
1804 1805 }
1805 1806 QHexEdit::keyReleaseEvent(arg__1);
1806 1807 }
1807 1808 void PythonQtShell_QHexEdit::leaveEvent(QEvent* arg__1)
1808 1809 {
1809 1810 if (_wrapper) {
1810 1811 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
1811 1812 PyErr_Clear();
1812 1813 if (obj && !PythonQtSlotFunction_Check(obj)) {
1813 1814 static const char* argumentList[] ={"" , "QEvent*"};
1814 1815 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1815 1816 void* args[2] = {NULL, (void*)&arg__1};
1816 1817 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1817 1818 if (result) { Py_DECREF(result); }
1818 1819 Py_DECREF(obj);
1819 1820 return;
1820 1821 }
1821 1822 }
1822 1823 QHexEdit::leaveEvent(arg__1);
1823 1824 }
1824 1825 int PythonQtShell_QHexEdit::metric(QPaintDevice::PaintDeviceMetric arg__1) const
1825 1826 {
1826 1827 if (_wrapper) {
1827 1828 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
1828 1829 PyErr_Clear();
1829 1830 if (obj && !PythonQtSlotFunction_Check(obj)) {
1830 1831 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
1831 1832 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1832 1833 int returnValue;
1833 1834 void* args[2] = {NULL, (void*)&arg__1};
1834 1835 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1835 1836 if (result) {
1836 1837 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1837 1838 if (args[0]!=&returnValue) {
1838 1839 if (args[0]==NULL) {
1839 1840 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
1840 1841 } else {
1841 1842 returnValue = *((int*)args[0]);
1842 1843 }
1843 1844 }
1844 1845 }
1845 1846 if (result) { Py_DECREF(result); }
1846 1847 Py_DECREF(obj);
1847 1848 return returnValue;
1848 1849 }
1849 1850 }
1850 1851 return QHexEdit::metric(arg__1);
1851 1852 }
1852 1853 void PythonQtShell_QHexEdit::mouseDoubleClickEvent(QMouseEvent* arg__1)
1853 1854 {
1854 1855 if (_wrapper) {
1855 1856 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
1856 1857 PyErr_Clear();
1857 1858 if (obj && !PythonQtSlotFunction_Check(obj)) {
1858 1859 static const char* argumentList[] ={"" , "QMouseEvent*"};
1859 1860 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1860 1861 void* args[2] = {NULL, (void*)&arg__1};
1861 1862 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1862 1863 if (result) { Py_DECREF(result); }
1863 1864 Py_DECREF(obj);
1864 1865 return;
1865 1866 }
1866 1867 }
1867 1868 QHexEdit::mouseDoubleClickEvent(arg__1);
1868 1869 }
1869 1870 void PythonQtShell_QHexEdit::mouseMoveEvent(QMouseEvent* arg__1)
1870 1871 {
1871 1872 if (_wrapper) {
1872 1873 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
1873 1874 PyErr_Clear();
1874 1875 if (obj && !PythonQtSlotFunction_Check(obj)) {
1875 1876 static const char* argumentList[] ={"" , "QMouseEvent*"};
1876 1877 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1877 1878 void* args[2] = {NULL, (void*)&arg__1};
1878 1879 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1879 1880 if (result) { Py_DECREF(result); }
1880 1881 Py_DECREF(obj);
1881 1882 return;
1882 1883 }
1883 1884 }
1884 1885 QHexEdit::mouseMoveEvent(arg__1);
1885 1886 }
1886 1887 void PythonQtShell_QHexEdit::mousePressEvent(QMouseEvent* arg__1)
1887 1888 {
1888 1889 if (_wrapper) {
1889 1890 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
1890 1891 PyErr_Clear();
1891 1892 if (obj && !PythonQtSlotFunction_Check(obj)) {
1892 1893 static const char* argumentList[] ={"" , "QMouseEvent*"};
1893 1894 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1894 1895 void* args[2] = {NULL, (void*)&arg__1};
1895 1896 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1896 1897 if (result) { Py_DECREF(result); }
1897 1898 Py_DECREF(obj);
1898 1899 return;
1899 1900 }
1900 1901 }
1901 1902 QHexEdit::mousePressEvent(arg__1);
1902 1903 }
1903 1904 void PythonQtShell_QHexEdit::mouseReleaseEvent(QMouseEvent* arg__1)
1904 1905 {
1905 1906 if (_wrapper) {
1906 1907 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
1907 1908 PyErr_Clear();
1908 1909 if (obj && !PythonQtSlotFunction_Check(obj)) {
1909 1910 static const char* argumentList[] ={"" , "QMouseEvent*"};
1910 1911 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1911 1912 void* args[2] = {NULL, (void*)&arg__1};
1912 1913 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1913 1914 if (result) { Py_DECREF(result); }
1914 1915 Py_DECREF(obj);
1915 1916 return;
1916 1917 }
1917 1918 }
1918 1919 QHexEdit::mouseReleaseEvent(arg__1);
1919 1920 }
1920 1921 void PythonQtShell_QHexEdit::moveEvent(QMoveEvent* arg__1)
1921 1922 {
1922 1923 if (_wrapper) {
1923 1924 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
1924 1925 PyErr_Clear();
1925 1926 if (obj && !PythonQtSlotFunction_Check(obj)) {
1926 1927 static const char* argumentList[] ={"" , "QMoveEvent*"};
1927 1928 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1928 1929 void* args[2] = {NULL, (void*)&arg__1};
1929 1930 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1930 1931 if (result) { Py_DECREF(result); }
1931 1932 Py_DECREF(obj);
1932 1933 return;
1933 1934 }
1934 1935 }
1935 1936 QHexEdit::moveEvent(arg__1);
1936 1937 }
1937 1938 bool PythonQtShell_QHexEdit::nativeEvent(const QByteArray& eventType, void* message, long* result)
1938 1939 {
1939 1940 if (_wrapper) {
1940 1941 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
1941 1942 PyErr_Clear();
1942 1943 if (obj && !PythonQtSlotFunction_Check(obj)) {
1943 1944 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
1944 1945 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
1945 1946 bool returnValue;
1946 1947 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
1947 1948 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1948 1949 if (result) {
1949 1950 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1950 1951 if (args[0]!=&returnValue) {
1951 1952 if (args[0]==NULL) {
1952 1953 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
1953 1954 } else {
1954 1955 returnValue = *((bool*)args[0]);
1955 1956 }
1956 1957 }
1957 1958 }
1958 1959 if (result) { Py_DECREF(result); }
1959 1960 Py_DECREF(obj);
1960 1961 return returnValue;
1961 1962 }
1962 1963 }
1963 1964 return QHexEdit::nativeEvent(eventType, message, result);
1964 1965 }
1965 1966 QPaintEngine* PythonQtShell_QHexEdit::paintEngine() const
1966 1967 {
1967 1968 if (_wrapper) {
1968 1969 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
1969 1970 PyErr_Clear();
1970 1971 if (obj && !PythonQtSlotFunction_Check(obj)) {
1971 1972 static const char* argumentList[] ={"QPaintEngine*"};
1972 1973 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1973 1974 QPaintEngine* returnValue;
1974 1975 void* args[1] = {NULL};
1975 1976 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1976 1977 if (result) {
1977 1978 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1978 1979 if (args[0]!=&returnValue) {
1979 1980 if (args[0]==NULL) {
1980 1981 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
1981 1982 } else {
1982 1983 returnValue = *((QPaintEngine**)args[0]);
1983 1984 }
1984 1985 }
1985 1986 }
1986 1987 if (result) { Py_DECREF(result); }
1987 1988 Py_DECREF(obj);
1988 1989 return returnValue;
1989 1990 }
1990 1991 }
1991 1992 return QHexEdit::paintEngine();
1992 1993 }
1993 1994 void PythonQtShell_QHexEdit::paintEvent(QPaintEvent* arg__1)
1994 1995 {
1995 1996 if (_wrapper) {
1996 1997 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
1997 1998 PyErr_Clear();
1998 1999 if (obj && !PythonQtSlotFunction_Check(obj)) {
1999 2000 static const char* argumentList[] ={"" , "QPaintEvent*"};
2000 2001 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2001 2002 void* args[2] = {NULL, (void*)&arg__1};
2002 2003 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2003 2004 if (result) { Py_DECREF(result); }
2004 2005 Py_DECREF(obj);
2005 2006 return;
2006 2007 }
2007 2008 }
2008 2009 QHexEdit::paintEvent(arg__1);
2009 2010 }
2010 2011 QPaintDevice* PythonQtShell_QHexEdit::redirected(QPoint* offset) const
2011 2012 {
2012 2013 if (_wrapper) {
2013 2014 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
2014 2015 PyErr_Clear();
2015 2016 if (obj && !PythonQtSlotFunction_Check(obj)) {
2016 2017 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
2017 2018 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2018 2019 QPaintDevice* returnValue;
2019 2020 void* args[2] = {NULL, (void*)&offset};
2020 2021 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2021 2022 if (result) {
2022 2023 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2023 2024 if (args[0]!=&returnValue) {
2024 2025 if (args[0]==NULL) {
2025 2026 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
2026 2027 } else {
2027 2028 returnValue = *((QPaintDevice**)args[0]);
2028 2029 }
2029 2030 }
2030 2031 }
2031 2032 if (result) { Py_DECREF(result); }
2032 2033 Py_DECREF(obj);
2033 2034 return returnValue;
2034 2035 }
2035 2036 }
2036 2037 return QHexEdit::redirected(offset);
2037 2038 }
2038 2039 void PythonQtShell_QHexEdit::resizeEvent(QResizeEvent* arg__1)
2039 2040 {
2040 2041 if (_wrapper) {
2041 2042 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
2042 2043 PyErr_Clear();
2043 2044 if (obj && !PythonQtSlotFunction_Check(obj)) {
2044 2045 static const char* argumentList[] ={"" , "QResizeEvent*"};
2045 2046 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2046 2047 void* args[2] = {NULL, (void*)&arg__1};
2047 2048 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2048 2049 if (result) { Py_DECREF(result); }
2049 2050 Py_DECREF(obj);
2050 2051 return;
2051 2052 }
2052 2053 }
2053 2054 QHexEdit::resizeEvent(arg__1);
2054 2055 }
2055 2056 void PythonQtShell_QHexEdit::scrollContentsBy(int dx, int dy)
2056 2057 {
2057 2058 if (_wrapper) {
2058 2059 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "scrollContentsBy");
2059 2060 PyErr_Clear();
2060 2061 if (obj && !PythonQtSlotFunction_Check(obj)) {
2061 2062 static const char* argumentList[] ={"" , "int" , "int"};
2062 2063 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2063 2064 void* args[3] = {NULL, (void*)&dx, (void*)&dy};
2064 2065 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2065 2066 if (result) { Py_DECREF(result); }
2066 2067 Py_DECREF(obj);
2067 2068 return;
2068 2069 }
2069 2070 }
2070 2071 QHexEdit::scrollContentsBy(dx, dy);
2071 2072 }
2072 2073 void PythonQtShell_QHexEdit::setupViewport(QWidget* viewport)
2073 2074 {
2074 2075 if (_wrapper) {
2075 2076 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setupViewport");
2076 2077 PyErr_Clear();
2077 2078 if (obj && !PythonQtSlotFunction_Check(obj)) {
2078 2079 static const char* argumentList[] ={"" , "QWidget*"};
2079 2080 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2080 2081 void* args[2] = {NULL, (void*)&viewport};
2081 2082 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2082 2083 if (result) { Py_DECREF(result); }
2083 2084 Py_DECREF(obj);
2084 2085 return;
2085 2086 }
2086 2087 }
2087 2088 QHexEdit::setupViewport(viewport);
2088 2089 }
2089 2090 QPainter* PythonQtShell_QHexEdit::sharedPainter() const
2090 2091 {
2091 2092 if (_wrapper) {
2092 2093 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
2093 2094 PyErr_Clear();
2094 2095 if (obj && !PythonQtSlotFunction_Check(obj)) {
2095 2096 static const char* argumentList[] ={"QPainter*"};
2096 2097 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2097 2098 QPainter* returnValue;
2098 2099 void* args[1] = {NULL};
2099 2100 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2100 2101 if (result) {
2101 2102 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2102 2103 if (args[0]!=&returnValue) {
2103 2104 if (args[0]==NULL) {
2104 2105 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
2105 2106 } else {
2106 2107 returnValue = *((QPainter**)args[0]);
2107 2108 }
2108 2109 }
2109 2110 }
2110 2111 if (result) { Py_DECREF(result); }
2111 2112 Py_DECREF(obj);
2112 2113 return returnValue;
2113 2114 }
2114 2115 }
2115 2116 return QHexEdit::sharedPainter();
2116 2117 }
2117 2118 void PythonQtShell_QHexEdit::showEvent(QShowEvent* arg__1)
2118 2119 {
2119 2120 if (_wrapper) {
2120 2121 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
2121 2122 PyErr_Clear();
2122 2123 if (obj && !PythonQtSlotFunction_Check(obj)) {
2123 2124 static const char* argumentList[] ={"" , "QShowEvent*"};
2124 2125 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2125 2126 void* args[2] = {NULL, (void*)&arg__1};
2126 2127 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2127 2128 if (result) { Py_DECREF(result); }
2128 2129 Py_DECREF(obj);
2129 2130 return;
2130 2131 }
2131 2132 }
2132 2133 QHexEdit::showEvent(arg__1);
2133 2134 }
2134 2135 void PythonQtShell_QHexEdit::tabletEvent(QTabletEvent* arg__1)
2135 2136 {
2136 2137 if (_wrapper) {
2137 2138 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
2138 2139 PyErr_Clear();
2139 2140 if (obj && !PythonQtSlotFunction_Check(obj)) {
2140 2141 static const char* argumentList[] ={"" , "QTabletEvent*"};
2141 2142 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2142 2143 void* args[2] = {NULL, (void*)&arg__1};
2143 2144 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2144 2145 if (result) { Py_DECREF(result); }
2145 2146 Py_DECREF(obj);
2146 2147 return;
2147 2148 }
2148 2149 }
2149 2150 QHexEdit::tabletEvent(arg__1);
2150 2151 }
2151 2152 void PythonQtShell_QHexEdit::timerEvent(QTimerEvent* arg__1)
2152 2153 {
2153 2154 if (_wrapper) {
2154 2155 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
2155 2156 PyErr_Clear();
2156 2157 if (obj && !PythonQtSlotFunction_Check(obj)) {
2157 2158 static const char* argumentList[] ={"" , "QTimerEvent*"};
2158 2159 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2159 2160 void* args[2] = {NULL, (void*)&arg__1};
2160 2161 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2161 2162 if (result) { Py_DECREF(result); }
2162 2163 Py_DECREF(obj);
2163 2164 return;
2164 2165 }
2165 2166 }
2166 2167 QHexEdit::timerEvent(arg__1);
2167 2168 }
2168 2169 bool PythonQtShell_QHexEdit::viewportEvent(QEvent* arg__1)
2169 2170 {
2170 2171 if (_wrapper) {
2171 2172 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportEvent");
2172 2173 PyErr_Clear();
2173 2174 if (obj && !PythonQtSlotFunction_Check(obj)) {
2174 2175 static const char* argumentList[] ={"bool" , "QEvent*"};
2175 2176 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2176 2177 bool returnValue;
2177 2178 void* args[2] = {NULL, (void*)&arg__1};
2178 2179 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2179 2180 if (result) {
2180 2181 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2181 2182 if (args[0]!=&returnValue) {
2182 2183 if (args[0]==NULL) {
2183 2184 PythonQt::priv()->handleVirtualOverloadReturnError("viewportEvent", methodInfo, result);
2184 2185 } else {
2185 2186 returnValue = *((bool*)args[0]);
2186 2187 }
2187 2188 }
2188 2189 }
2189 2190 if (result) { Py_DECREF(result); }
2190 2191 Py_DECREF(obj);
2191 2192 return returnValue;
2192 2193 }
2193 2194 }
2194 2195 return QHexEdit::viewportEvent(arg__1);
2195 2196 }
2196 2197 QSize PythonQtShell_QHexEdit::viewportSizeHint() const
2197 2198 {
2198 2199 if (_wrapper) {
2199 2200 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportSizeHint");
2200 2201 PyErr_Clear();
2201 2202 if (obj && !PythonQtSlotFunction_Check(obj)) {
2202 2203 static const char* argumentList[] ={"QSize"};
2203 2204 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2204 2205 QSize returnValue;
2205 2206 void* args[1] = {NULL};
2206 2207 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2207 2208 if (result) {
2208 2209 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2209 2210 if (args[0]!=&returnValue) {
2210 2211 if (args[0]==NULL) {
2211 2212 PythonQt::priv()->handleVirtualOverloadReturnError("viewportSizeHint", methodInfo, result);
2212 2213 } else {
2213 2214 returnValue = *((QSize*)args[0]);
2214 2215 }
2215 2216 }
2216 2217 }
2217 2218 if (result) { Py_DECREF(result); }
2218 2219 Py_DECREF(obj);
2219 2220 return returnValue;
2220 2221 }
2221 2222 }
2222 2223 return QHexEdit::viewportSizeHint();
2223 2224 }
2224 2225 void PythonQtShell_QHexEdit::wheelEvent(QWheelEvent* arg__1)
2225 2226 {
2226 2227 if (_wrapper) {
2227 2228 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
2228 2229 PyErr_Clear();
2229 2230 if (obj && !PythonQtSlotFunction_Check(obj)) {
2230 2231 static const char* argumentList[] ={"" , "QWheelEvent*"};
2231 2232 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2232 2233 void* args[2] = {NULL, (void*)&arg__1};
2233 2234 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2234 2235 if (result) { Py_DECREF(result); }
2235 2236 Py_DECREF(obj);
2236 2237 return;
2237 2238 }
2238 2239 }
2239 2240 QHexEdit::wheelEvent(arg__1);
2240 2241 }
2241 2242 QHexEdit* PythonQtWrapper_QHexEdit::new_QHexEdit(QWidget* parent)
2242 2243 {
2243 2244 return new PythonQtShell_QHexEdit(parent); }
2244 2245
2245 2246 QColor PythonQtWrapper_QHexEdit::addressAreaColor(QHexEdit* theWrappedObject)
2246 2247 {
2247 2248 return ( theWrappedObject->addressAreaColor());
2248 2249 }
2249 2250
2250 2251 int PythonQtWrapper_QHexEdit::addressOffset(QHexEdit* theWrappedObject)
2251 2252 {
2252 2253 return ( theWrappedObject->addressOffset());
2253 2254 }
2254 2255
2255 2256 int PythonQtWrapper_QHexEdit::cursorPosition(QHexEdit* theWrappedObject)
2256 2257 {
2257 2258 return ( theWrappedObject->cursorPosition());
2258 2259 }
2259 2260
2260 2261 QByteArray PythonQtWrapper_QHexEdit::data(QHexEdit* theWrappedObject)
2261 2262 {
2262 2263 return ( theWrappedObject->data());
2263 2264 }
2264 2265
2265 2266 const QFont* PythonQtWrapper_QHexEdit::font(QHexEdit* theWrappedObject) const
2266 2267 {
2267 2268 return &( theWrappedObject->font());
2268 2269 }
2269 2270
2270 2271 QColor PythonQtWrapper_QHexEdit::highlightingColor(QHexEdit* theWrappedObject)
2271 2272 {
2272 2273 return ( theWrappedObject->highlightingColor());
2273 2274 }
2274 2275
2275 2276 int PythonQtWrapper_QHexEdit::indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2276 2277 {
2277 2278 return ( theWrappedObject->indexOf(ba, from));
2278 2279 }
2279 2280
2280 2281 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, char ch)
2281 2282 {
2282 2283 ( theWrappedObject->insert(i, ch));
2283 2284 }
2284 2285
2285 2286 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba)
2286 2287 {
2287 2288 ( theWrappedObject->insert(i, ba));
2288 2289 }
2289 2290
2290 2291 bool PythonQtWrapper_QHexEdit::isReadOnly(QHexEdit* theWrappedObject)
2291 2292 {
2292 2293 return ( theWrappedObject->isReadOnly());
2293 2294 }
2294 2295
2295 2296 int PythonQtWrapper_QHexEdit::lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2296 2297 {
2297 2298 return ( theWrappedObject->lastIndexOf(ba, from));
2298 2299 }
2299 2300
2300 2301 bool PythonQtWrapper_QHexEdit::overwriteMode(QHexEdit* theWrappedObject)
2301 2302 {
2302 2303 return ( theWrappedObject->overwriteMode());
2303 2304 }
2304 2305
2305 2306 void PythonQtWrapper_QHexEdit::remove(QHexEdit* theWrappedObject, int pos, int len)
2306 2307 {
2307 2308 ( theWrappedObject->remove(pos, len));
2308 2309 }
2309 2310
2310 2311 void PythonQtWrapper_QHexEdit::replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after)
2311 2312 {
2312 2313 ( theWrappedObject->replace(pos, len, after));
2313 2314 }
2314 2315
2315 2316 QColor PythonQtWrapper_QHexEdit::selectionColor(QHexEdit* theWrappedObject)
2316 2317 {
2317 2318 return ( theWrappedObject->selectionColor());
2318 2319 }
2319 2320
2320 2321 QString PythonQtWrapper_QHexEdit::selectionToReadableString(QHexEdit* theWrappedObject)
2321 2322 {
2322 2323 return ( theWrappedObject->selectionToReadableString());
2323 2324 }
2324 2325
2325 2326 void PythonQtWrapper_QHexEdit::setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color)
2326 2327 {
2327 2328 ( theWrappedObject->setAddressAreaColor(color));
2328 2329 }
2329 2330
2330 2331 void PythonQtWrapper_QHexEdit::setAddressOffset(QHexEdit* theWrappedObject, int offset)
2331 2332 {
2332 2333 ( theWrappedObject->setAddressOffset(offset));
2333 2334 }
2334 2335
2335 2336 void PythonQtWrapper_QHexEdit::setCursorPosition(QHexEdit* theWrappedObject, int cusorPos)
2336 2337 {
2337 2338 ( theWrappedObject->setCursorPosition(cusorPos));
2338 2339 }
2339 2340
2340 2341 void PythonQtWrapper_QHexEdit::setData(QHexEdit* theWrappedObject, const QByteArray& data)
2341 2342 {
2342 2343 ( theWrappedObject->setData(data));
2343 2344 }
2344 2345
2345 2346 void PythonQtWrapper_QHexEdit::setFont(QHexEdit* theWrappedObject, const QFont& arg__1)
2346 2347 {
2347 2348 ( theWrappedObject->setFont(arg__1));
2348 2349 }
2349 2350
2350 2351 void PythonQtWrapper_QHexEdit::setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color)
2351 2352 {
2352 2353 ( theWrappedObject->setHighlightingColor(color));
2353 2354 }
2354 2355
2355 2356 void PythonQtWrapper_QHexEdit::setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1)
2356 2357 {
2357 2358 ( theWrappedObject->setOverwriteMode(arg__1));
2358 2359 }
2359 2360
2360 2361 void PythonQtWrapper_QHexEdit::setReadOnly(QHexEdit* theWrappedObject, bool arg__1)
2361 2362 {
2362 2363 ( theWrappedObject->setReadOnly(arg__1));
2363 2364 }
2364 2365
2365 2366 void PythonQtWrapper_QHexEdit::setSelectionColor(QHexEdit* theWrappedObject, const QColor& color)
2366 2367 {
2367 2368 ( theWrappedObject->setSelectionColor(color));
2368 2369 }
2369 2370
2370 2371 QString PythonQtWrapper_QHexEdit::toReadableString(QHexEdit* theWrappedObject)
2371 2372 {
2372 2373 return ( theWrappedObject->toReadableString());
2373 2374 }
2374 2375
2375 2376
2376 2377
2377 2378 PythonQtShell_QHexSpinBox::~PythonQtShell_QHexSpinBox() {
2378 2379 PythonQtPrivate* priv = PythonQt::priv();
2379 2380 if (priv) { priv->shellClassDeleted(this); }
2380 2381 }
2381 2382 void PythonQtShell_QHexSpinBox::actionEvent(QActionEvent* arg__1)
2382 2383 {
2383 2384 if (_wrapper) {
2384 2385 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
2385 2386 PyErr_Clear();
2386 2387 if (obj && !PythonQtSlotFunction_Check(obj)) {
2387 2388 static const char* argumentList[] ={"" , "QActionEvent*"};
2388 2389 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2389 2390 void* args[2] = {NULL, (void*)&arg__1};
2390 2391 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2391 2392 if (result) { Py_DECREF(result); }
2392 2393 Py_DECREF(obj);
2393 2394 return;
2394 2395 }
2395 2396 }
2396 2397 QHexSpinBox::actionEvent(arg__1);
2397 2398 }
2398 2399 void PythonQtShell_QHexSpinBox::changeEvent(QEvent* event)
2399 2400 {
2400 2401 if (_wrapper) {
2401 2402 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
2402 2403 PyErr_Clear();
2403 2404 if (obj && !PythonQtSlotFunction_Check(obj)) {
2404 2405 static const char* argumentList[] ={"" , "QEvent*"};
2405 2406 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2406 2407 void* args[2] = {NULL, (void*)&event};
2407 2408 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2408 2409 if (result) { Py_DECREF(result); }
2409 2410 Py_DECREF(obj);
2410 2411 return;
2411 2412 }
2412 2413 }
2413 2414 QHexSpinBox::changeEvent(event);
2414 2415 }
2415 2416 void PythonQtShell_QHexSpinBox::childEvent(QChildEvent* arg__1)
2416 2417 {
2417 2418 if (_wrapper) {
2418 2419 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
2419 2420 PyErr_Clear();
2420 2421 if (obj && !PythonQtSlotFunction_Check(obj)) {
2421 2422 static const char* argumentList[] ={"" , "QChildEvent*"};
2422 2423 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2423 2424 void* args[2] = {NULL, (void*)&arg__1};
2424 2425 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2425 2426 if (result) { Py_DECREF(result); }
2426 2427 Py_DECREF(obj);
2427 2428 return;
2428 2429 }
2429 2430 }
2430 2431 QHexSpinBox::childEvent(arg__1);
2431 2432 }
2432 2433 void PythonQtShell_QHexSpinBox::clear()
2433 2434 {
2434 2435 if (_wrapper) {
2435 2436 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "clear");
2436 2437 PyErr_Clear();
2437 2438 if (obj && !PythonQtSlotFunction_Check(obj)) {
2438 2439 static const char* argumentList[] ={""};
2439 2440 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2440 2441 void* args[1] = {NULL};
2441 2442 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2442 2443 if (result) { Py_DECREF(result); }
2443 2444 Py_DECREF(obj);
2444 2445 return;
2445 2446 }
2446 2447 }
2447 2448 QHexSpinBox::clear();
2448 2449 }
2449 2450 void PythonQtShell_QHexSpinBox::closeEvent(QCloseEvent* event)
2450 2451 {
2451 2452 if (_wrapper) {
2452 2453 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
2453 2454 PyErr_Clear();
2454 2455 if (obj && !PythonQtSlotFunction_Check(obj)) {
2455 2456 static const char* argumentList[] ={"" , "QCloseEvent*"};
2456 2457 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2457 2458 void* args[2] = {NULL, (void*)&event};
2458 2459 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2459 2460 if (result) { Py_DECREF(result); }
2460 2461 Py_DECREF(obj);
2461 2462 return;
2462 2463 }
2463 2464 }
2464 2465 QHexSpinBox::closeEvent(event);
2465 2466 }
2466 2467 void PythonQtShell_QHexSpinBox::contextMenuEvent(QContextMenuEvent* event)
2467 2468 {
2468 2469 if (_wrapper) {
2469 2470 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
2470 2471 PyErr_Clear();
2471 2472 if (obj && !PythonQtSlotFunction_Check(obj)) {
2472 2473 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
2473 2474 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2474 2475 void* args[2] = {NULL, (void*)&event};
2475 2476 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2476 2477 if (result) { Py_DECREF(result); }
2477 2478 Py_DECREF(obj);
2478 2479 return;
2479 2480 }
2480 2481 }
2481 2482 QHexSpinBox::contextMenuEvent(event);
2482 2483 }
2483 2484 void PythonQtShell_QHexSpinBox::customEvent(QEvent* arg__1)
2484 2485 {
2485 2486 if (_wrapper) {
2486 2487 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
2487 2488 PyErr_Clear();
2488 2489 if (obj && !PythonQtSlotFunction_Check(obj)) {
2489 2490 static const char* argumentList[] ={"" , "QEvent*"};
2490 2491 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2491 2492 void* args[2] = {NULL, (void*)&arg__1};
2492 2493 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2493 2494 if (result) { Py_DECREF(result); }
2494 2495 Py_DECREF(obj);
2495 2496 return;
2496 2497 }
2497 2498 }
2498 2499 QHexSpinBox::customEvent(arg__1);
2499 2500 }
2500 2501 int PythonQtShell_QHexSpinBox::devType() const
2501 2502 {
2502 2503 if (_wrapper) {
2503 2504 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
2504 2505 PyErr_Clear();
2505 2506 if (obj && !PythonQtSlotFunction_Check(obj)) {
2506 2507 static const char* argumentList[] ={"int"};
2507 2508 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2508 2509 int returnValue;
2509 2510 void* args[1] = {NULL};
2510 2511 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2511 2512 if (result) {
2512 2513 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2513 2514 if (args[0]!=&returnValue) {
2514 2515 if (args[0]==NULL) {
2515 2516 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
2516 2517 } else {
2517 2518 returnValue = *((int*)args[0]);
2518 2519 }
2519 2520 }
2520 2521 }
2521 2522 if (result) { Py_DECREF(result); }
2522 2523 Py_DECREF(obj);
2523 2524 return returnValue;
2524 2525 }
2525 2526 }
2526 2527 return QHexSpinBox::devType();
2527 2528 }
2528 2529 void PythonQtShell_QHexSpinBox::dragEnterEvent(QDragEnterEvent* arg__1)
2529 2530 {
2530 2531 if (_wrapper) {
2531 2532 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
2532 2533 PyErr_Clear();
2533 2534 if (obj && !PythonQtSlotFunction_Check(obj)) {
2534 2535 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
2535 2536 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2536 2537 void* args[2] = {NULL, (void*)&arg__1};
2537 2538 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2538 2539 if (result) { Py_DECREF(result); }
2539 2540 Py_DECREF(obj);
2540 2541 return;
2541 2542 }
2542 2543 }
2543 2544 QHexSpinBox::dragEnterEvent(arg__1);
2544 2545 }
2545 2546 void PythonQtShell_QHexSpinBox::dragLeaveEvent(QDragLeaveEvent* arg__1)
2546 2547 {
2547 2548 if (_wrapper) {
2548 2549 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
2549 2550 PyErr_Clear();
2550 2551 if (obj && !PythonQtSlotFunction_Check(obj)) {
2551 2552 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
2552 2553 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2553 2554 void* args[2] = {NULL, (void*)&arg__1};
2554 2555 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2555 2556 if (result) { Py_DECREF(result); }
2556 2557 Py_DECREF(obj);
2557 2558 return;
2558 2559 }
2559 2560 }
2560 2561 QHexSpinBox::dragLeaveEvent(arg__1);
2561 2562 }
2562 2563 void PythonQtShell_QHexSpinBox::dragMoveEvent(QDragMoveEvent* arg__1)
2563 2564 {
2564 2565 if (_wrapper) {
2565 2566 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
2566 2567 PyErr_Clear();
2567 2568 if (obj && !PythonQtSlotFunction_Check(obj)) {
2568 2569 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
2569 2570 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2570 2571 void* args[2] = {NULL, (void*)&arg__1};
2571 2572 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2572 2573 if (result) { Py_DECREF(result); }
2573 2574 Py_DECREF(obj);
2574 2575 return;
2575 2576 }
2576 2577 }
2577 2578 QHexSpinBox::dragMoveEvent(arg__1);
2578 2579 }
2579 2580 void PythonQtShell_QHexSpinBox::dropEvent(QDropEvent* arg__1)
2580 2581 {
2581 2582 if (_wrapper) {
2582 2583 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
2583 2584 PyErr_Clear();
2584 2585 if (obj && !PythonQtSlotFunction_Check(obj)) {
2585 2586 static const char* argumentList[] ={"" , "QDropEvent*"};
2586 2587 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2587 2588 void* args[2] = {NULL, (void*)&arg__1};
2588 2589 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2589 2590 if (result) { Py_DECREF(result); }
2590 2591 Py_DECREF(obj);
2591 2592 return;
2592 2593 }
2593 2594 }
2594 2595 QHexSpinBox::dropEvent(arg__1);
2595 2596 }
2596 2597 void PythonQtShell_QHexSpinBox::enterEvent(QEvent* arg__1)
2597 2598 {
2598 2599 if (_wrapper) {
2599 2600 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
2600 2601 PyErr_Clear();
2601 2602 if (obj && !PythonQtSlotFunction_Check(obj)) {
2602 2603 static const char* argumentList[] ={"" , "QEvent*"};
2603 2604 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2604 2605 void* args[2] = {NULL, (void*)&arg__1};
2605 2606 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2606 2607 if (result) { Py_DECREF(result); }
2607 2608 Py_DECREF(obj);
2608 2609 return;
2609 2610 }
2610 2611 }
2611 2612 QHexSpinBox::enterEvent(arg__1);
2612 2613 }
2613 2614 bool PythonQtShell_QHexSpinBox::event(QEvent* event)
2614 2615 {
2615 2616 if (_wrapper) {
2616 2617 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
2617 2618 PyErr_Clear();
2618 2619 if (obj && !PythonQtSlotFunction_Check(obj)) {
2619 2620 static const char* argumentList[] ={"bool" , "QEvent*"};
2620 2621 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2621 2622 bool returnValue;
2622 2623 void* args[2] = {NULL, (void*)&event};
2623 2624 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2624 2625 if (result) {
2625 2626 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2626 2627 if (args[0]!=&returnValue) {
2627 2628 if (args[0]==NULL) {
2628 2629 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
2629 2630 } else {
2630 2631 returnValue = *((bool*)args[0]);
2631 2632 }
2632 2633 }
2633 2634 }
2634 2635 if (result) { Py_DECREF(result); }
2635 2636 Py_DECREF(obj);
2636 2637 return returnValue;
2637 2638 }
2638 2639 }
2639 2640 return QHexSpinBox::event(event);
2640 2641 }
2641 2642 bool PythonQtShell_QHexSpinBox::eventFilter(QObject* arg__1, QEvent* arg__2)
2642 2643 {
2643 2644 if (_wrapper) {
2644 2645 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
2645 2646 PyErr_Clear();
2646 2647 if (obj && !PythonQtSlotFunction_Check(obj)) {
2647 2648 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
2648 2649 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2649 2650 bool returnValue;
2650 2651 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
2651 2652 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2652 2653 if (result) {
2653 2654 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2654 2655 if (args[0]!=&returnValue) {
2655 2656 if (args[0]==NULL) {
2656 2657 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
2657 2658 } else {
2658 2659 returnValue = *((bool*)args[0]);
2659 2660 }
2660 2661 }
2661 2662 }
2662 2663 if (result) { Py_DECREF(result); }
2663 2664 Py_DECREF(obj);
2664 2665 return returnValue;
2665 2666 }
2666 2667 }
2667 2668 return QHexSpinBox::eventFilter(arg__1, arg__2);
2668 2669 }
2669 2670 void PythonQtShell_QHexSpinBox::fixup(QString& str) const
2670 2671 {
2671 2672 if (_wrapper) {
2672 2673 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "fixup");
2673 2674 PyErr_Clear();
2674 2675 if (obj && !PythonQtSlotFunction_Check(obj)) {
2675 2676 static const char* argumentList[] ={"" , "QString&"};
2676 2677 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2677 2678 void* args[2] = {NULL, (void*)&str};
2678 2679 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2679 2680 if (result) { Py_DECREF(result); }
2680 2681 Py_DECREF(obj);
2681 2682 return;
2682 2683 }
2683 2684 }
2684 2685 QHexSpinBox::fixup(str);
2685 2686 }
2686 2687 void PythonQtShell_QHexSpinBox::focusInEvent(QFocusEvent* event)
2687 2688 {
2688 2689 if (_wrapper) {
2689 2690 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
2690 2691 PyErr_Clear();
2691 2692 if (obj && !PythonQtSlotFunction_Check(obj)) {
2692 2693 static const char* argumentList[] ={"" , "QFocusEvent*"};
2693 2694 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2694 2695 void* args[2] = {NULL, (void*)&event};
2695 2696 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2696 2697 if (result) { Py_DECREF(result); }
2697 2698 Py_DECREF(obj);
2698 2699 return;
2699 2700 }
2700 2701 }
2701 2702 QHexSpinBox::focusInEvent(event);
2702 2703 }
2703 2704 bool PythonQtShell_QHexSpinBox::focusNextPrevChild(bool next)
2704 2705 {
2705 2706 if (_wrapper) {
2706 2707 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
2707 2708 PyErr_Clear();
2708 2709 if (obj && !PythonQtSlotFunction_Check(obj)) {
2709 2710 static const char* argumentList[] ={"bool" , "bool"};
2710 2711 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2711 2712 bool returnValue;
2712 2713 void* args[2] = {NULL, (void*)&next};
2713 2714 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2714 2715 if (result) {
2715 2716 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2716 2717 if (args[0]!=&returnValue) {
2717 2718 if (args[0]==NULL) {
2718 2719 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
2719 2720 } else {
2720 2721 returnValue = *((bool*)args[0]);
2721 2722 }
2722 2723 }
2723 2724 }
2724 2725 if (result) { Py_DECREF(result); }
2725 2726 Py_DECREF(obj);
2726 2727 return returnValue;
2727 2728 }
2728 2729 }
2729 2730 return QHexSpinBox::focusNextPrevChild(next);
2730 2731 }
2731 2732 void PythonQtShell_QHexSpinBox::focusOutEvent(QFocusEvent* event)
2732 2733 {
2733 2734 if (_wrapper) {
2734 2735 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
2735 2736 PyErr_Clear();
2736 2737 if (obj && !PythonQtSlotFunction_Check(obj)) {
2737 2738 static const char* argumentList[] ={"" , "QFocusEvent*"};
2738 2739 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2739 2740 void* args[2] = {NULL, (void*)&event};
2740 2741 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2741 2742 if (result) { Py_DECREF(result); }
2742 2743 Py_DECREF(obj);
2743 2744 return;
2744 2745 }
2745 2746 }
2746 2747 QHexSpinBox::focusOutEvent(event);
2747 2748 }
2748 2749 bool PythonQtShell_QHexSpinBox::hasHeightForWidth() const
2749 2750 {
2750 2751 if (_wrapper) {
2751 2752 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
2752 2753 PyErr_Clear();
2753 2754 if (obj && !PythonQtSlotFunction_Check(obj)) {
2754 2755 static const char* argumentList[] ={"bool"};
2755 2756 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2756 2757 bool returnValue;
2757 2758 void* args[1] = {NULL};
2758 2759 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2759 2760 if (result) {
2760 2761 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2761 2762 if (args[0]!=&returnValue) {
2762 2763 if (args[0]==NULL) {
2763 2764 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
2764 2765 } else {
2765 2766 returnValue = *((bool*)args[0]);
2766 2767 }
2767 2768 }
2768 2769 }
2769 2770 if (result) { Py_DECREF(result); }
2770 2771 Py_DECREF(obj);
2771 2772 return returnValue;
2772 2773 }
2773 2774 }
2774 2775 return QHexSpinBox::hasHeightForWidth();
2775 2776 }
2776 2777 int PythonQtShell_QHexSpinBox::heightForWidth(int arg__1) const
2777 2778 {
2778 2779 if (_wrapper) {
2779 2780 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
2780 2781 PyErr_Clear();
2781 2782 if (obj && !PythonQtSlotFunction_Check(obj)) {
2782 2783 static const char* argumentList[] ={"int" , "int"};
2783 2784 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2784 2785 int returnValue;
2785 2786 void* args[2] = {NULL, (void*)&arg__1};
2786 2787 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2787 2788 if (result) {
2788 2789 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2789 2790 if (args[0]!=&returnValue) {
2790 2791 if (args[0]==NULL) {
2791 2792 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
2792 2793 } else {
2793 2794 returnValue = *((int*)args[0]);
2794 2795 }
2795 2796 }
2796 2797 }
2797 2798 if (result) { Py_DECREF(result); }
2798 2799 Py_DECREF(obj);
2799 2800 return returnValue;
2800 2801 }
2801 2802 }
2802 2803 return QHexSpinBox::heightForWidth(arg__1);
2803 2804 }
2804 2805 void PythonQtShell_QHexSpinBox::hideEvent(QHideEvent* event)
2805 2806 {
2806 2807 if (_wrapper) {
2807 2808 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
2808 2809 PyErr_Clear();
2809 2810 if (obj && !PythonQtSlotFunction_Check(obj)) {
2810 2811 static const char* argumentList[] ={"" , "QHideEvent*"};
2811 2812 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2812 2813 void* args[2] = {NULL, (void*)&event};
2813 2814 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2814 2815 if (result) { Py_DECREF(result); }
2815 2816 Py_DECREF(obj);
2816 2817 return;
2817 2818 }
2818 2819 }
2819 2820 QHexSpinBox::hideEvent(event);
2820 2821 }
2821 2822 void PythonQtShell_QHexSpinBox::initPainter(QPainter* painter) const
2822 2823 {
2823 2824 if (_wrapper) {
2824 2825 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
2825 2826 PyErr_Clear();
2826 2827 if (obj && !PythonQtSlotFunction_Check(obj)) {
2827 2828 static const char* argumentList[] ={"" , "QPainter*"};
2828 2829 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2829 2830 void* args[2] = {NULL, (void*)&painter};
2830 2831 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2831 2832 if (result) { Py_DECREF(result); }
2832 2833 Py_DECREF(obj);
2833 2834 return;
2834 2835 }
2835 2836 }
2836 2837 QHexSpinBox::initPainter(painter);
2837 2838 }
2838 2839 void PythonQtShell_QHexSpinBox::inputMethodEvent(QInputMethodEvent* arg__1)
2839 2840 {
2840 2841 if (_wrapper) {
2841 2842 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
2842 2843 PyErr_Clear();
2843 2844 if (obj && !PythonQtSlotFunction_Check(obj)) {
2844 2845 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
2845 2846 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2846 2847 void* args[2] = {NULL, (void*)&arg__1};
2847 2848 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2848 2849 if (result) { Py_DECREF(result); }
2849 2850 Py_DECREF(obj);
2850 2851 return;
2851 2852 }
2852 2853 }
2853 2854 QHexSpinBox::inputMethodEvent(arg__1);
2854 2855 }
2855 2856 QVariant PythonQtShell_QHexSpinBox::inputMethodQuery(Qt::InputMethodQuery arg__1) const
2856 2857 {
2857 2858 if (_wrapper) {
2858 2859 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
2859 2860 PyErr_Clear();
2860 2861 if (obj && !PythonQtSlotFunction_Check(obj)) {
2861 2862 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
2862 2863 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2863 2864 QVariant returnValue;
2864 2865 void* args[2] = {NULL, (void*)&arg__1};
2865 2866 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2866 2867 if (result) {
2867 2868 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2868 2869 if (args[0]!=&returnValue) {
2869 2870 if (args[0]==NULL) {
2870 2871 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
2871 2872 } else {
2872 2873 returnValue = *((QVariant*)args[0]);
2873 2874 }
2874 2875 }
2875 2876 }
2876 2877 if (result) { Py_DECREF(result); }
2877 2878 Py_DECREF(obj);
2878 2879 return returnValue;
2879 2880 }
2880 2881 }
2881 2882 return QHexSpinBox::inputMethodQuery(arg__1);
2882 2883 }
2883 2884 void PythonQtShell_QHexSpinBox::keyPressEvent(QKeyEvent* event)
2884 2885 {
2885 2886 if (_wrapper) {
2886 2887 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
2887 2888 PyErr_Clear();
2888 2889 if (obj && !PythonQtSlotFunction_Check(obj)) {
2889 2890 static const char* argumentList[] ={"" , "QKeyEvent*"};
2890 2891 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2891 2892 void* args[2] = {NULL, (void*)&event};
2892 2893 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2893 2894 if (result) { Py_DECREF(result); }
2894 2895 Py_DECREF(obj);
2895 2896 return;
2896 2897 }
2897 2898 }
2898 2899 QHexSpinBox::keyPressEvent(event);
2899 2900 }
2900 2901 void PythonQtShell_QHexSpinBox::keyReleaseEvent(QKeyEvent* event)
2901 2902 {
2902 2903 if (_wrapper) {
2903 2904 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
2904 2905 PyErr_Clear();
2905 2906 if (obj && !PythonQtSlotFunction_Check(obj)) {
2906 2907 static const char* argumentList[] ={"" , "QKeyEvent*"};
2907 2908 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2908 2909 void* args[2] = {NULL, (void*)&event};
2909 2910 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2910 2911 if (result) { Py_DECREF(result); }
2911 2912 Py_DECREF(obj);
2912 2913 return;
2913 2914 }
2914 2915 }
2915 2916 QHexSpinBox::keyReleaseEvent(event);
2916 2917 }
2917 2918 void PythonQtShell_QHexSpinBox::leaveEvent(QEvent* arg__1)
2918 2919 {
2919 2920 if (_wrapper) {
2920 2921 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
2921 2922 PyErr_Clear();
2922 2923 if (obj && !PythonQtSlotFunction_Check(obj)) {
2923 2924 static const char* argumentList[] ={"" , "QEvent*"};
2924 2925 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2925 2926 void* args[2] = {NULL, (void*)&arg__1};
2926 2927 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2927 2928 if (result) { Py_DECREF(result); }
2928 2929 Py_DECREF(obj);
2929 2930 return;
2930 2931 }
2931 2932 }
2932 2933 QHexSpinBox::leaveEvent(arg__1);
2933 2934 }
2934 2935 int PythonQtShell_QHexSpinBox::metric(QPaintDevice::PaintDeviceMetric arg__1) const
2935 2936 {
2936 2937 if (_wrapper) {
2937 2938 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
2938 2939 PyErr_Clear();
2939 2940 if (obj && !PythonQtSlotFunction_Check(obj)) {
2940 2941 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
2941 2942 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2942 2943 int returnValue;
2943 2944 void* args[2] = {NULL, (void*)&arg__1};
2944 2945 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2945 2946 if (result) {
2946 2947 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2947 2948 if (args[0]!=&returnValue) {
2948 2949 if (args[0]==NULL) {
2949 2950 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
2950 2951 } else {
2951 2952 returnValue = *((int*)args[0]);
2952 2953 }
2953 2954 }
2954 2955 }
2955 2956 if (result) { Py_DECREF(result); }
2956 2957 Py_DECREF(obj);
2957 2958 return returnValue;
2958 2959 }
2959 2960 }
2960 2961 return QHexSpinBox::metric(arg__1);
2961 2962 }
2962 2963 void PythonQtShell_QHexSpinBox::mouseDoubleClickEvent(QMouseEvent* arg__1)
2963 2964 {
2964 2965 if (_wrapper) {
2965 2966 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
2966 2967 PyErr_Clear();
2967 2968 if (obj && !PythonQtSlotFunction_Check(obj)) {
2968 2969 static const char* argumentList[] ={"" , "QMouseEvent*"};
2969 2970 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2970 2971 void* args[2] = {NULL, (void*)&arg__1};
2971 2972 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2972 2973 if (result) { Py_DECREF(result); }
2973 2974 Py_DECREF(obj);
2974 2975 return;
2975 2976 }
2976 2977 }
2977 2978 QHexSpinBox::mouseDoubleClickEvent(arg__1);
2978 2979 }
2979 2980 void PythonQtShell_QHexSpinBox::mouseMoveEvent(QMouseEvent* event)
2980 2981 {
2981 2982 if (_wrapper) {
2982 2983 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
2983 2984 PyErr_Clear();
2984 2985 if (obj && !PythonQtSlotFunction_Check(obj)) {
2985 2986 static const char* argumentList[] ={"" , "QMouseEvent*"};
2986 2987 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2987 2988 void* args[2] = {NULL, (void*)&event};
2988 2989 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2989 2990 if (result) { Py_DECREF(result); }
2990 2991 Py_DECREF(obj);
2991 2992 return;
2992 2993 }
2993 2994 }
2994 2995 QHexSpinBox::mouseMoveEvent(event);
2995 2996 }
2996 2997 void PythonQtShell_QHexSpinBox::mousePressEvent(QMouseEvent* event)
2997 2998 {
2998 2999 if (_wrapper) {
2999 3000 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
3000 3001 PyErr_Clear();
3001 3002 if (obj && !PythonQtSlotFunction_Check(obj)) {
3002 3003 static const char* argumentList[] ={"" , "QMouseEvent*"};
3003 3004 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3004 3005 void* args[2] = {NULL, (void*)&event};
3005 3006 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3006 3007 if (result) { Py_DECREF(result); }
3007 3008 Py_DECREF(obj);
3008 3009 return;
3009 3010 }
3010 3011 }
3011 3012 QHexSpinBox::mousePressEvent(event);
3012 3013 }
3013 3014 void PythonQtShell_QHexSpinBox::mouseReleaseEvent(QMouseEvent* event)
3014 3015 {
3015 3016 if (_wrapper) {
3016 3017 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
3017 3018 PyErr_Clear();
3018 3019 if (obj && !PythonQtSlotFunction_Check(obj)) {
3019 3020 static const char* argumentList[] ={"" , "QMouseEvent*"};
3020 3021 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3021 3022 void* args[2] = {NULL, (void*)&event};
3022 3023 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3023 3024 if (result) { Py_DECREF(result); }
3024 3025 Py_DECREF(obj);
3025 3026 return;
3026 3027 }
3027 3028 }
3028 3029 QHexSpinBox::mouseReleaseEvent(event);
3029 3030 }
3030 3031 void PythonQtShell_QHexSpinBox::moveEvent(QMoveEvent* arg__1)
3031 3032 {
3032 3033 if (_wrapper) {
3033 3034 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
3034 3035 PyErr_Clear();
3035 3036 if (obj && !PythonQtSlotFunction_Check(obj)) {
3036 3037 static const char* argumentList[] ={"" , "QMoveEvent*"};
3037 3038 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3038 3039 void* args[2] = {NULL, (void*)&arg__1};
3039 3040 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3040 3041 if (result) { Py_DECREF(result); }
3041 3042 Py_DECREF(obj);
3042 3043 return;
3043 3044 }
3044 3045 }
3045 3046 QHexSpinBox::moveEvent(arg__1);
3046 3047 }
3047 3048 bool PythonQtShell_QHexSpinBox::nativeEvent(const QByteArray& eventType, void* message, long* result)
3048 3049 {
3049 3050 if (_wrapper) {
3050 3051 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
3051 3052 PyErr_Clear();
3052 3053 if (obj && !PythonQtSlotFunction_Check(obj)) {
3053 3054 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
3054 3055 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
3055 3056 bool returnValue;
3056 3057 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
3057 3058 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3058 3059 if (result) {
3059 3060 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3060 3061 if (args[0]!=&returnValue) {
3061 3062 if (args[0]==NULL) {
3062 3063 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
3063 3064 } else {
3064 3065 returnValue = *((bool*)args[0]);
3065 3066 }
3066 3067 }
3067 3068 }
3068 3069 if (result) { Py_DECREF(result); }
3069 3070 Py_DECREF(obj);
3070 3071 return returnValue;
3071 3072 }
3072 3073 }
3073 3074 return QHexSpinBox::nativeEvent(eventType, message, result);
3074 3075 }
3075 3076 QPaintEngine* PythonQtShell_QHexSpinBox::paintEngine() const
3076 3077 {
3077 3078 if (_wrapper) {
3078 3079 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
3079 3080 PyErr_Clear();
3080 3081 if (obj && !PythonQtSlotFunction_Check(obj)) {
3081 3082 static const char* argumentList[] ={"QPaintEngine*"};
3082 3083 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3083 3084 QPaintEngine* returnValue;
3084 3085 void* args[1] = {NULL};
3085 3086 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3086 3087 if (result) {
3087 3088 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3088 3089 if (args[0]!=&returnValue) {
3089 3090 if (args[0]==NULL) {
3090 3091 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
3091 3092 } else {
3092 3093 returnValue = *((QPaintEngine**)args[0]);
3093 3094 }
3094 3095 }
3095 3096 }
3096 3097 if (result) { Py_DECREF(result); }
3097 3098 Py_DECREF(obj);
3098 3099 return returnValue;
3099 3100 }
3100 3101 }
3101 3102 return QHexSpinBox::paintEngine();
3102 3103 }
3103 3104 void PythonQtShell_QHexSpinBox::paintEvent(QPaintEvent* event)
3104 3105 {
3105 3106 if (_wrapper) {
3106 3107 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
3107 3108 PyErr_Clear();
3108 3109 if (obj && !PythonQtSlotFunction_Check(obj)) {
3109 3110 static const char* argumentList[] ={"" , "QPaintEvent*"};
3110 3111 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3111 3112 void* args[2] = {NULL, (void*)&event};
3112 3113 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3113 3114 if (result) { Py_DECREF(result); }
3114 3115 Py_DECREF(obj);
3115 3116 return;
3116 3117 }
3117 3118 }
3118 3119 QHexSpinBox::paintEvent(event);
3119 3120 }
3120 3121 QPaintDevice* PythonQtShell_QHexSpinBox::redirected(QPoint* offset) const
3121 3122 {
3122 3123 if (_wrapper) {
3123 3124 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
3124 3125 PyErr_Clear();
3125 3126 if (obj && !PythonQtSlotFunction_Check(obj)) {
3126 3127 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
3127 3128 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3128 3129 QPaintDevice* returnValue;
3129 3130 void* args[2] = {NULL, (void*)&offset};
3130 3131 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3131 3132 if (result) {
3132 3133 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3133 3134 if (args[0]!=&returnValue) {
3134 3135 if (args[0]==NULL) {
3135 3136 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
3136 3137 } else {
3137 3138 returnValue = *((QPaintDevice**)args[0]);
3138 3139 }
3139 3140 }
3140 3141 }
3141 3142 if (result) { Py_DECREF(result); }
3142 3143 Py_DECREF(obj);
3143 3144 return returnValue;
3144 3145 }
3145 3146 }
3146 3147 return QHexSpinBox::redirected(offset);
3147 3148 }
3148 3149 void PythonQtShell_QHexSpinBox::resizeEvent(QResizeEvent* event)
3149 3150 {
3150 3151 if (_wrapper) {
3151 3152 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
3152 3153 PyErr_Clear();
3153 3154 if (obj && !PythonQtSlotFunction_Check(obj)) {
3154 3155 static const char* argumentList[] ={"" , "QResizeEvent*"};
3155 3156 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3156 3157 void* args[2] = {NULL, (void*)&event};
3157 3158 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3158 3159 if (result) { Py_DECREF(result); }
3159 3160 Py_DECREF(obj);
3160 3161 return;
3161 3162 }
3162 3163 }
3163 3164 QHexSpinBox::resizeEvent(event);
3164 3165 }
3165 3166 QPainter* PythonQtShell_QHexSpinBox::sharedPainter() const
3166 3167 {
3167 3168 if (_wrapper) {
3168 3169 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
3169 3170 PyErr_Clear();
3170 3171 if (obj && !PythonQtSlotFunction_Check(obj)) {
3171 3172 static const char* argumentList[] ={"QPainter*"};
3172 3173 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3173 3174 QPainter* returnValue;
3174 3175 void* args[1] = {NULL};
3175 3176 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3176 3177 if (result) {
3177 3178 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3178 3179 if (args[0]!=&returnValue) {
3179 3180 if (args[0]==NULL) {
3180 3181 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
3181 3182 } else {
3182 3183 returnValue = *((QPainter**)args[0]);
3183 3184 }
3184 3185 }
3185 3186 }
3186 3187 if (result) { Py_DECREF(result); }
3187 3188 Py_DECREF(obj);
3188 3189 return returnValue;
3189 3190 }
3190 3191 }
3191 3192 return QHexSpinBox::sharedPainter();
3192 3193 }
3193 3194 void PythonQtShell_QHexSpinBox::showEvent(QShowEvent* event)
3194 3195 {
3195 3196 if (_wrapper) {
3196 3197 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
3197 3198 PyErr_Clear();
3198 3199 if (obj && !PythonQtSlotFunction_Check(obj)) {
3199 3200 static const char* argumentList[] ={"" , "QShowEvent*"};
3200 3201 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3201 3202 void* args[2] = {NULL, (void*)&event};
3202 3203 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3203 3204 if (result) { Py_DECREF(result); }
3204 3205 Py_DECREF(obj);
3205 3206 return;
3206 3207 }
3207 3208 }
3208 3209 QHexSpinBox::showEvent(event);
3209 3210 }
3210 3211 void PythonQtShell_QHexSpinBox::stepBy(int steps)
3211 3212 {
3212 3213 if (_wrapper) {
3213 3214 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepBy");
3214 3215 PyErr_Clear();
3215 3216 if (obj && !PythonQtSlotFunction_Check(obj)) {
3216 3217 static const char* argumentList[] ={"" , "int"};
3217 3218 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3218 3219 void* args[2] = {NULL, (void*)&steps};
3219 3220 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3220 3221 if (result) { Py_DECREF(result); }
3221 3222 Py_DECREF(obj);
3222 3223 return;
3223 3224 }
3224 3225 }
3225 3226 QHexSpinBox::stepBy(steps);
3226 3227 }
3227 3228 QAbstractSpinBox::StepEnabled PythonQtShell_QHexSpinBox::stepEnabled() const
3228 3229 {
3229 3230 if (_wrapper) {
3230 3231 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepEnabled");
3231 3232 PyErr_Clear();
3232 3233 if (obj && !PythonQtSlotFunction_Check(obj)) {
3233 3234 static const char* argumentList[] ={"QAbstractSpinBox::StepEnabled"};
3234 3235 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3235 3236 QAbstractSpinBox::StepEnabled returnValue;
3236 3237 void* args[1] = {NULL};
3237 3238 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3238 3239 if (result) {
3239 3240 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3240 3241 if (args[0]!=&returnValue) {
3241 3242 if (args[0]==NULL) {
3242 3243 PythonQt::priv()->handleVirtualOverloadReturnError("stepEnabled", methodInfo, result);
3243 3244 } else {
3244 3245 returnValue = *((QAbstractSpinBox::StepEnabled*)args[0]);
3245 3246 }
3246 3247 }
3247 3248 }
3248 3249 if (result) { Py_DECREF(result); }
3249 3250 Py_DECREF(obj);
3250 3251 return returnValue;
3251 3252 }
3252 3253 }
3253 3254 return QHexSpinBox::stepEnabled();
3254 3255 }
3255 3256 void PythonQtShell_QHexSpinBox::tabletEvent(QTabletEvent* arg__1)
3256 3257 {
3257 3258 if (_wrapper) {
3258 3259 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
3259 3260 PyErr_Clear();
3260 3261 if (obj && !PythonQtSlotFunction_Check(obj)) {
3261 3262 static const char* argumentList[] ={"" , "QTabletEvent*"};
3262 3263 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3263 3264 void* args[2] = {NULL, (void*)&arg__1};
3264 3265 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3265 3266 if (result) { Py_DECREF(result); }
3266 3267 Py_DECREF(obj);
3267 3268 return;
3268 3269 }
3269 3270 }
3270 3271 QHexSpinBox::tabletEvent(arg__1);
3271 3272 }
3272 3273 QString PythonQtShell_QHexSpinBox::textFromValue(int value) const
3273 3274 {
3274 3275 if (_wrapper) {
3275 3276 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "textFromValue");
3276 3277 PyErr_Clear();
3277 3278 if (obj && !PythonQtSlotFunction_Check(obj)) {
3278 3279 static const char* argumentList[] ={"QString" , "int"};
3279 3280 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3280 3281 QString returnValue;
3281 3282 void* args[2] = {NULL, (void*)&value};
3282 3283 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3283 3284 if (result) {
3284 3285 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3285 3286 if (args[0]!=&returnValue) {
3286 3287 if (args[0]==NULL) {
3287 3288 PythonQt::priv()->handleVirtualOverloadReturnError("textFromValue", methodInfo, result);
3288 3289 } else {
3289 3290 returnValue = *((QString*)args[0]);
3290 3291 }
3291 3292 }
3292 3293 }
3293 3294 if (result) { Py_DECREF(result); }
3294 3295 Py_DECREF(obj);
3295 3296 return returnValue;
3296 3297 }
3297 3298 }
3298 3299 return QHexSpinBox::textFromValue(value);
3299 3300 }
3300 3301 void PythonQtShell_QHexSpinBox::timerEvent(QTimerEvent* event)
3301 3302 {
3302 3303 if (_wrapper) {
3303 3304 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
3304 3305 PyErr_Clear();
3305 3306 if (obj && !PythonQtSlotFunction_Check(obj)) {
3306 3307 static const char* argumentList[] ={"" , "QTimerEvent*"};
3307 3308 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3308 3309 void* args[2] = {NULL, (void*)&event};
3309 3310 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3310 3311 if (result) { Py_DECREF(result); }
3311 3312 Py_DECREF(obj);
3312 3313 return;
3313 3314 }
3314 3315 }
3315 3316 QHexSpinBox::timerEvent(event);
3316 3317 }
3317 3318 QValidator::State PythonQtShell_QHexSpinBox::validate(QString& input, int& pos) const
3318 3319 {
3319 3320 if (_wrapper) {
3320 3321 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "validate");
3321 3322 PyErr_Clear();
3322 3323 if (obj && !PythonQtSlotFunction_Check(obj)) {
3323 3324 static const char* argumentList[] ={"QValidator::State" , "QString&" , "int&"};
3324 3325 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3325 3326 QValidator::State returnValue;
3326 3327 void* args[3] = {NULL, (void*)&input, (void*)&pos};
3327 3328 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3328 3329 if (result) {
3329 3330 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3330 3331 if (args[0]!=&returnValue) {
3331 3332 if (args[0]==NULL) {
3332 3333 PythonQt::priv()->handleVirtualOverloadReturnError("validate", methodInfo, result);
3333 3334 } else {
3334 3335 returnValue = *((QValidator::State*)args[0]);
3335 3336 }
3336 3337 }
3337 3338 }
3338 3339 if (result) { Py_DECREF(result); }
3339 3340 Py_DECREF(obj);
3340 3341 return returnValue;
3341 3342 }
3342 3343 }
3343 3344 return QHexSpinBox::validate(input, pos);
3344 3345 }
3345 3346 int PythonQtShell_QHexSpinBox::valueFromText(const QString& text) const
3346 3347 {
3347 3348 if (_wrapper) {
3348 3349 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "valueFromText");
3349 3350 PyErr_Clear();
3350 3351 if (obj && !PythonQtSlotFunction_Check(obj)) {
3351 3352 static const char* argumentList[] ={"int" , "const QString&"};
3352 3353 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3353 3354 int returnValue;
3354 3355 void* args[2] = {NULL, (void*)&text};
3355 3356 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3356 3357 if (result) {
3357 3358 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3358 3359 if (args[0]!=&returnValue) {
3359 3360 if (args[0]==NULL) {
3360 3361 PythonQt::priv()->handleVirtualOverloadReturnError("valueFromText", methodInfo, result);
3361 3362 } else {
3362 3363 returnValue = *((int*)args[0]);
3363 3364 }
3364 3365 }
3365 3366 }
3366 3367 if (result) { Py_DECREF(result); }
3367 3368 Py_DECREF(obj);
3368 3369 return returnValue;
3369 3370 }
3370 3371 }
3371 3372 return QHexSpinBox::valueFromText(text);
3372 3373 }
3373 3374 void PythonQtShell_QHexSpinBox::wheelEvent(QWheelEvent* event)
3374 3375 {
3375 3376 if (_wrapper) {
3376 3377 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
3377 3378 PyErr_Clear();
3378 3379 if (obj && !PythonQtSlotFunction_Check(obj)) {
3379 3380 static const char* argumentList[] ={"" , "QWheelEvent*"};
3380 3381 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3381 3382 void* args[2] = {NULL, (void*)&event};
3382 3383 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3383 3384 if (result) { Py_DECREF(result); }
3384 3385 Py_DECREF(obj);
3385 3386 return;
3386 3387 }
3387 3388 }
3388 3389 QHexSpinBox::wheelEvent(event);
3389 3390 }
3390 3391 QHexSpinBox* PythonQtWrapper_QHexSpinBox::new_QHexSpinBox(QWidget* parent)
3391 3392 {
3392 3393 return new PythonQtShell_QHexSpinBox(parent); }
3393 3394
3394 3395 void PythonQtWrapper_QHexSpinBox::show(QHexSpinBox* theWrappedObject)
3395 3396 {
3396 3397 ( theWrappedObject->show());
3397 3398 }
3398 3399
3399 3400 QString PythonQtWrapper_QHexSpinBox::textFromValue(QHexSpinBox* theWrappedObject, int value) const
3400 3401 {
3401 3402 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_textFromValue(value));
3402 3403 }
3403 3404
3404 3405 QValidator::State PythonQtWrapper_QHexSpinBox::validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const
3405 3406 {
3406 3407 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_validate(input, pos));
3407 3408 }
3408 3409
3409 3410 int PythonQtWrapper_QHexSpinBox::valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const
3410 3411 {
3411 3412 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_valueFromText(text));
3412 3413 }
3413 3414
3414 3415
3415 3416
3416 3417 PythonQtShell_SocExplorerPlot::~PythonQtShell_SocExplorerPlot() {
3417 3418 PythonQtPrivate* priv = PythonQt::priv();
3418 3419 if (priv) { priv->shellClassDeleted(this); }
3419 3420 }
3420 3421 void PythonQtShell_SocExplorerPlot::actionEvent(QActionEvent* arg__1)
3421 3422 {
3422 3423 if (_wrapper) {
3423 3424 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
3424 3425 PyErr_Clear();
3425 3426 if (obj && !PythonQtSlotFunction_Check(obj)) {
3426 3427 static const char* argumentList[] ={"" , "QActionEvent*"};
3427 3428 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3428 3429 void* args[2] = {NULL, (void*)&arg__1};
3429 3430 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3430 3431 if (result) { Py_DECREF(result); }
3431 3432 Py_DECREF(obj);
3432 3433 return;
3433 3434 }
3434 3435 }
3435 3436 SocExplorerPlot::actionEvent(arg__1);
3436 3437 }
3437 3438 void PythonQtShell_SocExplorerPlot::changeEvent(QEvent* arg__1)
3438 3439 {
3439 3440 if (_wrapper) {
3440 3441 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
3441 3442 PyErr_Clear();
3442 3443 if (obj && !PythonQtSlotFunction_Check(obj)) {
3443 3444 static const char* argumentList[] ={"" , "QEvent*"};
3444 3445 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3445 3446 void* args[2] = {NULL, (void*)&arg__1};
3446 3447 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3447 3448 if (result) { Py_DECREF(result); }
3448 3449 Py_DECREF(obj);
3449 3450 return;
3450 3451 }
3451 3452 }
3452 3453 SocExplorerPlot::changeEvent(arg__1);
3453 3454 }
3454 3455 void PythonQtShell_SocExplorerPlot::childEvent(QChildEvent* arg__1)
3455 3456 {
3456 3457 if (_wrapper) {
3457 3458 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
3458 3459 PyErr_Clear();
3459 3460 if (obj && !PythonQtSlotFunction_Check(obj)) {
3460 3461 static const char* argumentList[] ={"" , "QChildEvent*"};
3461 3462 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3462 3463 void* args[2] = {NULL, (void*)&arg__1};
3463 3464 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3464 3465 if (result) { Py_DECREF(result); }
3465 3466 Py_DECREF(obj);
3466 3467 return;
3467 3468 }
3468 3469 }
3469 3470 SocExplorerPlot::childEvent(arg__1);
3470 3471 }
3471 3472 void PythonQtShell_SocExplorerPlot::closeEvent(QCloseEvent* arg__1)
3472 3473 {
3473 3474 if (_wrapper) {
3474 3475 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
3475 3476 PyErr_Clear();
3476 3477 if (obj && !PythonQtSlotFunction_Check(obj)) {
3477 3478 static const char* argumentList[] ={"" , "QCloseEvent*"};
3478 3479 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3479 3480 void* args[2] = {NULL, (void*)&arg__1};
3480 3481 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3481 3482 if (result) { Py_DECREF(result); }
3482 3483 Py_DECREF(obj);
3483 3484 return;
3484 3485 }
3485 3486 }
3486 3487 SocExplorerPlot::closeEvent(arg__1);
3487 3488 }
3488 3489 void PythonQtShell_SocExplorerPlot::contextMenuEvent(QContextMenuEvent* arg__1)
3489 3490 {
3490 3491 if (_wrapper) {
3491 3492 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
3492 3493 PyErr_Clear();
3493 3494 if (obj && !PythonQtSlotFunction_Check(obj)) {
3494 3495 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
3495 3496 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3496 3497 void* args[2] = {NULL, (void*)&arg__1};
3497 3498 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3498 3499 if (result) { Py_DECREF(result); }
3499 3500 Py_DECREF(obj);
3500 3501 return;
3501 3502 }
3502 3503 }
3503 3504 SocExplorerPlot::contextMenuEvent(arg__1);
3504 3505 }
3505 3506 void PythonQtShell_SocExplorerPlot::customEvent(QEvent* arg__1)
3506 3507 {
3507 3508 if (_wrapper) {
3508 3509 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
3509 3510 PyErr_Clear();
3510 3511 if (obj && !PythonQtSlotFunction_Check(obj)) {
3511 3512 static const char* argumentList[] ={"" , "QEvent*"};
3512 3513 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3513 3514 void* args[2] = {NULL, (void*)&arg__1};
3514 3515 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3515 3516 if (result) { Py_DECREF(result); }
3516 3517 Py_DECREF(obj);
3517 3518 return;
3518 3519 }
3519 3520 }
3520 3521 SocExplorerPlot::customEvent(arg__1);
3521 3522 }
3522 3523 int PythonQtShell_SocExplorerPlot::devType() const
3523 3524 {
3524 3525 if (_wrapper) {
3525 3526 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
3526 3527 PyErr_Clear();
3527 3528 if (obj && !PythonQtSlotFunction_Check(obj)) {
3528 3529 static const char* argumentList[] ={"int"};
3529 3530 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3530 3531 int returnValue;
3531 3532 void* args[1] = {NULL};
3532 3533 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3533 3534 if (result) {
3534 3535 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3535 3536 if (args[0]!=&returnValue) {
3536 3537 if (args[0]==NULL) {
3537 3538 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
3538 3539 } else {
3539 3540 returnValue = *((int*)args[0]);
3540 3541 }
3541 3542 }
3542 3543 }
3543 3544 if (result) { Py_DECREF(result); }
3544 3545 Py_DECREF(obj);
3545 3546 return returnValue;
3546 3547 }
3547 3548 }
3548 3549 return SocExplorerPlot::devType();
3549 3550 }
3550 3551 void PythonQtShell_SocExplorerPlot::dragEnterEvent(QDragEnterEvent* arg__1)
3551 3552 {
3552 3553 if (_wrapper) {
3553 3554 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
3554 3555 PyErr_Clear();
3555 3556 if (obj && !PythonQtSlotFunction_Check(obj)) {
3556 3557 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
3557 3558 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3558 3559 void* args[2] = {NULL, (void*)&arg__1};
3559 3560 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3560 3561 if (result) { Py_DECREF(result); }
3561 3562 Py_DECREF(obj);
3562 3563 return;
3563 3564 }
3564 3565 }
3565 3566 SocExplorerPlot::dragEnterEvent(arg__1);
3566 3567 }
3567 3568 void PythonQtShell_SocExplorerPlot::dragLeaveEvent(QDragLeaveEvent* arg__1)
3568 3569 {
3569 3570 if (_wrapper) {
3570 3571 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
3571 3572 PyErr_Clear();
3572 3573 if (obj && !PythonQtSlotFunction_Check(obj)) {
3573 3574 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
3574 3575 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3575 3576 void* args[2] = {NULL, (void*)&arg__1};
3576 3577 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3577 3578 if (result) { Py_DECREF(result); }
3578 3579 Py_DECREF(obj);
3579 3580 return;
3580 3581 }
3581 3582 }
3582 3583 SocExplorerPlot::dragLeaveEvent(arg__1);
3583 3584 }
3584 3585 void PythonQtShell_SocExplorerPlot::dragMoveEvent(QDragMoveEvent* arg__1)
3585 3586 {
3586 3587 if (_wrapper) {
3587 3588 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
3588 3589 PyErr_Clear();
3589 3590 if (obj && !PythonQtSlotFunction_Check(obj)) {
3590 3591 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
3591 3592 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3592 3593 void* args[2] = {NULL, (void*)&arg__1};
3593 3594 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3594 3595 if (result) { Py_DECREF(result); }
3595 3596 Py_DECREF(obj);
3596 3597 return;
3597 3598 }
3598 3599 }
3599 3600 SocExplorerPlot::dragMoveEvent(arg__1);
3600 3601 }
3601 3602 void PythonQtShell_SocExplorerPlot::dropEvent(QDropEvent* arg__1)
3602 3603 {
3603 3604 if (_wrapper) {
3604 3605 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
3605 3606 PyErr_Clear();
3606 3607 if (obj && !PythonQtSlotFunction_Check(obj)) {
3607 3608 static const char* argumentList[] ={"" , "QDropEvent*"};
3608 3609 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3609 3610 void* args[2] = {NULL, (void*)&arg__1};
3610 3611 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3611 3612 if (result) { Py_DECREF(result); }
3612 3613 Py_DECREF(obj);
3613 3614 return;
3614 3615 }
3615 3616 }
3616 3617 SocExplorerPlot::dropEvent(arg__1);
3617 3618 }
3618 3619 void PythonQtShell_SocExplorerPlot::enterEvent(QEvent* arg__1)
3619 3620 {
3620 3621 if (_wrapper) {
3621 3622 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
3622 3623 PyErr_Clear();
3623 3624 if (obj && !PythonQtSlotFunction_Check(obj)) {
3624 3625 static const char* argumentList[] ={"" , "QEvent*"};
3625 3626 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3626 3627 void* args[2] = {NULL, (void*)&arg__1};
3627 3628 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3628 3629 if (result) { Py_DECREF(result); }
3629 3630 Py_DECREF(obj);
3630 3631 return;
3631 3632 }
3632 3633 }
3633 3634 SocExplorerPlot::enterEvent(arg__1);
3634 3635 }
3635 3636 bool PythonQtShell_SocExplorerPlot::event(QEvent* arg__1)
3636 3637 {
3637 3638 if (_wrapper) {
3638 3639 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
3639 3640 PyErr_Clear();
3640 3641 if (obj && !PythonQtSlotFunction_Check(obj)) {
3641 3642 static const char* argumentList[] ={"bool" , "QEvent*"};
3642 3643 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3643 3644 bool returnValue;
3644 3645 void* args[2] = {NULL, (void*)&arg__1};
3645 3646 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3646 3647 if (result) {
3647 3648 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3648 3649 if (args[0]!=&returnValue) {
3649 3650 if (args[0]==NULL) {
3650 3651 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
3651 3652 } else {
3652 3653 returnValue = *((bool*)args[0]);
3653 3654 }
3654 3655 }
3655 3656 }
3656 3657 if (result) { Py_DECREF(result); }
3657 3658 Py_DECREF(obj);
3658 3659 return returnValue;
3659 3660 }
3660 3661 }
3661 3662 return SocExplorerPlot::event(arg__1);
3662 3663 }
3663 3664 bool PythonQtShell_SocExplorerPlot::eventFilter(QObject* arg__1, QEvent* arg__2)
3664 3665 {
3665 3666 if (_wrapper) {
3666 3667 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
3667 3668 PyErr_Clear();
3668 3669 if (obj && !PythonQtSlotFunction_Check(obj)) {
3669 3670 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
3670 3671 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3671 3672 bool returnValue;
3672 3673 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
3673 3674 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3674 3675 if (result) {
3675 3676 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3676 3677 if (args[0]!=&returnValue) {
3677 3678 if (args[0]==NULL) {
3678 3679 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
3679 3680 } else {
3680 3681 returnValue = *((bool*)args[0]);
3681 3682 }
3682 3683 }
3683 3684 }
3684 3685 if (result) { Py_DECREF(result); }
3685 3686 Py_DECREF(obj);
3686 3687 return returnValue;
3687 3688 }
3688 3689 }
3689 3690 return SocExplorerPlot::eventFilter(arg__1, arg__2);
3690 3691 }
3691 3692 void PythonQtShell_SocExplorerPlot::focusInEvent(QFocusEvent* arg__1)
3692 3693 {
3693 3694 if (_wrapper) {
3694 3695 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
3695 3696 PyErr_Clear();
3696 3697 if (obj && !PythonQtSlotFunction_Check(obj)) {
3697 3698 static const char* argumentList[] ={"" , "QFocusEvent*"};
3698 3699 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3699 3700 void* args[2] = {NULL, (void*)&arg__1};
3700 3701 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3701 3702 if (result) { Py_DECREF(result); }
3702 3703 Py_DECREF(obj);
3703 3704 return;
3704 3705 }
3705 3706 }
3706 3707 SocExplorerPlot::focusInEvent(arg__1);
3707 3708 }
3708 3709 bool PythonQtShell_SocExplorerPlot::focusNextPrevChild(bool next)
3709 3710 {
3710 3711 if (_wrapper) {
3711 3712 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
3712 3713 PyErr_Clear();
3713 3714 if (obj && !PythonQtSlotFunction_Check(obj)) {
3714 3715 static const char* argumentList[] ={"bool" , "bool"};
3715 3716 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3716 3717 bool returnValue;
3717 3718 void* args[2] = {NULL, (void*)&next};
3718 3719 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3719 3720 if (result) {
3720 3721 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3721 3722 if (args[0]!=&returnValue) {
3722 3723 if (args[0]==NULL) {
3723 3724 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
3724 3725 } else {
3725 3726 returnValue = *((bool*)args[0]);
3726 3727 }
3727 3728 }
3728 3729 }
3729 3730 if (result) { Py_DECREF(result); }
3730 3731 Py_DECREF(obj);
3731 3732 return returnValue;
3732 3733 }
3733 3734 }
3734 3735 return SocExplorerPlot::focusNextPrevChild(next);
3735 3736 }
3736 3737 void PythonQtShell_SocExplorerPlot::focusOutEvent(QFocusEvent* arg__1)
3737 3738 {
3738 3739 if (_wrapper) {
3739 3740 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
3740 3741 PyErr_Clear();
3741 3742 if (obj && !PythonQtSlotFunction_Check(obj)) {
3742 3743 static const char* argumentList[] ={"" , "QFocusEvent*"};
3743 3744 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3744 3745 void* args[2] = {NULL, (void*)&arg__1};
3745 3746 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3746 3747 if (result) { Py_DECREF(result); }
3747 3748 Py_DECREF(obj);
3748 3749 return;
3749 3750 }
3750 3751 }
3751 3752 SocExplorerPlot::focusOutEvent(arg__1);
3752 3753 }
3753 3754 bool PythonQtShell_SocExplorerPlot::hasHeightForWidth() const
3754 3755 {
3755 3756 if (_wrapper) {
3756 3757 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
3757 3758 PyErr_Clear();
3758 3759 if (obj && !PythonQtSlotFunction_Check(obj)) {
3759 3760 static const char* argumentList[] ={"bool"};
3760 3761 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3761 3762 bool returnValue;
3762 3763 void* args[1] = {NULL};
3763 3764 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3764 3765 if (result) {
3765 3766 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3766 3767 if (args[0]!=&returnValue) {
3767 3768 if (args[0]==NULL) {
3768 3769 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
3769 3770 } else {
3770 3771 returnValue = *((bool*)args[0]);
3771 3772 }
3772 3773 }
3773 3774 }
3774 3775 if (result) { Py_DECREF(result); }
3775 3776 Py_DECREF(obj);
3776 3777 return returnValue;
3777 3778 }
3778 3779 }
3779 3780 return SocExplorerPlot::hasHeightForWidth();
3780 3781 }
3781 3782 int PythonQtShell_SocExplorerPlot::heightForWidth(int arg__1) const
3782 3783 {
3783 3784 if (_wrapper) {
3784 3785 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
3785 3786 PyErr_Clear();
3786 3787 if (obj && !PythonQtSlotFunction_Check(obj)) {
3787 3788 static const char* argumentList[] ={"int" , "int"};
3788 3789 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3789 3790 int returnValue;
3790 3791 void* args[2] = {NULL, (void*)&arg__1};
3791 3792 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3792 3793 if (result) {
3793 3794 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3794 3795 if (args[0]!=&returnValue) {
3795 3796 if (args[0]==NULL) {
3796 3797 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
3797 3798 } else {
3798 3799 returnValue = *((int*)args[0]);
3799 3800 }
3800 3801 }
3801 3802 }
3802 3803 if (result) { Py_DECREF(result); }
3803 3804 Py_DECREF(obj);
3804 3805 return returnValue;
3805 3806 }
3806 3807 }
3807 3808 return SocExplorerPlot::heightForWidth(arg__1);
3808 3809 }
3809 3810 void PythonQtShell_SocExplorerPlot::hideEvent(QHideEvent* arg__1)
3810 3811 {
3811 3812 if (_wrapper) {
3812 3813 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
3813 3814 PyErr_Clear();
3814 3815 if (obj && !PythonQtSlotFunction_Check(obj)) {
3815 3816 static const char* argumentList[] ={"" , "QHideEvent*"};
3816 3817 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3817 3818 void* args[2] = {NULL, (void*)&arg__1};
3818 3819 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3819 3820 if (result) { Py_DECREF(result); }
3820 3821 Py_DECREF(obj);
3821 3822 return;
3822 3823 }
3823 3824 }
3824 3825 SocExplorerPlot::hideEvent(arg__1);
3825 3826 }
3826 3827 void PythonQtShell_SocExplorerPlot::initPainter(QPainter* painter) const
3827 3828 {
3828 3829 if (_wrapper) {
3829 3830 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
3830 3831 PyErr_Clear();
3831 3832 if (obj && !PythonQtSlotFunction_Check(obj)) {
3832 3833 static const char* argumentList[] ={"" , "QPainter*"};
3833 3834 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3834 3835 void* args[2] = {NULL, (void*)&painter};
3835 3836 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3836 3837 if (result) { Py_DECREF(result); }
3837 3838 Py_DECREF(obj);
3838 3839 return;
3839 3840 }
3840 3841 }
3841 3842 SocExplorerPlot::initPainter(painter);
3842 3843 }
3843 3844 void PythonQtShell_SocExplorerPlot::inputMethodEvent(QInputMethodEvent* arg__1)
3844 3845 {
3845 3846 if (_wrapper) {
3846 3847 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
3847 3848 PyErr_Clear();
3848 3849 if (obj && !PythonQtSlotFunction_Check(obj)) {
3849 3850 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
3850 3851 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3851 3852 void* args[2] = {NULL, (void*)&arg__1};
3852 3853 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3853 3854 if (result) { Py_DECREF(result); }
3854 3855 Py_DECREF(obj);
3855 3856 return;
3856 3857 }
3857 3858 }
3858 3859 SocExplorerPlot::inputMethodEvent(arg__1);
3859 3860 }
3860 3861 QVariant PythonQtShell_SocExplorerPlot::inputMethodQuery(Qt::InputMethodQuery arg__1) const
3861 3862 {
3862 3863 if (_wrapper) {
3863 3864 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
3864 3865 PyErr_Clear();
3865 3866 if (obj && !PythonQtSlotFunction_Check(obj)) {
3866 3867 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
3867 3868 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3868 3869 QVariant returnValue;
3869 3870 void* args[2] = {NULL, (void*)&arg__1};
3870 3871 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3871 3872 if (result) {
3872 3873 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3873 3874 if (args[0]!=&returnValue) {
3874 3875 if (args[0]==NULL) {
3875 3876 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
3876 3877 } else {
3877 3878 returnValue = *((QVariant*)args[0]);
3878 3879 }
3879 3880 }
3880 3881 }
3881 3882 if (result) { Py_DECREF(result); }
3882 3883 Py_DECREF(obj);
3883 3884 return returnValue;
3884 3885 }
3885 3886 }
3886 3887 return SocExplorerPlot::inputMethodQuery(arg__1);
3887 3888 }
3888 3889 void PythonQtShell_SocExplorerPlot::keyPressEvent(QKeyEvent* arg__1)
3889 3890 {
3890 3891 if (_wrapper) {
3891 3892 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
3892 3893 PyErr_Clear();
3893 3894 if (obj && !PythonQtSlotFunction_Check(obj)) {
3894 3895 static const char* argumentList[] ={"" , "QKeyEvent*"};
3895 3896 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3896 3897 void* args[2] = {NULL, (void*)&arg__1};
3897 3898 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3898 3899 if (result) { Py_DECREF(result); }
3899 3900 Py_DECREF(obj);
3900 3901 return;
3901 3902 }
3902 3903 }
3903 3904 SocExplorerPlot::keyPressEvent(arg__1);
3904 3905 }
3905 3906 void PythonQtShell_SocExplorerPlot::keyReleaseEvent(QKeyEvent* arg__1)
3906 3907 {
3907 3908 if (_wrapper) {
3908 3909 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
3909 3910 PyErr_Clear();
3910 3911 if (obj && !PythonQtSlotFunction_Check(obj)) {
3911 3912 static const char* argumentList[] ={"" , "QKeyEvent*"};
3912 3913 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3913 3914 void* args[2] = {NULL, (void*)&arg__1};
3914 3915 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3915 3916 if (result) { Py_DECREF(result); }
3916 3917 Py_DECREF(obj);
3917 3918 return;
3918 3919 }
3919 3920 }
3920 3921 SocExplorerPlot::keyReleaseEvent(arg__1);
3921 3922 }
3922 3923 void PythonQtShell_SocExplorerPlot::leaveEvent(QEvent* arg__1)
3923 3924 {
3924 3925 if (_wrapper) {
3925 3926 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
3926 3927 PyErr_Clear();
3927 3928 if (obj && !PythonQtSlotFunction_Check(obj)) {
3928 3929 static const char* argumentList[] ={"" , "QEvent*"};
3929 3930 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3930 3931 void* args[2] = {NULL, (void*)&arg__1};
3931 3932 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3932 3933 if (result) { Py_DECREF(result); }
3933 3934 Py_DECREF(obj);
3934 3935 return;
3935 3936 }
3936 3937 }
3937 3938 SocExplorerPlot::leaveEvent(arg__1);
3938 3939 }
3939 3940 int PythonQtShell_SocExplorerPlot::metric(QPaintDevice::PaintDeviceMetric arg__1) const
3940 3941 {
3941 3942 if (_wrapper) {
3942 3943 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
3943 3944 PyErr_Clear();
3944 3945 if (obj && !PythonQtSlotFunction_Check(obj)) {
3945 3946 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
3946 3947 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3947 3948 int returnValue;
3948 3949 void* args[2] = {NULL, (void*)&arg__1};
3949 3950 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3950 3951 if (result) {
3951 3952 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3952 3953 if (args[0]!=&returnValue) {
3953 3954 if (args[0]==NULL) {
3954 3955 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
3955 3956 } else {
3956 3957 returnValue = *((int*)args[0]);
3957 3958 }
3958 3959 }
3959 3960 }
3960 3961 if (result) { Py_DECREF(result); }
3961 3962 Py_DECREF(obj);
3962 3963 return returnValue;
3963 3964 }
3964 3965 }
3965 3966 return SocExplorerPlot::metric(arg__1);
3966 3967 }
3967 3968 QSize PythonQtShell_SocExplorerPlot::minimumSizeHint() const
3968 3969 {
3969 3970 if (_wrapper) {
3970 3971 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
3971 3972 PyErr_Clear();
3972 3973 if (obj && !PythonQtSlotFunction_Check(obj)) {
3973 3974 static const char* argumentList[] ={"QSize"};
3974 3975 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3975 3976 QSize returnValue;
3976 3977 void* args[1] = {NULL};
3977 3978 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3978 3979 if (result) {
3979 3980 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3980 3981 if (args[0]!=&returnValue) {
3981 3982 if (args[0]==NULL) {
3982 3983 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
3983 3984 } else {
3984 3985 returnValue = *((QSize*)args[0]);
3985 3986 }
3986 3987 }
3987 3988 }
3988 3989 if (result) { Py_DECREF(result); }
3989 3990 Py_DECREF(obj);
3990 3991 return returnValue;
3991 3992 }
3992 3993 }
3993 3994 return SocExplorerPlot::minimumSizeHint();
3994 3995 }
3995 3996 void PythonQtShell_SocExplorerPlot::mouseDoubleClickEvent(QMouseEvent* arg__1)
3996 3997 {
3997 3998 if (_wrapper) {
3998 3999 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
3999 4000 PyErr_Clear();
4000 4001 if (obj && !PythonQtSlotFunction_Check(obj)) {
4001 4002 static const char* argumentList[] ={"" , "QMouseEvent*"};
4002 4003 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4003 4004 void* args[2] = {NULL, (void*)&arg__1};
4004 4005 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4005 4006 if (result) { Py_DECREF(result); }
4006 4007 Py_DECREF(obj);
4007 4008 return;
4008 4009 }
4009 4010 }
4010 4011 SocExplorerPlot::mouseDoubleClickEvent(arg__1);
4011 4012 }
4012 4013 void PythonQtShell_SocExplorerPlot::mouseMoveEvent(QMouseEvent* arg__1)
4013 4014 {
4014 4015 if (_wrapper) {
4015 4016 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
4016 4017 PyErr_Clear();
4017 4018 if (obj && !PythonQtSlotFunction_Check(obj)) {
4018 4019 static const char* argumentList[] ={"" , "QMouseEvent*"};
4019 4020 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4020 4021 void* args[2] = {NULL, (void*)&arg__1};
4021 4022 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4022 4023 if (result) { Py_DECREF(result); }
4023 4024 Py_DECREF(obj);
4024 4025 return;
4025 4026 }
4026 4027 }
4027 4028 SocExplorerPlot::mouseMoveEvent(arg__1);
4028 4029 }
4029 4030 void PythonQtShell_SocExplorerPlot::mousePressEvent(QMouseEvent* arg__1)
4030 4031 {
4031 4032 if (_wrapper) {
4032 4033 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
4033 4034 PyErr_Clear();
4034 4035 if (obj && !PythonQtSlotFunction_Check(obj)) {
4035 4036 static const char* argumentList[] ={"" , "QMouseEvent*"};
4036 4037 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4037 4038 void* args[2] = {NULL, (void*)&arg__1};
4038 4039 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4039 4040 if (result) { Py_DECREF(result); }
4040 4041 Py_DECREF(obj);
4041 4042 return;
4042 4043 }
4043 4044 }
4044 4045 SocExplorerPlot::mousePressEvent(arg__1);
4045 4046 }
4046 4047 void PythonQtShell_SocExplorerPlot::mouseReleaseEvent(QMouseEvent* arg__1)
4047 4048 {
4048 4049 if (_wrapper) {
4049 4050 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
4050 4051 PyErr_Clear();
4051 4052 if (obj && !PythonQtSlotFunction_Check(obj)) {
4052 4053 static const char* argumentList[] ={"" , "QMouseEvent*"};
4053 4054 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4054 4055 void* args[2] = {NULL, (void*)&arg__1};
4055 4056 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4056 4057 if (result) { Py_DECREF(result); }
4057 4058 Py_DECREF(obj);
4058 4059 return;
4059 4060 }
4060 4061 }
4061 4062 SocExplorerPlot::mouseReleaseEvent(arg__1);
4062 4063 }
4063 4064 void PythonQtShell_SocExplorerPlot::moveEvent(QMoveEvent* arg__1)
4064 4065 {
4065 4066 if (_wrapper) {
4066 4067 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
4067 4068 PyErr_Clear();
4068 4069 if (obj && !PythonQtSlotFunction_Check(obj)) {
4069 4070 static const char* argumentList[] ={"" , "QMoveEvent*"};
4070 4071 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4071 4072 void* args[2] = {NULL, (void*)&arg__1};
4072 4073 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4073 4074 if (result) { Py_DECREF(result); }
4074 4075 Py_DECREF(obj);
4075 4076 return;
4076 4077 }
4077 4078 }
4078 4079 SocExplorerPlot::moveEvent(arg__1);
4079 4080 }
4080 4081 bool PythonQtShell_SocExplorerPlot::nativeEvent(const QByteArray& eventType, void* message, long* result)
4081 4082 {
4082 4083 if (_wrapper) {
4083 4084 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
4084 4085 PyErr_Clear();
4085 4086 if (obj && !PythonQtSlotFunction_Check(obj)) {
4086 4087 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
4087 4088 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
4088 4089 bool returnValue;
4089 4090 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
4090 4091 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4091 4092 if (result) {
4092 4093 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4093 4094 if (args[0]!=&returnValue) {
4094 4095 if (args[0]==NULL) {
4095 4096 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
4096 4097 } else {
4097 4098 returnValue = *((bool*)args[0]);
4098 4099 }
4099 4100 }
4100 4101 }
4101 4102 if (result) { Py_DECREF(result); }
4102 4103 Py_DECREF(obj);
4103 4104 return returnValue;
4104 4105 }
4105 4106 }
4106 4107 return SocExplorerPlot::nativeEvent(eventType, message, result);
4107 4108 }
4108 4109 QPaintEngine* PythonQtShell_SocExplorerPlot::paintEngine() const
4109 4110 {
4110 4111 if (_wrapper) {
4111 4112 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
4112 4113 PyErr_Clear();
4113 4114 if (obj && !PythonQtSlotFunction_Check(obj)) {
4114 4115 static const char* argumentList[] ={"QPaintEngine*"};
4115 4116 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4116 4117 QPaintEngine* returnValue;
4117 4118 void* args[1] = {NULL};
4118 4119 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4119 4120 if (result) {
4120 4121 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4121 4122 if (args[0]!=&returnValue) {
4122 4123 if (args[0]==NULL) {
4123 4124 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
4124 4125 } else {
4125 4126 returnValue = *((QPaintEngine**)args[0]);
4126 4127 }
4127 4128 }
4128 4129 }
4129 4130 if (result) { Py_DECREF(result); }
4130 4131 Py_DECREF(obj);
4131 4132 return returnValue;
4132 4133 }
4133 4134 }
4134 4135 return SocExplorerPlot::paintEngine();
4135 4136 }
4136 4137 void PythonQtShell_SocExplorerPlot::paintEvent(QPaintEvent* arg__1)
4137 4138 {
4138 4139 if (_wrapper) {
4139 4140 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
4140 4141 PyErr_Clear();
4141 4142 if (obj && !PythonQtSlotFunction_Check(obj)) {
4142 4143 static const char* argumentList[] ={"" , "QPaintEvent*"};
4143 4144 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4144 4145 void* args[2] = {NULL, (void*)&arg__1};
4145 4146 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4146 4147 if (result) { Py_DECREF(result); }
4147 4148 Py_DECREF(obj);
4148 4149 return;
4149 4150 }
4150 4151 }
4151 4152 SocExplorerPlot::paintEvent(arg__1);
4152 4153 }
4153 4154 QPaintDevice* PythonQtShell_SocExplorerPlot::redirected(QPoint* offset) const
4154 4155 {
4155 4156 if (_wrapper) {
4156 4157 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
4157 4158 PyErr_Clear();
4158 4159 if (obj && !PythonQtSlotFunction_Check(obj)) {
4159 4160 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
4160 4161 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4161 4162 QPaintDevice* returnValue;
4162 4163 void* args[2] = {NULL, (void*)&offset};
4163 4164 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4164 4165 if (result) {
4165 4166 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4166 4167 if (args[0]!=&returnValue) {
4167 4168 if (args[0]==NULL) {
4168 4169 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
4169 4170 } else {
4170 4171 returnValue = *((QPaintDevice**)args[0]);
4171 4172 }
4172 4173 }
4173 4174 }
4174 4175 if (result) { Py_DECREF(result); }
4175 4176 Py_DECREF(obj);
4176 4177 return returnValue;
4177 4178 }
4178 4179 }
4179 4180 return SocExplorerPlot::redirected(offset);
4180 4181 }
4181 4182 void PythonQtShell_SocExplorerPlot::resizeEvent(QResizeEvent* arg__1)
4182 4183 {
4183 4184 if (_wrapper) {
4184 4185 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
4185 4186 PyErr_Clear();
4186 4187 if (obj && !PythonQtSlotFunction_Check(obj)) {
4187 4188 static const char* argumentList[] ={"" , "QResizeEvent*"};
4188 4189 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4189 4190 void* args[2] = {NULL, (void*)&arg__1};
4190 4191 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4191 4192 if (result) { Py_DECREF(result); }
4192 4193 Py_DECREF(obj);
4193 4194 return;
4194 4195 }
4195 4196 }
4196 4197 SocExplorerPlot::resizeEvent(arg__1);
4197 4198 }
4198 4199 QPainter* PythonQtShell_SocExplorerPlot::sharedPainter() const
4199 4200 {
4200 4201 if (_wrapper) {
4201 4202 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
4202 4203 PyErr_Clear();
4203 4204 if (obj && !PythonQtSlotFunction_Check(obj)) {
4204 4205 static const char* argumentList[] ={"QPainter*"};
4205 4206 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4206 4207 QPainter* returnValue;
4207 4208 void* args[1] = {NULL};
4208 4209 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4209 4210 if (result) {
4210 4211 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4211 4212 if (args[0]!=&returnValue) {
4212 4213 if (args[0]==NULL) {
4213 4214 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
4214 4215 } else {
4215 4216 returnValue = *((QPainter**)args[0]);
4216 4217 }
4217 4218 }
4218 4219 }
4219 4220 if (result) { Py_DECREF(result); }
4220 4221 Py_DECREF(obj);
4221 4222 return returnValue;
4222 4223 }
4223 4224 }
4224 4225 return SocExplorerPlot::sharedPainter();
4225 4226 }
4226 4227 void PythonQtShell_SocExplorerPlot::showEvent(QShowEvent* arg__1)
4227 4228 {
4228 4229 if (_wrapper) {
4229 4230 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
4230 4231 PyErr_Clear();
4231 4232 if (obj && !PythonQtSlotFunction_Check(obj)) {
4232 4233 static const char* argumentList[] ={"" , "QShowEvent*"};
4233 4234 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4234 4235 void* args[2] = {NULL, (void*)&arg__1};
4235 4236 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4236 4237 if (result) { Py_DECREF(result); }
4237 4238 Py_DECREF(obj);
4238 4239 return;
4239 4240 }
4240 4241 }
4241 4242 SocExplorerPlot::showEvent(arg__1);
4242 4243 }
4243 4244 QSize PythonQtShell_SocExplorerPlot::sizeHint() const
4244 4245 {
4245 4246 if (_wrapper) {
4246 4247 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
4247 4248 PyErr_Clear();
4248 4249 if (obj && !PythonQtSlotFunction_Check(obj)) {
4249 4250 static const char* argumentList[] ={"QSize"};
4250 4251 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4251 4252 QSize returnValue;
4252 4253 void* args[1] = {NULL};
4253 4254 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4254 4255 if (result) {
4255 4256 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4256 4257 if (args[0]!=&returnValue) {
4257 4258 if (args[0]==NULL) {
4258 4259 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
4259 4260 } else {
4260 4261 returnValue = *((QSize*)args[0]);
4261 4262 }
4262 4263 }
4263 4264 }
4264 4265 if (result) { Py_DECREF(result); }
4265 4266 Py_DECREF(obj);
4266 4267 return returnValue;
4267 4268 }
4268 4269 }
4269 4270 return SocExplorerPlot::sizeHint();
4270 4271 }
4271 4272 void PythonQtShell_SocExplorerPlot::tabletEvent(QTabletEvent* arg__1)
4272 4273 {
4273 4274 if (_wrapper) {
4274 4275 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
4275 4276 PyErr_Clear();
4276 4277 if (obj && !PythonQtSlotFunction_Check(obj)) {
4277 4278 static const char* argumentList[] ={"" , "QTabletEvent*"};
4278 4279 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4279 4280 void* args[2] = {NULL, (void*)&arg__1};
4280 4281 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4281 4282 if (result) { Py_DECREF(result); }
4282 4283 Py_DECREF(obj);
4283 4284 return;
4284 4285 }
4285 4286 }
4286 4287 SocExplorerPlot::tabletEvent(arg__1);
4287 4288 }
4288 4289 void PythonQtShell_SocExplorerPlot::timerEvent(QTimerEvent* arg__1)
4289 4290 {
4290 4291 if (_wrapper) {
4291 4292 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
4292 4293 PyErr_Clear();
4293 4294 if (obj && !PythonQtSlotFunction_Check(obj)) {
4294 4295 static const char* argumentList[] ={"" , "QTimerEvent*"};
4295 4296 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4296 4297 void* args[2] = {NULL, (void*)&arg__1};
4297 4298 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4298 4299 if (result) { Py_DECREF(result); }
4299 4300 Py_DECREF(obj);
4300 4301 return;
4301 4302 }
4302 4303 }
4303 4304 SocExplorerPlot::timerEvent(arg__1);
4304 4305 }
4305 4306 void PythonQtShell_SocExplorerPlot::wheelEvent(QWheelEvent* arg__1)
4306 4307 {
4307 4308 if (_wrapper) {
4308 4309 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
4309 4310 PyErr_Clear();
4310 4311 if (obj && !PythonQtSlotFunction_Check(obj)) {
4311 4312 static const char* argumentList[] ={"" , "QWheelEvent*"};
4312 4313 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4313 4314 void* args[2] = {NULL, (void*)&arg__1};
4314 4315 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4315 4316 if (result) { Py_DECREF(result); }
4316 4317 Py_DECREF(obj);
4317 4318 return;
4318 4319 }
4319 4320 }
4320 4321 SocExplorerPlot::wheelEvent(arg__1);
4321 4322 }
4322 4323 SocExplorerPlot* PythonQtWrapper_SocExplorerPlot::new_SocExplorerPlot(QWidget* parent)
4323 4324 {
4324 4325 return new PythonQtShell_SocExplorerPlot(parent); }
4325 4326
4326 4327 int PythonQtWrapper_SocExplorerPlot::addGraph(SocExplorerPlot* theWrappedObject)
4327 4328 {
4328 4329 return ( theWrappedObject->addGraph());
4329 4330 }
4330 4331
4331 4332 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4332 4333 {
4333 4334 ( theWrappedObject->addGraphData(graphIndex, x, y));
4334 4335 }
4335 4336
4336 4337 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y)
4337 4338 {
4338 4339 ( theWrappedObject->addGraphData(graphIndex, x, y));
4339 4340 }
4340 4341
4341 4342 QPen PythonQtWrapper_SocExplorerPlot::getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex)
4342 4343 {
4343 4344 return ( theWrappedObject->getGraphPen(graphIndex));
4344 4345 }
4345 4346
4346 4347 void PythonQtWrapper_SocExplorerPlot::keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4347 4348 {
4348 4349 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyPressEvent(arg__1));
4349 4350 }
4350 4351
4351 4352 void PythonQtWrapper_SocExplorerPlot::keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4352 4353 {
4353 4354 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyReleaseEvent(arg__1));
4354 4355 }
4355 4356
4356 4357 void PythonQtWrapper_SocExplorerPlot::mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4357 4358 {
4358 4359 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseMoveEvent(arg__1));
4359 4360 }
4360 4361
4361 4362 void PythonQtWrapper_SocExplorerPlot::mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4362 4363 {
4363 4364 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mousePressEvent(arg__1));
4364 4365 }
4365 4366
4366 4367 void PythonQtWrapper_SocExplorerPlot::mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4367 4368 {
4368 4369 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseReleaseEvent(arg__1));
4369 4370 }
4370 4371
4371 4372 void PythonQtWrapper_SocExplorerPlot::rescaleAxis(SocExplorerPlot* theWrappedObject)
4372 4373 {
4373 4374 ( theWrappedObject->rescaleAxis());
4374 4375 }
4375 4376
4376 4377 void PythonQtWrapper_SocExplorerPlot::setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable)
4377 4378 {
4378 4379 ( theWrappedObject->setAdaptativeSampling(graphIndex, enable));
4379 4380 }
4380 4381
4381 4382 void PythonQtWrapper_SocExplorerPlot::setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4382 4383 {
4383 4384 ( theWrappedObject->setGraphData(graphIndex, x, y));
4384 4385 }
4385 4386
4386 4387 void PythonQtWrapper_SocExplorerPlot::setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle)
4387 4388 {
4388 4389 ( theWrappedObject->setGraphLineStyle(graphIndex, lineStyle));
4389 4390 }
4390 4391
4391 4392 void PythonQtWrapper_SocExplorerPlot::setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name)
4392 4393 {
4393 4394 ( theWrappedObject->setGraphName(graphIndex, name));
4394 4395 }
4395 4396
4396 4397 void PythonQtWrapper_SocExplorerPlot::setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen)
4397 4398 {
4398 4399 ( theWrappedObject->setGraphPen(graphIndex, pen));
4399 4400 }
4400 4401
4401 4402 void PythonQtWrapper_SocExplorerPlot::setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle)
4402 4403 {
4403 4404 ( theWrappedObject->setGraphScatterStyle(graphIndex, scatterStyle));
4404 4405 }
4405 4406
4406 4407 void PythonQtWrapper_SocExplorerPlot::setLegendFont(SocExplorerPlot* theWrappedObject, QFont font)
4407 4408 {
4408 4409 ( theWrappedObject->setLegendFont(font));
4409 4410 }
4410 4411
4411 4412 void PythonQtWrapper_SocExplorerPlot::setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font)
4412 4413 {
4413 4414 ( theWrappedObject->setLegendSelectedFont(font));
4414 4415 }
4415 4416
4416 4417 void PythonQtWrapper_SocExplorerPlot::setTitle(SocExplorerPlot* theWrappedObject, QString title)
4417 4418 {
4418 4419 ( theWrappedObject->setTitle(title));
4419 4420 }
4420 4421
4421 4422 void PythonQtWrapper_SocExplorerPlot::setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4422 4423 {
4423 4424 ( theWrappedObject->setXaxisLabel(label));
4424 4425 }
4425 4426
4426 4427 void PythonQtWrapper_SocExplorerPlot::setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4427 4428 {
4428 4429 ( theWrappedObject->setXaxisRange(lower, upper));
4429 4430 }
4430 4431
4431 4432 void PythonQtWrapper_SocExplorerPlot::setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4432 4433 {
4433 4434 ( theWrappedObject->setYaxisLabel(label));
4434 4435 }
4435 4436
4436 4437 void PythonQtWrapper_SocExplorerPlot::setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4437 4438 {
4438 4439 ( theWrappedObject->setYaxisRange(lower, upper));
4439 4440 }
4440 4441
4441 4442 void PythonQtWrapper_SocExplorerPlot::show(SocExplorerPlot* theWrappedObject)
4442 4443 {
4443 4444 ( theWrappedObject->show());
4444 4445 }
4445 4446
4446 4447 void PythonQtWrapper_SocExplorerPlot::wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1)
4447 4448 {
4448 4449 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_wheelEvent(arg__1));
4449 4450 }
4450 4451
4451 4452
4452 4453
4453 4454 PythonQtShell_TCP_Terminal_Client::~PythonQtShell_TCP_Terminal_Client() {
4454 4455 PythonQtPrivate* priv = PythonQt::priv();
4455 4456 if (priv) { priv->shellClassDeleted(this); }
4456 4457 }
4457 4458 void PythonQtShell_TCP_Terminal_Client::childEvent(QChildEvent* arg__1)
4458 4459 {
4459 4460 if (_wrapper) {
4460 4461 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
4461 4462 PyErr_Clear();
4462 4463 if (obj && !PythonQtSlotFunction_Check(obj)) {
4463 4464 static const char* argumentList[] ={"" , "QChildEvent*"};
4464 4465 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4465 4466 void* args[2] = {NULL, (void*)&arg__1};
4466 4467 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4467 4468 if (result) { Py_DECREF(result); }
4468 4469 Py_DECREF(obj);
4469 4470 return;
4470 4471 }
4471 4472 }
4472 4473 TCP_Terminal_Client::childEvent(arg__1);
4473 4474 }
4474 4475 void PythonQtShell_TCP_Terminal_Client::customEvent(QEvent* arg__1)
4475 4476 {
4476 4477 if (_wrapper) {
4477 4478 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
4478 4479 PyErr_Clear();
4479 4480 if (obj && !PythonQtSlotFunction_Check(obj)) {
4480 4481 static const char* argumentList[] ={"" , "QEvent*"};
4481 4482 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4482 4483 void* args[2] = {NULL, (void*)&arg__1};
4483 4484 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4484 4485 if (result) { Py_DECREF(result); }
4485 4486 Py_DECREF(obj);
4486 4487 return;
4487 4488 }
4488 4489 }
4489 4490 TCP_Terminal_Client::customEvent(arg__1);
4490 4491 }
4491 4492 bool PythonQtShell_TCP_Terminal_Client::event(QEvent* arg__1)
4492 4493 {
4493 4494 if (_wrapper) {
4494 4495 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
4495 4496 PyErr_Clear();
4496 4497 if (obj && !PythonQtSlotFunction_Check(obj)) {
4497 4498 static const char* argumentList[] ={"bool" , "QEvent*"};
4498 4499 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4499 4500 bool returnValue;
4500 4501 void* args[2] = {NULL, (void*)&arg__1};
4501 4502 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4502 4503 if (result) {
4503 4504 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4504 4505 if (args[0]!=&returnValue) {
4505 4506 if (args[0]==NULL) {
4506 4507 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
4507 4508 } else {
4508 4509 returnValue = *((bool*)args[0]);
4509 4510 }
4510 4511 }
4511 4512 }
4512 4513 if (result) { Py_DECREF(result); }
4513 4514 Py_DECREF(obj);
4514 4515 return returnValue;
4515 4516 }
4516 4517 }
4517 4518 return TCP_Terminal_Client::event(arg__1);
4518 4519 }
4519 4520 bool PythonQtShell_TCP_Terminal_Client::eventFilter(QObject* arg__1, QEvent* arg__2)
4520 4521 {
4521 4522 if (_wrapper) {
4522 4523 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
4523 4524 PyErr_Clear();
4524 4525 if (obj && !PythonQtSlotFunction_Check(obj)) {
4525 4526 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4526 4527 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4527 4528 bool returnValue;
4528 4529 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
4529 4530 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4530 4531 if (result) {
4531 4532 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4532 4533 if (args[0]!=&returnValue) {
4533 4534 if (args[0]==NULL) {
4534 4535 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
4535 4536 } else {
4536 4537 returnValue = *((bool*)args[0]);
4537 4538 }
4538 4539 }
4539 4540 }
4540 4541 if (result) { Py_DECREF(result); }
4541 4542 Py_DECREF(obj);
4542 4543 return returnValue;
4543 4544 }
4544 4545 }
4545 4546 return TCP_Terminal_Client::eventFilter(arg__1, arg__2);
4546 4547 }
4547 4548 void PythonQtShell_TCP_Terminal_Client::timerEvent(QTimerEvent* arg__1)
4548 4549 {
4549 4550 if (_wrapper) {
4550 4551 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
4551 4552 PyErr_Clear();
4552 4553 if (obj && !PythonQtSlotFunction_Check(obj)) {
4553 4554 static const char* argumentList[] ={"" , "QTimerEvent*"};
4554 4555 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4555 4556 void* args[2] = {NULL, (void*)&arg__1};
4556 4557 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4557 4558 if (result) { Py_DECREF(result); }
4558 4559 Py_DECREF(obj);
4559 4560 return;
4560 4561 }
4561 4562 }
4562 4563 TCP_Terminal_Client::timerEvent(arg__1);
4563 4564 }
4564 4565 TCP_Terminal_Client* PythonQtWrapper_TCP_Terminal_Client::new_TCP_Terminal_Client(QObject* parent)
4565 4566 {
4566 4567 return new PythonQtShell_TCP_Terminal_Client(parent); }
4567 4568
4568 4569 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject)
4569 4570 {
4570 4571 ( theWrappedObject->connectToServer());
4571 4572 }
4572 4573
4573 4574 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port)
4574 4575 {
4575 4576 ( theWrappedObject->connectToServer(IP, port));
4576 4577 }
4577 4578
4578 4579 bool PythonQtWrapper_TCP_Terminal_Client::isConnected(TCP_Terminal_Client* theWrappedObject)
4579 4580 {
4580 4581 return ( theWrappedObject->isConnected());
4581 4582 }
4582 4583
4583 4584 void PythonQtWrapper_TCP_Terminal_Client::sendText(TCP_Terminal_Client* theWrappedObject, const QString& text)
4584 4585 {
4585 4586 ( theWrappedObject->sendText(text));
4586 4587 }
4587 4588
4588 4589 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject)
4589 4590 {
4590 4591 ( theWrappedObject->startServer());
4591 4592 }
4592 4593
4593 4594 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject, int port)
4594 4595 {
4595 4596 ( theWrappedObject->startServer(port));
4596 4597 }
4597 4598
4598 4599
4599 4600
4600 4601 XByteArray* PythonQtWrapper_XByteArray::new_XByteArray()
4601 4602 {
4602 4603 return new XByteArray(); }
4603 4604
4604 4605 int PythonQtWrapper_XByteArray::addressOffset(XByteArray* theWrappedObject)
4605 4606 {
4606 4607 return ( theWrappedObject->addressOffset());
4607 4608 }
4608 4609
4609 4610 int PythonQtWrapper_XByteArray::addressWidth(XByteArray* theWrappedObject)
4610 4611 {
4611 4612 return ( theWrappedObject->addressWidth());
4612 4613 }
4613 4614
4614 4615 QChar PythonQtWrapper_XByteArray::asciiChar(XByteArray* theWrappedObject, int index)
4615 4616 {
4616 4617 return ( theWrappedObject->asciiChar(index));
4617 4618 }
4618 4619
4619 4620 QByteArray* PythonQtWrapper_XByteArray::data(XByteArray* theWrappedObject)
4620 4621 {
4621 4622 return &( theWrappedObject->data());
4622 4623 }
4623 4624
4624 4625 bool PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i)
4625 4626 {
4626 4627 return ( theWrappedObject->dataChanged(i));
4627 4628 }
4628 4629
4629 4630 QByteArray PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i, int len)
4630 4631 {
4631 4632 return ( theWrappedObject->dataChanged(i, len));
4632 4633 }
4633 4634
4634 4635 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, char ch)
4635 4636 {
4636 4637 return &( theWrappedObject->insert(i, ch));
4637 4638 }
4638 4639
4639 4640 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, const QByteArray& ba)
4640 4641 {
4641 4642 return &( theWrappedObject->insert(i, ba));
4642 4643 }
4643 4644
4644 4645 int PythonQtWrapper_XByteArray::realAddressNumbers(XByteArray* theWrappedObject)
4645 4646 {
4646 4647 return ( theWrappedObject->realAddressNumbers());
4647 4648 }
4648 4649
4649 4650 QByteArray* PythonQtWrapper_XByteArray::remove(XByteArray* theWrappedObject, int pos, int len)
4650 4651 {
4651 4652 return &( theWrappedObject->remove(pos, len));
4652 4653 }
4653 4654
4654 4655 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, char ch)
4655 4656 {
4656 4657 return &( theWrappedObject->replace(index, ch));
4657 4658 }
4658 4659
4659 4660 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, const QByteArray& ba)
4660 4661 {
4661 4662 return &( theWrappedObject->replace(index, ba));
4662 4663 }
4663 4664
4664 4665 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba)
4665 4666 {
4666 4667 return &( theWrappedObject->replace(index, length, ba));
4667 4668 }
4668 4669
4669 4670 void PythonQtWrapper_XByteArray::setAddressOffset(XByteArray* theWrappedObject, int offset)
4670 4671 {
4671 4672 ( theWrappedObject->setAddressOffset(offset));
4672 4673 }
4673 4674
4674 4675 void PythonQtWrapper_XByteArray::setAddressWidth(XByteArray* theWrappedObject, int width)
4675 4676 {
4676 4677 ( theWrappedObject->setAddressWidth(width));
4677 4678 }
4678 4679
4679 4680 void PythonQtWrapper_XByteArray::setData(XByteArray* theWrappedObject, QByteArray data)
4680 4681 {
4681 4682 ( theWrappedObject->setData(data));
4682 4683 }
4683 4684
4684 4685 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, bool state)
4685 4686 {
4686 4687 ( theWrappedObject->setDataChanged(i, state));
4687 4688 }
4688 4689
4689 4690 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state)
4690 4691 {
4691 4692 ( theWrappedObject->setDataChanged(i, state));
4692 4693 }
4693 4694
4694 4695 int PythonQtWrapper_XByteArray::size(XByteArray* theWrappedObject)
4695 4696 {
4696 4697 return ( theWrappedObject->size());
4697 4698 }
4698 4699
4699 4700 QString PythonQtWrapper_XByteArray::toRedableString(XByteArray* theWrappedObject, int start, int end)
4700 4701 {
4701 4702 return ( theWrappedObject->toRedableString(start, end));
4702 4703 }
4703 4704
4704 4705
4705 4706
4706 4707 PythonQtShell_abstractExecFile::~PythonQtShell_abstractExecFile() {
4707 4708 PythonQtPrivate* priv = PythonQt::priv();
4708 4709 if (priv) { priv->shellClassDeleted(this); }
4709 4710 }
4710 4711 void PythonQtShell_abstractExecFile::childEvent(QChildEvent* arg__1)
4711 4712 {
4712 4713 if (_wrapper) {
4713 4714 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
4714 4715 PyErr_Clear();
4715 4716 if (obj && !PythonQtSlotFunction_Check(obj)) {
4716 4717 static const char* argumentList[] ={"" , "QChildEvent*"};
4717 4718 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4718 4719 void* args[2] = {NULL, (void*)&arg__1};
4719 4720 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4720 4721 if (result) { Py_DECREF(result); }
4721 4722 Py_DECREF(obj);
4722 4723 return;
4723 4724 }
4724 4725 }
4725 4726 abstractExecFile::childEvent(arg__1);
4726 4727 }
4727 4728 int PythonQtShell_abstractExecFile::closeFile()
4728 4729 {
4729 4730 if (_wrapper) {
4730 4731 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
4731 4732 PyErr_Clear();
4732 4733 if (obj && !PythonQtSlotFunction_Check(obj)) {
4733 4734 static const char* argumentList[] ={"int"};
4734 4735 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4735 4736 int returnValue;
4736 4737 void* args[1] = {NULL};
4737 4738 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4738 4739 if (result) {
4739 4740 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4740 4741 if (args[0]!=&returnValue) {
4741 4742 if (args[0]==NULL) {
4742 4743 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
4743 4744 } else {
4744 4745 returnValue = *((int*)args[0]);
4745 4746 }
4746 4747 }
4747 4748 }
4748 4749 if (result) { Py_DECREF(result); }
4749 4750 Py_DECREF(obj);
4750 4751 return returnValue;
4751 4752 }
4752 4753 }
4753 4754 return int();
4754 4755 }
4755 4756 void PythonQtShell_abstractExecFile::customEvent(QEvent* arg__1)
4756 4757 {
4757 4758 if (_wrapper) {
4758 4759 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
4759 4760 PyErr_Clear();
4760 4761 if (obj && !PythonQtSlotFunction_Check(obj)) {
4761 4762 static const char* argumentList[] ={"" , "QEvent*"};
4762 4763 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4763 4764 void* args[2] = {NULL, (void*)&arg__1};
4764 4765 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4765 4766 if (result) { Py_DECREF(result); }
4766 4767 Py_DECREF(obj);
4767 4768 return;
4768 4769 }
4769 4770 }
4770 4771 abstractExecFile::customEvent(arg__1);
4771 4772 }
4772 4773 bool PythonQtShell_abstractExecFile::event(QEvent* arg__1)
4773 4774 {
4774 4775 if (_wrapper) {
4775 4776 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
4776 4777 PyErr_Clear();
4777 4778 if (obj && !PythonQtSlotFunction_Check(obj)) {
4778 4779 static const char* argumentList[] ={"bool" , "QEvent*"};
4779 4780 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4780 4781 bool returnValue;
4781 4782 void* args[2] = {NULL, (void*)&arg__1};
4782 4783 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4783 4784 if (result) {
4784 4785 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4785 4786 if (args[0]!=&returnValue) {
4786 4787 if (args[0]==NULL) {
4787 4788 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
4788 4789 } else {
4789 4790 returnValue = *((bool*)args[0]);
4790 4791 }
4791 4792 }
4792 4793 }
4793 4794 if (result) { Py_DECREF(result); }
4794 4795 Py_DECREF(obj);
4795 4796 return returnValue;
4796 4797 }
4797 4798 }
4798 4799 return abstractExecFile::event(arg__1);
4799 4800 }
4800 4801 bool PythonQtShell_abstractExecFile::eventFilter(QObject* arg__1, QEvent* arg__2)
4801 4802 {
4802 4803 if (_wrapper) {
4803 4804 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
4804 4805 PyErr_Clear();
4805 4806 if (obj && !PythonQtSlotFunction_Check(obj)) {
4806 4807 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4807 4808 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4808 4809 bool returnValue;
4809 4810 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
4810 4811 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4811 4812 if (result) {
4812 4813 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4813 4814 if (args[0]!=&returnValue) {
4814 4815 if (args[0]==NULL) {
4815 4816 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
4816 4817 } else {
4817 4818 returnValue = *((bool*)args[0]);
4818 4819 }
4819 4820 }
4820 4821 }
4821 4822 if (result) { Py_DECREF(result); }
4822 4823 Py_DECREF(obj);
4823 4824 return returnValue;
4824 4825 }
4825 4826 }
4826 4827 return abstractExecFile::eventFilter(arg__1, arg__2);
4827 4828 }
4828 4829 QList<codeFragment* > PythonQtShell_abstractExecFile::getFragments()
4829 4830 {
4830 4831 if (_wrapper) {
4831 4832 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
4832 4833 PyErr_Clear();
4833 4834 if (obj && !PythonQtSlotFunction_Check(obj)) {
4834 4835 static const char* argumentList[] ={"QList<codeFragment* >"};
4835 4836 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4836 4837 QList<codeFragment* > returnValue;
4837 4838 void* args[1] = {NULL};
4838 4839 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4839 4840 if (result) {
4840 4841 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4841 4842 if (args[0]!=&returnValue) {
4842 4843 if (args[0]==NULL) {
4843 4844 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
4844 4845 } else {
4845 4846 returnValue = *((QList<codeFragment* >*)args[0]);
4846 4847 }
4847 4848 }
4848 4849 }
4849 4850 if (result) { Py_DECREF(result); }
4850 4851 Py_DECREF(obj);
4851 4852 return returnValue;
4852 4853 }
4853 4854 }
4854 4855 return QList<codeFragment* >();
4855 4856 }
4856 4857 bool PythonQtShell_abstractExecFile::isopened()
4857 4858 {
4858 4859 if (_wrapper) {
4859 4860 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
4860 4861 PyErr_Clear();
4861 4862 if (obj && !PythonQtSlotFunction_Check(obj)) {
4862 4863 static const char* argumentList[] ={"bool"};
4863 4864 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4864 4865 bool returnValue;
4865 4866 void* args[1] = {NULL};
4866 4867 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4867 4868 if (result) {
4868 4869 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4869 4870 if (args[0]!=&returnValue) {
4870 4871 if (args[0]==NULL) {
4871 4872 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
4872 4873 } else {
4873 4874 returnValue = *((bool*)args[0]);
4874 4875 }
4875 4876 }
4876 4877 }
4877 4878 if (result) { Py_DECREF(result); }
4878 4879 Py_DECREF(obj);
4879 4880 return returnValue;
4880 4881 }
4881 4882 }
4882 4883 return bool();
4883 4884 }
4884 4885 bool PythonQtShell_abstractExecFile::openFile(const QString& File)
4885 4886 {
4886 4887 if (_wrapper) {
4887 4888 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
4888 4889 PyErr_Clear();
4889 4890 if (obj && !PythonQtSlotFunction_Check(obj)) {
4890 4891 static const char* argumentList[] ={"bool" , "const QString&"};
4891 4892 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4892 4893 bool returnValue;
4893 4894 void* args[2] = {NULL, (void*)&File};
4894 4895 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4895 4896 if (result) {
4896 4897 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4897 4898 if (args[0]!=&returnValue) {
4898 4899 if (args[0]==NULL) {
4899 4900 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
4900 4901 } else {
4901 4902 returnValue = *((bool*)args[0]);
4902 4903 }
4903 4904 }
4904 4905 }
4905 4906 if (result) { Py_DECREF(result); }
4906 4907 Py_DECREF(obj);
4907 4908 return returnValue;
4908 4909 }
4909 4910 }
4910 4911 return bool();
4911 4912 }
4912 4913 void PythonQtShell_abstractExecFile::timerEvent(QTimerEvent* arg__1)
4913 4914 {
4914 4915 if (_wrapper) {
4915 4916 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
4916 4917 PyErr_Clear();
4917 4918 if (obj && !PythonQtSlotFunction_Check(obj)) {
4918 4919 static const char* argumentList[] ={"" , "QTimerEvent*"};
4919 4920 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4920 4921 void* args[2] = {NULL, (void*)&arg__1};
4921 4922 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4922 4923 if (result) { Py_DECREF(result); }
4923 4924 Py_DECREF(obj);
4924 4925 return;
4925 4926 }
4926 4927 }
4927 4928 abstractExecFile::timerEvent(arg__1);
4928 4929 }
4929 4930 abstractExecFile* PythonQtWrapper_abstractExecFile::new_abstractExecFile()
4930 4931 {
4931 4932 return new PythonQtShell_abstractExecFile(); }
4932 4933
4933 4934
4934 4935
4935 4936 PythonQtShell_codeFragment::~PythonQtShell_codeFragment() {
4936 4937 PythonQtPrivate* priv = PythonQt::priv();
4937 4938 if (priv) { priv->shellClassDeleted(this); }
4938 4939 }
4939 4940 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment()
4940 4941 {
4941 4942 return new PythonQtShell_codeFragment(); }
4942 4943
4943 4944 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment(char* data, unsigned int size, unsigned int address)
4944 4945 {
4945 4946 return new PythonQtShell_codeFragment(data, size, address); }
4946 4947
4947 4948
4948 4949
4949 4950 PythonQtShell_elfFileWidget::~PythonQtShell_elfFileWidget() {
4950 4951 PythonQtPrivate* priv = PythonQt::priv();
4951 4952 if (priv) { priv->shellClassDeleted(this); }
4952 4953 }
4953 4954 void PythonQtShell_elfFileWidget::actionEvent(QActionEvent* arg__1)
4954 4955 {
4955 4956 if (_wrapper) {
4956 4957 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
4957 4958 PyErr_Clear();
4958 4959 if (obj && !PythonQtSlotFunction_Check(obj)) {
4959 4960 static const char* argumentList[] ={"" , "QActionEvent*"};
4960 4961 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4961 4962 void* args[2] = {NULL, (void*)&arg__1};
4962 4963 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4963 4964 if (result) { Py_DECREF(result); }
4964 4965 Py_DECREF(obj);
4965 4966 return;
4966 4967 }
4967 4968 }
4968 4969 elfFileWidget::actionEvent(arg__1);
4969 4970 }
4970 4971 void PythonQtShell_elfFileWidget::changeEvent(QEvent* arg__1)
4971 4972 {
4972 4973 if (_wrapper) {
4973 4974 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
4974 4975 PyErr_Clear();
4975 4976 if (obj && !PythonQtSlotFunction_Check(obj)) {
4976 4977 static const char* argumentList[] ={"" , "QEvent*"};
4977 4978 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4978 4979 void* args[2] = {NULL, (void*)&arg__1};
4979 4980 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4980 4981 if (result) { Py_DECREF(result); }
4981 4982 Py_DECREF(obj);
4982 4983 return;
4983 4984 }
4984 4985 }
4985 4986 elfFileWidget::changeEvent(arg__1);
4986 4987 }
4987 4988 void PythonQtShell_elfFileWidget::childEvent(QChildEvent* arg__1)
4988 4989 {
4989 4990 if (_wrapper) {
4990 4991 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
4991 4992 PyErr_Clear();
4992 4993 if (obj && !PythonQtSlotFunction_Check(obj)) {
4993 4994 static const char* argumentList[] ={"" , "QChildEvent*"};
4994 4995 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4995 4996 void* args[2] = {NULL, (void*)&arg__1};
4996 4997 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4997 4998 if (result) { Py_DECREF(result); }
4998 4999 Py_DECREF(obj);
4999 5000 return;
5000 5001 }
5001 5002 }
5002 5003 elfFileWidget::childEvent(arg__1);
5003 5004 }
5004 5005 void PythonQtShell_elfFileWidget::closeEvent(QCloseEvent* arg__1)
5005 5006 {
5006 5007 if (_wrapper) {
5007 5008 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
5008 5009 PyErr_Clear();
5009 5010 if (obj && !PythonQtSlotFunction_Check(obj)) {
5010 5011 static const char* argumentList[] ={"" , "QCloseEvent*"};
5011 5012 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5012 5013 void* args[2] = {NULL, (void*)&arg__1};
5013 5014 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5014 5015 if (result) { Py_DECREF(result); }
5015 5016 Py_DECREF(obj);
5016 5017 return;
5017 5018 }
5018 5019 }
5019 5020 elfFileWidget::closeEvent(arg__1);
5020 5021 }
5021 5022 void PythonQtShell_elfFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
5022 5023 {
5023 5024 if (_wrapper) {
5024 5025 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
5025 5026 PyErr_Clear();
5026 5027 if (obj && !PythonQtSlotFunction_Check(obj)) {
5027 5028 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
5028 5029 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5029 5030 void* args[2] = {NULL, (void*)&arg__1};
5030 5031 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5031 5032 if (result) { Py_DECREF(result); }
5032 5033 Py_DECREF(obj);
5033 5034 return;
5034 5035 }
5035 5036 }
5036 5037 elfFileWidget::contextMenuEvent(arg__1);
5037 5038 }
5038 5039 void PythonQtShell_elfFileWidget::customEvent(QEvent* arg__1)
5039 5040 {
5040 5041 if (_wrapper) {
5041 5042 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
5042 5043 PyErr_Clear();
5043 5044 if (obj && !PythonQtSlotFunction_Check(obj)) {
5044 5045 static const char* argumentList[] ={"" , "QEvent*"};
5045 5046 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5046 5047 void* args[2] = {NULL, (void*)&arg__1};
5047 5048 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5048 5049 if (result) { Py_DECREF(result); }
5049 5050 Py_DECREF(obj);
5050 5051 return;
5051 5052 }
5052 5053 }
5053 5054 elfFileWidget::customEvent(arg__1);
5054 5055 }
5055 5056 int PythonQtShell_elfFileWidget::devType() const
5056 5057 {
5057 5058 if (_wrapper) {
5058 5059 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
5059 5060 PyErr_Clear();
5060 5061 if (obj && !PythonQtSlotFunction_Check(obj)) {
5061 5062 static const char* argumentList[] ={"int"};
5062 5063 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5063 5064 int returnValue;
5064 5065 void* args[1] = {NULL};
5065 5066 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5066 5067 if (result) {
5067 5068 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5068 5069 if (args[0]!=&returnValue) {
5069 5070 if (args[0]==NULL) {
5070 5071 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
5071 5072 } else {
5072 5073 returnValue = *((int*)args[0]);
5073 5074 }
5074 5075 }
5075 5076 }
5076 5077 if (result) { Py_DECREF(result); }
5077 5078 Py_DECREF(obj);
5078 5079 return returnValue;
5079 5080 }
5080 5081 }
5081 5082 return elfFileWidget::devType();
5082 5083 }
5083 5084 void PythonQtShell_elfFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
5084 5085 {
5085 5086 if (_wrapper) {
5086 5087 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
5087 5088 PyErr_Clear();
5088 5089 if (obj && !PythonQtSlotFunction_Check(obj)) {
5089 5090 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
5090 5091 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5091 5092 void* args[2] = {NULL, (void*)&arg__1};
5092 5093 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5093 5094 if (result) { Py_DECREF(result); }
5094 5095 Py_DECREF(obj);
5095 5096 return;
5096 5097 }
5097 5098 }
5098 5099 elfFileWidget::dragEnterEvent(arg__1);
5099 5100 }
5100 5101 void PythonQtShell_elfFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
5101 5102 {
5102 5103 if (_wrapper) {
5103 5104 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
5104 5105 PyErr_Clear();
5105 5106 if (obj && !PythonQtSlotFunction_Check(obj)) {
5106 5107 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
5107 5108 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5108 5109 void* args[2] = {NULL, (void*)&arg__1};
5109 5110 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5110 5111 if (result) { Py_DECREF(result); }
5111 5112 Py_DECREF(obj);
5112 5113 return;
5113 5114 }
5114 5115 }
5115 5116 elfFileWidget::dragLeaveEvent(arg__1);
5116 5117 }
5117 5118 void PythonQtShell_elfFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
5118 5119 {
5119 5120 if (_wrapper) {
5120 5121 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
5121 5122 PyErr_Clear();
5122 5123 if (obj && !PythonQtSlotFunction_Check(obj)) {
5123 5124 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
5124 5125 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5125 5126 void* args[2] = {NULL, (void*)&arg__1};
5126 5127 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5127 5128 if (result) { Py_DECREF(result); }
5128 5129 Py_DECREF(obj);
5129 5130 return;
5130 5131 }
5131 5132 }
5132 5133 elfFileWidget::dragMoveEvent(arg__1);
5133 5134 }
5134 5135 void PythonQtShell_elfFileWidget::dropEvent(QDropEvent* arg__1)
5135 5136 {
5136 5137 if (_wrapper) {
5137 5138 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
5138 5139 PyErr_Clear();
5139 5140 if (obj && !PythonQtSlotFunction_Check(obj)) {
5140 5141 static const char* argumentList[] ={"" , "QDropEvent*"};
5141 5142 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5142 5143 void* args[2] = {NULL, (void*)&arg__1};
5143 5144 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5144 5145 if (result) { Py_DECREF(result); }
5145 5146 Py_DECREF(obj);
5146 5147 return;
5147 5148 }
5148 5149 }
5149 5150 elfFileWidget::dropEvent(arg__1);
5150 5151 }
5151 5152 void PythonQtShell_elfFileWidget::enterEvent(QEvent* arg__1)
5152 5153 {
5153 5154 if (_wrapper) {
5154 5155 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
5155 5156 PyErr_Clear();
5156 5157 if (obj && !PythonQtSlotFunction_Check(obj)) {
5157 5158 static const char* argumentList[] ={"" , "QEvent*"};
5158 5159 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5159 5160 void* args[2] = {NULL, (void*)&arg__1};
5160 5161 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5161 5162 if (result) { Py_DECREF(result); }
5162 5163 Py_DECREF(obj);
5163 5164 return;
5164 5165 }
5165 5166 }
5166 5167 elfFileWidget::enterEvent(arg__1);
5167 5168 }
5168 5169 bool PythonQtShell_elfFileWidget::event(QEvent* arg__1)
5169 5170 {
5170 5171 if (_wrapper) {
5171 5172 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
5172 5173 PyErr_Clear();
5173 5174 if (obj && !PythonQtSlotFunction_Check(obj)) {
5174 5175 static const char* argumentList[] ={"bool" , "QEvent*"};
5175 5176 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5176 5177 bool returnValue;
5177 5178 void* args[2] = {NULL, (void*)&arg__1};
5178 5179 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5179 5180 if (result) {
5180 5181 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5181 5182 if (args[0]!=&returnValue) {
5182 5183 if (args[0]==NULL) {
5183 5184 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
5184 5185 } else {
5185 5186 returnValue = *((bool*)args[0]);
5186 5187 }
5187 5188 }
5188 5189 }
5189 5190 if (result) { Py_DECREF(result); }
5190 5191 Py_DECREF(obj);
5191 5192 return returnValue;
5192 5193 }
5193 5194 }
5194 5195 return elfFileWidget::event(arg__1);
5195 5196 }
5196 5197 bool PythonQtShell_elfFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
5197 5198 {
5198 5199 if (_wrapper) {
5199 5200 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
5200 5201 PyErr_Clear();
5201 5202 if (obj && !PythonQtSlotFunction_Check(obj)) {
5202 5203 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5203 5204 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5204 5205 bool returnValue;
5205 5206 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
5206 5207 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5207 5208 if (result) {
5208 5209 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5209 5210 if (args[0]!=&returnValue) {
5210 5211 if (args[0]==NULL) {
5211 5212 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
5212 5213 } else {
5213 5214 returnValue = *((bool*)args[0]);
5214 5215 }
5215 5216 }
5216 5217 }
5217 5218 if (result) { Py_DECREF(result); }
5218 5219 Py_DECREF(obj);
5219 5220 return returnValue;
5220 5221 }
5221 5222 }
5222 5223 return elfFileWidget::eventFilter(arg__1, arg__2);
5223 5224 }
5224 5225 void PythonQtShell_elfFileWidget::focusInEvent(QFocusEvent* arg__1)
5225 5226 {
5226 5227 if (_wrapper) {
5227 5228 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
5228 5229 PyErr_Clear();
5229 5230 if (obj && !PythonQtSlotFunction_Check(obj)) {
5230 5231 static const char* argumentList[] ={"" , "QFocusEvent*"};
5231 5232 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5232 5233 void* args[2] = {NULL, (void*)&arg__1};
5233 5234 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5234 5235 if (result) { Py_DECREF(result); }
5235 5236 Py_DECREF(obj);
5236 5237 return;
5237 5238 }
5238 5239 }
5239 5240 elfFileWidget::focusInEvent(arg__1);
5240 5241 }
5241 5242 bool PythonQtShell_elfFileWidget::focusNextPrevChild(bool next)
5242 5243 {
5243 5244 if (_wrapper) {
5244 5245 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
5245 5246 PyErr_Clear();
5246 5247 if (obj && !PythonQtSlotFunction_Check(obj)) {
5247 5248 static const char* argumentList[] ={"bool" , "bool"};
5248 5249 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5249 5250 bool returnValue;
5250 5251 void* args[2] = {NULL, (void*)&next};
5251 5252 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5252 5253 if (result) {
5253 5254 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5254 5255 if (args[0]!=&returnValue) {
5255 5256 if (args[0]==NULL) {
5256 5257 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
5257 5258 } else {
5258 5259 returnValue = *((bool*)args[0]);
5259 5260 }
5260 5261 }
5261 5262 }
5262 5263 if (result) { Py_DECREF(result); }
5263 5264 Py_DECREF(obj);
5264 5265 return returnValue;
5265 5266 }
5266 5267 }
5267 5268 return elfFileWidget::focusNextPrevChild(next);
5268 5269 }
5269 5270 void PythonQtShell_elfFileWidget::focusOutEvent(QFocusEvent* arg__1)
5270 5271 {
5271 5272 if (_wrapper) {
5272 5273 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
5273 5274 PyErr_Clear();
5274 5275 if (obj && !PythonQtSlotFunction_Check(obj)) {
5275 5276 static const char* argumentList[] ={"" , "QFocusEvent*"};
5276 5277 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5277 5278 void* args[2] = {NULL, (void*)&arg__1};
5278 5279 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5279 5280 if (result) { Py_DECREF(result); }
5280 5281 Py_DECREF(obj);
5281 5282 return;
5282 5283 }
5283 5284 }
5284 5285 elfFileWidget::focusOutEvent(arg__1);
5285 5286 }
5286 5287 bool PythonQtShell_elfFileWidget::hasHeightForWidth() const
5287 5288 {
5288 5289 if (_wrapper) {
5289 5290 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
5290 5291 PyErr_Clear();
5291 5292 if (obj && !PythonQtSlotFunction_Check(obj)) {
5292 5293 static const char* argumentList[] ={"bool"};
5293 5294 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5294 5295 bool returnValue;
5295 5296 void* args[1] = {NULL};
5296 5297 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5297 5298 if (result) {
5298 5299 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5299 5300 if (args[0]!=&returnValue) {
5300 5301 if (args[0]==NULL) {
5301 5302 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
5302 5303 } else {
5303 5304 returnValue = *((bool*)args[0]);
5304 5305 }
5305 5306 }
5306 5307 }
5307 5308 if (result) { Py_DECREF(result); }
5308 5309 Py_DECREF(obj);
5309 5310 return returnValue;
5310 5311 }
5311 5312 }
5312 5313 return elfFileWidget::hasHeightForWidth();
5313 5314 }
5314 5315 int PythonQtShell_elfFileWidget::heightForWidth(int arg__1) const
5315 5316 {
5316 5317 if (_wrapper) {
5317 5318 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
5318 5319 PyErr_Clear();
5319 5320 if (obj && !PythonQtSlotFunction_Check(obj)) {
5320 5321 static const char* argumentList[] ={"int" , "int"};
5321 5322 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5322 5323 int returnValue;
5323 5324 void* args[2] = {NULL, (void*)&arg__1};
5324 5325 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5325 5326 if (result) {
5326 5327 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5327 5328 if (args[0]!=&returnValue) {
5328 5329 if (args[0]==NULL) {
5329 5330 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
5330 5331 } else {
5331 5332 returnValue = *((int*)args[0]);
5332 5333 }
5333 5334 }
5334 5335 }
5335 5336 if (result) { Py_DECREF(result); }
5336 5337 Py_DECREF(obj);
5337 5338 return returnValue;
5338 5339 }
5339 5340 }
5340 5341 return elfFileWidget::heightForWidth(arg__1);
5341 5342 }
5342 5343 void PythonQtShell_elfFileWidget::hideEvent(QHideEvent* arg__1)
5343 5344 {
5344 5345 if (_wrapper) {
5345 5346 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
5346 5347 PyErr_Clear();
5347 5348 if (obj && !PythonQtSlotFunction_Check(obj)) {
5348 5349 static const char* argumentList[] ={"" , "QHideEvent*"};
5349 5350 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5350 5351 void* args[2] = {NULL, (void*)&arg__1};
5351 5352 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5352 5353 if (result) { Py_DECREF(result); }
5353 5354 Py_DECREF(obj);
5354 5355 return;
5355 5356 }
5356 5357 }
5357 5358 elfFileWidget::hideEvent(arg__1);
5358 5359 }
5359 5360 void PythonQtShell_elfFileWidget::initPainter(QPainter* painter) const
5360 5361 {
5361 5362 if (_wrapper) {
5362 5363 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
5363 5364 PyErr_Clear();
5364 5365 if (obj && !PythonQtSlotFunction_Check(obj)) {
5365 5366 static const char* argumentList[] ={"" , "QPainter*"};
5366 5367 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5367 5368 void* args[2] = {NULL, (void*)&painter};
5368 5369 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5369 5370 if (result) { Py_DECREF(result); }
5370 5371 Py_DECREF(obj);
5371 5372 return;
5372 5373 }
5373 5374 }
5374 5375 elfFileWidget::initPainter(painter);
5375 5376 }
5376 5377 void PythonQtShell_elfFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
5377 5378 {
5378 5379 if (_wrapper) {
5379 5380 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
5380 5381 PyErr_Clear();
5381 5382 if (obj && !PythonQtSlotFunction_Check(obj)) {
5382 5383 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
5383 5384 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5384 5385 void* args[2] = {NULL, (void*)&arg__1};
5385 5386 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5386 5387 if (result) { Py_DECREF(result); }
5387 5388 Py_DECREF(obj);
5388 5389 return;
5389 5390 }
5390 5391 }
5391 5392 elfFileWidget::inputMethodEvent(arg__1);
5392 5393 }
5393 5394 QVariant PythonQtShell_elfFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
5394 5395 {
5395 5396 if (_wrapper) {
5396 5397 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
5397 5398 PyErr_Clear();
5398 5399 if (obj && !PythonQtSlotFunction_Check(obj)) {
5399 5400 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
5400 5401 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5401 5402 QVariant returnValue;
5402 5403 void* args[2] = {NULL, (void*)&arg__1};
5403 5404 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5404 5405 if (result) {
5405 5406 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5406 5407 if (args[0]!=&returnValue) {
5407 5408 if (args[0]==NULL) {
5408 5409 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
5409 5410 } else {
5410 5411 returnValue = *((QVariant*)args[0]);
5411 5412 }
5412 5413 }
5413 5414 }
5414 5415 if (result) { Py_DECREF(result); }
5415 5416 Py_DECREF(obj);
5416 5417 return returnValue;
5417 5418 }
5418 5419 }
5419 5420 return elfFileWidget::inputMethodQuery(arg__1);
5420 5421 }
5421 5422 void PythonQtShell_elfFileWidget::keyPressEvent(QKeyEvent* arg__1)
5422 5423 {
5423 5424 if (_wrapper) {
5424 5425 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
5425 5426 PyErr_Clear();
5426 5427 if (obj && !PythonQtSlotFunction_Check(obj)) {
5427 5428 static const char* argumentList[] ={"" , "QKeyEvent*"};
5428 5429 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5429 5430 void* args[2] = {NULL, (void*)&arg__1};
5430 5431 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5431 5432 if (result) { Py_DECREF(result); }
5432 5433 Py_DECREF(obj);
5433 5434 return;
5434 5435 }
5435 5436 }
5436 5437 elfFileWidget::keyPressEvent(arg__1);
5437 5438 }
5438 5439 void PythonQtShell_elfFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
5439 5440 {
5440 5441 if (_wrapper) {
5441 5442 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
5442 5443 PyErr_Clear();
5443 5444 if (obj && !PythonQtSlotFunction_Check(obj)) {
5444 5445 static const char* argumentList[] ={"" , "QKeyEvent*"};
5445 5446 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5446 5447 void* args[2] = {NULL, (void*)&arg__1};
5447 5448 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5448 5449 if (result) { Py_DECREF(result); }
5449 5450 Py_DECREF(obj);
5450 5451 return;
5451 5452 }
5452 5453 }
5453 5454 elfFileWidget::keyReleaseEvent(arg__1);
5454 5455 }
5455 5456 void PythonQtShell_elfFileWidget::leaveEvent(QEvent* arg__1)
5456 5457 {
5457 5458 if (_wrapper) {
5458 5459 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
5459 5460 PyErr_Clear();
5460 5461 if (obj && !PythonQtSlotFunction_Check(obj)) {
5461 5462 static const char* argumentList[] ={"" , "QEvent*"};
5462 5463 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5463 5464 void* args[2] = {NULL, (void*)&arg__1};
5464 5465 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5465 5466 if (result) { Py_DECREF(result); }
5466 5467 Py_DECREF(obj);
5467 5468 return;
5468 5469 }
5469 5470 }
5470 5471 elfFileWidget::leaveEvent(arg__1);
5471 5472 }
5472 5473 int PythonQtShell_elfFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
5473 5474 {
5474 5475 if (_wrapper) {
5475 5476 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
5476 5477 PyErr_Clear();
5477 5478 if (obj && !PythonQtSlotFunction_Check(obj)) {
5478 5479 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
5479 5480 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5480 5481 int returnValue;
5481 5482 void* args[2] = {NULL, (void*)&arg__1};
5482 5483 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5483 5484 if (result) {
5484 5485 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5485 5486 if (args[0]!=&returnValue) {
5486 5487 if (args[0]==NULL) {
5487 5488 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
5488 5489 } else {
5489 5490 returnValue = *((int*)args[0]);
5490 5491 }
5491 5492 }
5492 5493 }
5493 5494 if (result) { Py_DECREF(result); }
5494 5495 Py_DECREF(obj);
5495 5496 return returnValue;
5496 5497 }
5497 5498 }
5498 5499 return elfFileWidget::metric(arg__1);
5499 5500 }
5500 5501 QSize PythonQtShell_elfFileWidget::minimumSizeHint() const
5501 5502 {
5502 5503 if (_wrapper) {
5503 5504 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
5504 5505 PyErr_Clear();
5505 5506 if (obj && !PythonQtSlotFunction_Check(obj)) {
5506 5507 static const char* argumentList[] ={"QSize"};
5507 5508 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5508 5509 QSize returnValue;
5509 5510 void* args[1] = {NULL};
5510 5511 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5511 5512 if (result) {
5512 5513 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5513 5514 if (args[0]!=&returnValue) {
5514 5515 if (args[0]==NULL) {
5515 5516 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
5516 5517 } else {
5517 5518 returnValue = *((QSize*)args[0]);
5518 5519 }
5519 5520 }
5520 5521 }
5521 5522 if (result) { Py_DECREF(result); }
5522 5523 Py_DECREF(obj);
5523 5524 return returnValue;
5524 5525 }
5525 5526 }
5526 5527 return elfFileWidget::minimumSizeHint();
5527 5528 }
5528 5529 void PythonQtShell_elfFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
5529 5530 {
5530 5531 if (_wrapper) {
5531 5532 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
5532 5533 PyErr_Clear();
5533 5534 if (obj && !PythonQtSlotFunction_Check(obj)) {
5534 5535 static const char* argumentList[] ={"" , "QMouseEvent*"};
5535 5536 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5536 5537 void* args[2] = {NULL, (void*)&arg__1};
5537 5538 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5538 5539 if (result) { Py_DECREF(result); }
5539 5540 Py_DECREF(obj);
5540 5541 return;
5541 5542 }
5542 5543 }
5543 5544 elfFileWidget::mouseDoubleClickEvent(arg__1);
5544 5545 }
5545 5546 void PythonQtShell_elfFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
5546 5547 {
5547 5548 if (_wrapper) {
5548 5549 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
5549 5550 PyErr_Clear();
5550 5551 if (obj && !PythonQtSlotFunction_Check(obj)) {
5551 5552 static const char* argumentList[] ={"" , "QMouseEvent*"};
5552 5553 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5553 5554 void* args[2] = {NULL, (void*)&arg__1};
5554 5555 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5555 5556 if (result) { Py_DECREF(result); }
5556 5557 Py_DECREF(obj);
5557 5558 return;
5558 5559 }
5559 5560 }
5560 5561 elfFileWidget::mouseMoveEvent(arg__1);
5561 5562 }
5562 5563 void PythonQtShell_elfFileWidget::mousePressEvent(QMouseEvent* arg__1)
5563 5564 {
5564 5565 if (_wrapper) {
5565 5566 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
5566 5567 PyErr_Clear();
5567 5568 if (obj && !PythonQtSlotFunction_Check(obj)) {
5568 5569 static const char* argumentList[] ={"" , "QMouseEvent*"};
5569 5570 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5570 5571 void* args[2] = {NULL, (void*)&arg__1};
5571 5572 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5572 5573 if (result) { Py_DECREF(result); }
5573 5574 Py_DECREF(obj);
5574 5575 return;
5575 5576 }
5576 5577 }
5577 5578 elfFileWidget::mousePressEvent(arg__1);
5578 5579 }
5579 5580 void PythonQtShell_elfFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
5580 5581 {
5581 5582 if (_wrapper) {
5582 5583 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
5583 5584 PyErr_Clear();
5584 5585 if (obj && !PythonQtSlotFunction_Check(obj)) {
5585 5586 static const char* argumentList[] ={"" , "QMouseEvent*"};
5586 5587 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5587 5588 void* args[2] = {NULL, (void*)&arg__1};
5588 5589 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5589 5590 if (result) { Py_DECREF(result); }
5590 5591 Py_DECREF(obj);
5591 5592 return;
5592 5593 }
5593 5594 }
5594 5595 elfFileWidget::mouseReleaseEvent(arg__1);
5595 5596 }
5596 5597 void PythonQtShell_elfFileWidget::moveEvent(QMoveEvent* arg__1)
5597 5598 {
5598 5599 if (_wrapper) {
5599 5600 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
5600 5601 PyErr_Clear();
5601 5602 if (obj && !PythonQtSlotFunction_Check(obj)) {
5602 5603 static const char* argumentList[] ={"" , "QMoveEvent*"};
5603 5604 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5604 5605 void* args[2] = {NULL, (void*)&arg__1};
5605 5606 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5606 5607 if (result) { Py_DECREF(result); }
5607 5608 Py_DECREF(obj);
5608 5609 return;
5609 5610 }
5610 5611 }
5611 5612 elfFileWidget::moveEvent(arg__1);
5612 5613 }
5613 5614 bool PythonQtShell_elfFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result)
5614 5615 {
5615 5616 if (_wrapper) {
5616 5617 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
5617 5618 PyErr_Clear();
5618 5619 if (obj && !PythonQtSlotFunction_Check(obj)) {
5619 5620 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
5620 5621 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
5621 5622 bool returnValue;
5622 5623 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
5623 5624 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5624 5625 if (result) {
5625 5626 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5626 5627 if (args[0]!=&returnValue) {
5627 5628 if (args[0]==NULL) {
5628 5629 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
5629 5630 } else {
5630 5631 returnValue = *((bool*)args[0]);
5631 5632 }
5632 5633 }
5633 5634 }
5634 5635 if (result) { Py_DECREF(result); }
5635 5636 Py_DECREF(obj);
5636 5637 return returnValue;
5637 5638 }
5638 5639 }
5639 5640 return elfFileWidget::nativeEvent(eventType, message, result);
5640 5641 }
5641 5642 QPaintEngine* PythonQtShell_elfFileWidget::paintEngine() const
5642 5643 {
5643 5644 if (_wrapper) {
5644 5645 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
5645 5646 PyErr_Clear();
5646 5647 if (obj && !PythonQtSlotFunction_Check(obj)) {
5647 5648 static const char* argumentList[] ={"QPaintEngine*"};
5648 5649 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5649 5650 QPaintEngine* returnValue;
5650 5651 void* args[1] = {NULL};
5651 5652 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5652 5653 if (result) {
5653 5654 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5654 5655 if (args[0]!=&returnValue) {
5655 5656 if (args[0]==NULL) {
5656 5657 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
5657 5658 } else {
5658 5659 returnValue = *((QPaintEngine**)args[0]);
5659 5660 }
5660 5661 }
5661 5662 }
5662 5663 if (result) { Py_DECREF(result); }
5663 5664 Py_DECREF(obj);
5664 5665 return returnValue;
5665 5666 }
5666 5667 }
5667 5668 return elfFileWidget::paintEngine();
5668 5669 }
5669 5670 void PythonQtShell_elfFileWidget::paintEvent(QPaintEvent* arg__1)
5670 5671 {
5671 5672 if (_wrapper) {
5672 5673 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
5673 5674 PyErr_Clear();
5674 5675 if (obj && !PythonQtSlotFunction_Check(obj)) {
5675 5676 static const char* argumentList[] ={"" , "QPaintEvent*"};
5676 5677 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5677 5678 void* args[2] = {NULL, (void*)&arg__1};
5678 5679 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5679 5680 if (result) { Py_DECREF(result); }
5680 5681 Py_DECREF(obj);
5681 5682 return;
5682 5683 }
5683 5684 }
5684 5685 elfFileWidget::paintEvent(arg__1);
5685 5686 }
5686 5687 QPaintDevice* PythonQtShell_elfFileWidget::redirected(QPoint* offset) const
5687 5688 {
5688 5689 if (_wrapper) {
5689 5690 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
5690 5691 PyErr_Clear();
5691 5692 if (obj && !PythonQtSlotFunction_Check(obj)) {
5692 5693 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
5693 5694 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5694 5695 QPaintDevice* returnValue;
5695 5696 void* args[2] = {NULL, (void*)&offset};
5696 5697 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5697 5698 if (result) {
5698 5699 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5699 5700 if (args[0]!=&returnValue) {
5700 5701 if (args[0]==NULL) {
5701 5702 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
5702 5703 } else {
5703 5704 returnValue = *((QPaintDevice**)args[0]);
5704 5705 }
5705 5706 }
5706 5707 }
5707 5708 if (result) { Py_DECREF(result); }
5708 5709 Py_DECREF(obj);
5709 5710 return returnValue;
5710 5711 }
5711 5712 }
5712 5713 return elfFileWidget::redirected(offset);
5713 5714 }
5714 5715 void PythonQtShell_elfFileWidget::resizeEvent(QResizeEvent* arg__1)
5715 5716 {
5716 5717 if (_wrapper) {
5717 5718 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
5718 5719 PyErr_Clear();
5719 5720 if (obj && !PythonQtSlotFunction_Check(obj)) {
5720 5721 static const char* argumentList[] ={"" , "QResizeEvent*"};
5721 5722 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5722 5723 void* args[2] = {NULL, (void*)&arg__1};
5723 5724 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5724 5725 if (result) { Py_DECREF(result); }
5725 5726 Py_DECREF(obj);
5726 5727 return;
5727 5728 }
5728 5729 }
5729 5730 elfFileWidget::resizeEvent(arg__1);
5730 5731 }
5731 5732 QPainter* PythonQtShell_elfFileWidget::sharedPainter() const
5732 5733 {
5733 5734 if (_wrapper) {
5734 5735 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
5735 5736 PyErr_Clear();
5736 5737 if (obj && !PythonQtSlotFunction_Check(obj)) {
5737 5738 static const char* argumentList[] ={"QPainter*"};
5738 5739 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5739 5740 QPainter* returnValue;
5740 5741 void* args[1] = {NULL};
5741 5742 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5742 5743 if (result) {
5743 5744 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5744 5745 if (args[0]!=&returnValue) {
5745 5746 if (args[0]==NULL) {
5746 5747 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
5747 5748 } else {
5748 5749 returnValue = *((QPainter**)args[0]);
5749 5750 }
5750 5751 }
5751 5752 }
5752 5753 if (result) { Py_DECREF(result); }
5753 5754 Py_DECREF(obj);
5754 5755 return returnValue;
5755 5756 }
5756 5757 }
5757 5758 return elfFileWidget::sharedPainter();
5758 5759 }
5759 5760 void PythonQtShell_elfFileWidget::showEvent(QShowEvent* arg__1)
5760 5761 {
5761 5762 if (_wrapper) {
5762 5763 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
5763 5764 PyErr_Clear();
5764 5765 if (obj && !PythonQtSlotFunction_Check(obj)) {
5765 5766 static const char* argumentList[] ={"" , "QShowEvent*"};
5766 5767 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5767 5768 void* args[2] = {NULL, (void*)&arg__1};
5768 5769 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5769 5770 if (result) { Py_DECREF(result); }
5770 5771 Py_DECREF(obj);
5771 5772 return;
5772 5773 }
5773 5774 }
5774 5775 elfFileWidget::showEvent(arg__1);
5775 5776 }
5776 5777 QSize PythonQtShell_elfFileWidget::sizeHint() const
5777 5778 {
5778 5779 if (_wrapper) {
5779 5780 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
5780 5781 PyErr_Clear();
5781 5782 if (obj && !PythonQtSlotFunction_Check(obj)) {
5782 5783 static const char* argumentList[] ={"QSize"};
5783 5784 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5784 5785 QSize returnValue;
5785 5786 void* args[1] = {NULL};
5786 5787 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5787 5788 if (result) {
5788 5789 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5789 5790 if (args[0]!=&returnValue) {
5790 5791 if (args[0]==NULL) {
5791 5792 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
5792 5793 } else {
5793 5794 returnValue = *((QSize*)args[0]);
5794 5795 }
5795 5796 }
5796 5797 }
5797 5798 if (result) { Py_DECREF(result); }
5798 5799 Py_DECREF(obj);
5799 5800 return returnValue;
5800 5801 }
5801 5802 }
5802 5803 return elfFileWidget::sizeHint();
5803 5804 }
5804 5805 void PythonQtShell_elfFileWidget::tabletEvent(QTabletEvent* arg__1)
5805 5806 {
5806 5807 if (_wrapper) {
5807 5808 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
5808 5809 PyErr_Clear();
5809 5810 if (obj && !PythonQtSlotFunction_Check(obj)) {
5810 5811 static const char* argumentList[] ={"" , "QTabletEvent*"};
5811 5812 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5812 5813 void* args[2] = {NULL, (void*)&arg__1};
5813 5814 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5814 5815 if (result) { Py_DECREF(result); }
5815 5816 Py_DECREF(obj);
5816 5817 return;
5817 5818 }
5818 5819 }
5819 5820 elfFileWidget::tabletEvent(arg__1);
5820 5821 }
5821 5822 void PythonQtShell_elfFileWidget::timerEvent(QTimerEvent* arg__1)
5822 5823 {
5823 5824 if (_wrapper) {
5824 5825 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
5825 5826 PyErr_Clear();
5826 5827 if (obj && !PythonQtSlotFunction_Check(obj)) {
5827 5828 static const char* argumentList[] ={"" , "QTimerEvent*"};
5828 5829 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5829 5830 void* args[2] = {NULL, (void*)&arg__1};
5830 5831 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5831 5832 if (result) { Py_DECREF(result); }
5832 5833 Py_DECREF(obj);
5833 5834 return;
5834 5835 }
5835 5836 }
5836 5837 elfFileWidget::timerEvent(arg__1);
5837 5838 }
5838 5839 void PythonQtShell_elfFileWidget::wheelEvent(QWheelEvent* arg__1)
5839 5840 {
5840 5841 if (_wrapper) {
5841 5842 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
5842 5843 PyErr_Clear();
5843 5844 if (obj && !PythonQtSlotFunction_Check(obj)) {
5844 5845 static const char* argumentList[] ={"" , "QWheelEvent*"};
5845 5846 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5846 5847 void* args[2] = {NULL, (void*)&arg__1};
5847 5848 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5848 5849 if (result) { Py_DECREF(result); }
5849 5850 Py_DECREF(obj);
5850 5851 return;
5851 5852 }
5852 5853 }
5853 5854 elfFileWidget::wheelEvent(arg__1);
5854 5855 }
5855 5856 elfFileWidget* PythonQtWrapper_elfFileWidget::new_elfFileWidget(QWidget* parent)
5856 5857 {
5857 5858 return new PythonQtShell_elfFileWidget(parent); }
5858 5859
5859 5860
5860 5861
5861 5862 PythonQtShell_elfInfoWdgt::~PythonQtShell_elfInfoWdgt() {
5862 5863 PythonQtPrivate* priv = PythonQt::priv();
5863 5864 if (priv) { priv->shellClassDeleted(this); }
5864 5865 }
5865 5866 void PythonQtShell_elfInfoWdgt::actionEvent(QActionEvent* arg__1)
5866 5867 {
5867 5868 if (_wrapper) {
5868 5869 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
5869 5870 PyErr_Clear();
5870 5871 if (obj && !PythonQtSlotFunction_Check(obj)) {
5871 5872 static const char* argumentList[] ={"" , "QActionEvent*"};
5872 5873 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5873 5874 void* args[2] = {NULL, (void*)&arg__1};
5874 5875 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5875 5876 if (result) { Py_DECREF(result); }
5876 5877 Py_DECREF(obj);
5877 5878 return;
5878 5879 }
5879 5880 }
5880 5881 elfInfoWdgt::actionEvent(arg__1);
5881 5882 }
5882 5883 void PythonQtShell_elfInfoWdgt::changeEvent(QEvent* arg__1)
5883 5884 {
5884 5885 if (_wrapper) {
5885 5886 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
5886 5887 PyErr_Clear();
5887 5888 if (obj && !PythonQtSlotFunction_Check(obj)) {
5888 5889 static const char* argumentList[] ={"" , "QEvent*"};
5889 5890 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5890 5891 void* args[2] = {NULL, (void*)&arg__1};
5891 5892 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5892 5893 if (result) { Py_DECREF(result); }
5893 5894 Py_DECREF(obj);
5894 5895 return;
5895 5896 }
5896 5897 }
5897 5898 elfInfoWdgt::changeEvent(arg__1);
5898 5899 }
5899 5900 void PythonQtShell_elfInfoWdgt::childEvent(QChildEvent* arg__1)
5900 5901 {
5901 5902 if (_wrapper) {
5902 5903 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
5903 5904 PyErr_Clear();
5904 5905 if (obj && !PythonQtSlotFunction_Check(obj)) {
5905 5906 static const char* argumentList[] ={"" , "QChildEvent*"};
5906 5907 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5907 5908 void* args[2] = {NULL, (void*)&arg__1};
5908 5909 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5909 5910 if (result) { Py_DECREF(result); }
5910 5911 Py_DECREF(obj);
5911 5912 return;
5912 5913 }
5913 5914 }
5914 5915 elfInfoWdgt::childEvent(arg__1);
5915 5916 }
5916 5917 void PythonQtShell_elfInfoWdgt::closeEvent(QCloseEvent* arg__1)
5917 5918 {
5918 5919 if (_wrapper) {
5919 5920 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
5920 5921 PyErr_Clear();
5921 5922 if (obj && !PythonQtSlotFunction_Check(obj)) {
5922 5923 static const char* argumentList[] ={"" , "QCloseEvent*"};
5923 5924 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5924 5925 void* args[2] = {NULL, (void*)&arg__1};
5925 5926 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5926 5927 if (result) { Py_DECREF(result); }
5927 5928 Py_DECREF(obj);
5928 5929 return;
5929 5930 }
5930 5931 }
5931 5932 elfInfoWdgt::closeEvent(arg__1);
5932 5933 }
5933 5934 void PythonQtShell_elfInfoWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
5934 5935 {
5935 5936 if (_wrapper) {
5936 5937 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
5937 5938 PyErr_Clear();
5938 5939 if (obj && !PythonQtSlotFunction_Check(obj)) {
5939 5940 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
5940 5941 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5941 5942 void* args[2] = {NULL, (void*)&arg__1};
5942 5943 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5943 5944 if (result) { Py_DECREF(result); }
5944 5945 Py_DECREF(obj);
5945 5946 return;
5946 5947 }
5947 5948 }
5948 5949 elfInfoWdgt::contextMenuEvent(arg__1);
5949 5950 }
5950 5951 void PythonQtShell_elfInfoWdgt::customEvent(QEvent* arg__1)
5951 5952 {
5952 5953 if (_wrapper) {
5953 5954 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
5954 5955 PyErr_Clear();
5955 5956 if (obj && !PythonQtSlotFunction_Check(obj)) {
5956 5957 static const char* argumentList[] ={"" , "QEvent*"};
5957 5958 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5958 5959 void* args[2] = {NULL, (void*)&arg__1};
5959 5960 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5960 5961 if (result) { Py_DECREF(result); }
5961 5962 Py_DECREF(obj);
5962 5963 return;
5963 5964 }
5964 5965 }
5965 5966 elfInfoWdgt::customEvent(arg__1);
5966 5967 }
5967 5968 int PythonQtShell_elfInfoWdgt::devType() const
5968 5969 {
5969 5970 if (_wrapper) {
5970 5971 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
5971 5972 PyErr_Clear();
5972 5973 if (obj && !PythonQtSlotFunction_Check(obj)) {
5973 5974 static const char* argumentList[] ={"int"};
5974 5975 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5975 5976 int returnValue;
5976 5977 void* args[1] = {NULL};
5977 5978 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5978 5979 if (result) {
5979 5980 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5980 5981 if (args[0]!=&returnValue) {
5981 5982 if (args[0]==NULL) {
5982 5983 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
5983 5984 } else {
5984 5985 returnValue = *((int*)args[0]);
5985 5986 }
5986 5987 }
5987 5988 }
5988 5989 if (result) { Py_DECREF(result); }
5989 5990 Py_DECREF(obj);
5990 5991 return returnValue;
5991 5992 }
5992 5993 }
5993 5994 return elfInfoWdgt::devType();
5994 5995 }
5995 5996 void PythonQtShell_elfInfoWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
5996 5997 {
5997 5998 if (_wrapper) {
5998 5999 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
5999 6000 PyErr_Clear();
6000 6001 if (obj && !PythonQtSlotFunction_Check(obj)) {
6001 6002 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
6002 6003 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6003 6004 void* args[2] = {NULL, (void*)&arg__1};
6004 6005 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6005 6006 if (result) { Py_DECREF(result); }
6006 6007 Py_DECREF(obj);
6007 6008 return;
6008 6009 }
6009 6010 }
6010 6011 elfInfoWdgt::dragEnterEvent(arg__1);
6011 6012 }
6012 6013 void PythonQtShell_elfInfoWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
6013 6014 {
6014 6015 if (_wrapper) {
6015 6016 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
6016 6017 PyErr_Clear();
6017 6018 if (obj && !PythonQtSlotFunction_Check(obj)) {
6018 6019 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
6019 6020 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6020 6021 void* args[2] = {NULL, (void*)&arg__1};
6021 6022 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6022 6023 if (result) { Py_DECREF(result); }
6023 6024 Py_DECREF(obj);
6024 6025 return;
6025 6026 }
6026 6027 }
6027 6028 elfInfoWdgt::dragLeaveEvent(arg__1);
6028 6029 }
6029 6030 void PythonQtShell_elfInfoWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
6030 6031 {
6031 6032 if (_wrapper) {
6032 6033 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
6033 6034 PyErr_Clear();
6034 6035 if (obj && !PythonQtSlotFunction_Check(obj)) {
6035 6036 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
6036 6037 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6037 6038 void* args[2] = {NULL, (void*)&arg__1};
6038 6039 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6039 6040 if (result) { Py_DECREF(result); }
6040 6041 Py_DECREF(obj);
6041 6042 return;
6042 6043 }
6043 6044 }
6044 6045 elfInfoWdgt::dragMoveEvent(arg__1);
6045 6046 }
6046 6047 void PythonQtShell_elfInfoWdgt::dropEvent(QDropEvent* arg__1)
6047 6048 {
6048 6049 if (_wrapper) {
6049 6050 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
6050 6051 PyErr_Clear();
6051 6052 if (obj && !PythonQtSlotFunction_Check(obj)) {
6052 6053 static const char* argumentList[] ={"" , "QDropEvent*"};
6053 6054 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6054 6055 void* args[2] = {NULL, (void*)&arg__1};
6055 6056 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6056 6057 if (result) { Py_DECREF(result); }
6057 6058 Py_DECREF(obj);
6058 6059 return;
6059 6060 }
6060 6061 }
6061 6062 elfInfoWdgt::dropEvent(arg__1);
6062 6063 }
6063 6064 void PythonQtShell_elfInfoWdgt::enterEvent(QEvent* arg__1)
6064 6065 {
6065 6066 if (_wrapper) {
6066 6067 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
6067 6068 PyErr_Clear();
6068 6069 if (obj && !PythonQtSlotFunction_Check(obj)) {
6069 6070 static const char* argumentList[] ={"" , "QEvent*"};
6070 6071 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6071 6072 void* args[2] = {NULL, (void*)&arg__1};
6072 6073 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6073 6074 if (result) { Py_DECREF(result); }
6074 6075 Py_DECREF(obj);
6075 6076 return;
6076 6077 }
6077 6078 }
6078 6079 elfInfoWdgt::enterEvent(arg__1);
6079 6080 }
6080 6081 bool PythonQtShell_elfInfoWdgt::event(QEvent* arg__1)
6081 6082 {
6082 6083 if (_wrapper) {
6083 6084 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
6084 6085 PyErr_Clear();
6085 6086 if (obj && !PythonQtSlotFunction_Check(obj)) {
6086 6087 static const char* argumentList[] ={"bool" , "QEvent*"};
6087 6088 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6088 6089 bool returnValue;
6089 6090 void* args[2] = {NULL, (void*)&arg__1};
6090 6091 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6091 6092 if (result) {
6092 6093 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6093 6094 if (args[0]!=&returnValue) {
6094 6095 if (args[0]==NULL) {
6095 6096 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
6096 6097 } else {
6097 6098 returnValue = *((bool*)args[0]);
6098 6099 }
6099 6100 }
6100 6101 }
6101 6102 if (result) { Py_DECREF(result); }
6102 6103 Py_DECREF(obj);
6103 6104 return returnValue;
6104 6105 }
6105 6106 }
6106 6107 return elfInfoWdgt::event(arg__1);
6107 6108 }
6108 6109 bool PythonQtShell_elfInfoWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
6109 6110 {
6110 6111 if (_wrapper) {
6111 6112 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
6112 6113 PyErr_Clear();
6113 6114 if (obj && !PythonQtSlotFunction_Check(obj)) {
6114 6115 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
6115 6116 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
6116 6117 bool returnValue;
6117 6118 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
6118 6119 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6119 6120 if (result) {
6120 6121 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6121 6122 if (args[0]!=&returnValue) {
6122 6123 if (args[0]==NULL) {
6123 6124 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
6124 6125 } else {
6125 6126 returnValue = *((bool*)args[0]);
6126 6127 }
6127 6128 }
6128 6129 }
6129 6130 if (result) { Py_DECREF(result); }
6130 6131 Py_DECREF(obj);
6131 6132 return returnValue;
6132 6133 }
6133 6134 }
6134 6135 return elfInfoWdgt::eventFilter(arg__1, arg__2);
6135 6136 }
6136 6137 void PythonQtShell_elfInfoWdgt::focusInEvent(QFocusEvent* arg__1)
6137 6138 {
6138 6139 if (_wrapper) {
6139 6140 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
6140 6141 PyErr_Clear();
6141 6142 if (obj && !PythonQtSlotFunction_Check(obj)) {
6142 6143 static const char* argumentList[] ={"" , "QFocusEvent*"};
6143 6144 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6144 6145 void* args[2] = {NULL, (void*)&arg__1};
6145 6146 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6146 6147 if (result) { Py_DECREF(result); }
6147 6148 Py_DECREF(obj);
6148 6149 return;
6149 6150 }
6150 6151 }
6151 6152 elfInfoWdgt::focusInEvent(arg__1);
6152 6153 }
6153 6154 bool PythonQtShell_elfInfoWdgt::focusNextPrevChild(bool next)
6154 6155 {
6155 6156 if (_wrapper) {
6156 6157 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
6157 6158 PyErr_Clear();
6158 6159 if (obj && !PythonQtSlotFunction_Check(obj)) {
6159 6160 static const char* argumentList[] ={"bool" , "bool"};
6160 6161 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6161 6162 bool returnValue;
6162 6163 void* args[2] = {NULL, (void*)&next};
6163 6164 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6164 6165 if (result) {
6165 6166 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6166 6167 if (args[0]!=&returnValue) {
6167 6168 if (args[0]==NULL) {
6168 6169 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
6169 6170 } else {
6170 6171 returnValue = *((bool*)args[0]);
6171 6172 }
6172 6173 }
6173 6174 }
6174 6175 if (result) { Py_DECREF(result); }
6175 6176 Py_DECREF(obj);
6176 6177 return returnValue;
6177 6178 }
6178 6179 }
6179 6180 return elfInfoWdgt::focusNextPrevChild(next);
6180 6181 }
6181 6182 void PythonQtShell_elfInfoWdgt::focusOutEvent(QFocusEvent* arg__1)
6182 6183 {
6183 6184 if (_wrapper) {
6184 6185 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
6185 6186 PyErr_Clear();
6186 6187 if (obj && !PythonQtSlotFunction_Check(obj)) {
6187 6188 static const char* argumentList[] ={"" , "QFocusEvent*"};
6188 6189 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6189 6190 void* args[2] = {NULL, (void*)&arg__1};
6190 6191 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6191 6192 if (result) { Py_DECREF(result); }
6192 6193 Py_DECREF(obj);
6193 6194 return;
6194 6195 }
6195 6196 }
6196 6197 elfInfoWdgt::focusOutEvent(arg__1);
6197 6198 }
6198 6199 bool PythonQtShell_elfInfoWdgt::hasHeightForWidth() const
6199 6200 {
6200 6201 if (_wrapper) {
6201 6202 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
6202 6203 PyErr_Clear();
6203 6204 if (obj && !PythonQtSlotFunction_Check(obj)) {
6204 6205 static const char* argumentList[] ={"bool"};
6205 6206 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6206 6207 bool returnValue;
6207 6208 void* args[1] = {NULL};
6208 6209 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6209 6210 if (result) {
6210 6211 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6211 6212 if (args[0]!=&returnValue) {
6212 6213 if (args[0]==NULL) {
6213 6214 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
6214 6215 } else {
6215 6216 returnValue = *((bool*)args[0]);
6216 6217 }
6217 6218 }
6218 6219 }
6219 6220 if (result) { Py_DECREF(result); }
6220 6221 Py_DECREF(obj);
6221 6222 return returnValue;
6222 6223 }
6223 6224 }
6224 6225 return elfInfoWdgt::hasHeightForWidth();
6225 6226 }
6226 6227 int PythonQtShell_elfInfoWdgt::heightForWidth(int arg__1) const
6227 6228 {
6228 6229 if (_wrapper) {
6229 6230 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
6230 6231 PyErr_Clear();
6231 6232 if (obj && !PythonQtSlotFunction_Check(obj)) {
6232 6233 static const char* argumentList[] ={"int" , "int"};
6233 6234 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6234 6235 int returnValue;
6235 6236 void* args[2] = {NULL, (void*)&arg__1};
6236 6237 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6237 6238 if (result) {
6238 6239 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6239 6240 if (args[0]!=&returnValue) {
6240 6241 if (args[0]==NULL) {
6241 6242 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
6242 6243 } else {
6243 6244 returnValue = *((int*)args[0]);
6244 6245 }
6245 6246 }
6246 6247 }
6247 6248 if (result) { Py_DECREF(result); }
6248 6249 Py_DECREF(obj);
6249 6250 return returnValue;
6250 6251 }
6251 6252 }
6252 6253 return elfInfoWdgt::heightForWidth(arg__1);
6253 6254 }
6254 6255 void PythonQtShell_elfInfoWdgt::hideEvent(QHideEvent* arg__1)
6255 6256 {
6256 6257 if (_wrapper) {
6257 6258 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
6258 6259 PyErr_Clear();
6259 6260 if (obj && !PythonQtSlotFunction_Check(obj)) {
6260 6261 static const char* argumentList[] ={"" , "QHideEvent*"};
6261 6262 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6262 6263 void* args[2] = {NULL, (void*)&arg__1};
6263 6264 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6264 6265 if (result) { Py_DECREF(result); }
6265 6266 Py_DECREF(obj);
6266 6267 return;
6267 6268 }
6268 6269 }
6269 6270 elfInfoWdgt::hideEvent(arg__1);
6270 6271 }
6271 6272 void PythonQtShell_elfInfoWdgt::initPainter(QPainter* painter) const
6272 6273 {
6273 6274 if (_wrapper) {
6274 6275 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
6275 6276 PyErr_Clear();
6276 6277 if (obj && !PythonQtSlotFunction_Check(obj)) {
6277 6278 static const char* argumentList[] ={"" , "QPainter*"};
6278 6279 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6279 6280 void* args[2] = {NULL, (void*)&painter};
6280 6281 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6281 6282 if (result) { Py_DECREF(result); }
6282 6283 Py_DECREF(obj);
6283 6284 return;
6284 6285 }
6285 6286 }
6286 6287 elfInfoWdgt::initPainter(painter);
6287 6288 }
6288 6289 void PythonQtShell_elfInfoWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
6289 6290 {
6290 6291 if (_wrapper) {
6291 6292 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
6292 6293 PyErr_Clear();
6293 6294 if (obj && !PythonQtSlotFunction_Check(obj)) {
6294 6295 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
6295 6296 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6296 6297 void* args[2] = {NULL, (void*)&arg__1};
6297 6298 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6298 6299 if (result) { Py_DECREF(result); }
6299 6300 Py_DECREF(obj);
6300 6301 return;
6301 6302 }
6302 6303 }
6303 6304 elfInfoWdgt::inputMethodEvent(arg__1);
6304 6305 }
6305 6306 QVariant PythonQtShell_elfInfoWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
6306 6307 {
6307 6308 if (_wrapper) {
6308 6309 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
6309 6310 PyErr_Clear();
6310 6311 if (obj && !PythonQtSlotFunction_Check(obj)) {
6311 6312 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
6312 6313 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6313 6314 QVariant returnValue;
6314 6315 void* args[2] = {NULL, (void*)&arg__1};
6315 6316 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6316 6317 if (result) {
6317 6318 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6318 6319 if (args[0]!=&returnValue) {
6319 6320 if (args[0]==NULL) {
6320 6321 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
6321 6322 } else {
6322 6323 returnValue = *((QVariant*)args[0]);
6323 6324 }
6324 6325 }
6325 6326 }
6326 6327 if (result) { Py_DECREF(result); }
6327 6328 Py_DECREF(obj);
6328 6329 return returnValue;
6329 6330 }
6330 6331 }
6331 6332 return elfInfoWdgt::inputMethodQuery(arg__1);
6332 6333 }
6333 6334 void PythonQtShell_elfInfoWdgt::keyPressEvent(QKeyEvent* arg__1)
6334 6335 {
6335 6336 if (_wrapper) {
6336 6337 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
6337 6338 PyErr_Clear();
6338 6339 if (obj && !PythonQtSlotFunction_Check(obj)) {
6339 6340 static const char* argumentList[] ={"" , "QKeyEvent*"};
6340 6341 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6341 6342 void* args[2] = {NULL, (void*)&arg__1};
6342 6343 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6343 6344 if (result) { Py_DECREF(result); }
6344 6345 Py_DECREF(obj);
6345 6346 return;
6346 6347 }
6347 6348 }
6348 6349 elfInfoWdgt::keyPressEvent(arg__1);
6349 6350 }
6350 6351 void PythonQtShell_elfInfoWdgt::keyReleaseEvent(QKeyEvent* arg__1)
6351 6352 {
6352 6353 if (_wrapper) {
6353 6354 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
6354 6355 PyErr_Clear();
6355 6356 if (obj && !PythonQtSlotFunction_Check(obj)) {
6356 6357 static const char* argumentList[] ={"" , "QKeyEvent*"};
6357 6358 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6358 6359 void* args[2] = {NULL, (void*)&arg__1};
6359 6360 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6360 6361 if (result) { Py_DECREF(result); }
6361 6362 Py_DECREF(obj);
6362 6363 return;
6363 6364 }
6364 6365 }
6365 6366 elfInfoWdgt::keyReleaseEvent(arg__1);
6366 6367 }
6367 6368 void PythonQtShell_elfInfoWdgt::leaveEvent(QEvent* arg__1)
6368 6369 {
6369 6370 if (_wrapper) {
6370 6371 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
6371 6372 PyErr_Clear();
6372 6373 if (obj && !PythonQtSlotFunction_Check(obj)) {
6373 6374 static const char* argumentList[] ={"" , "QEvent*"};
6374 6375 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6375 6376 void* args[2] = {NULL, (void*)&arg__1};
6376 6377 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6377 6378 if (result) { Py_DECREF(result); }
6378 6379 Py_DECREF(obj);
6379 6380 return;
6380 6381 }
6381 6382 }
6382 6383 elfInfoWdgt::leaveEvent(arg__1);
6383 6384 }
6384 6385 int PythonQtShell_elfInfoWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
6385 6386 {
6386 6387 if (_wrapper) {
6387 6388 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
6388 6389 PyErr_Clear();
6389 6390 if (obj && !PythonQtSlotFunction_Check(obj)) {
6390 6391 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
6391 6392 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6392 6393 int returnValue;
6393 6394 void* args[2] = {NULL, (void*)&arg__1};
6394 6395 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6395 6396 if (result) {
6396 6397 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6397 6398 if (args[0]!=&returnValue) {
6398 6399 if (args[0]==NULL) {
6399 6400 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
6400 6401 } else {
6401 6402 returnValue = *((int*)args[0]);
6402 6403 }
6403 6404 }
6404 6405 }
6405 6406 if (result) { Py_DECREF(result); }
6406 6407 Py_DECREF(obj);
6407 6408 return returnValue;
6408 6409 }
6409 6410 }
6410 6411 return elfInfoWdgt::metric(arg__1);
6411 6412 }
6412 6413 QSize PythonQtShell_elfInfoWdgt::minimumSizeHint() const
6413 6414 {
6414 6415 if (_wrapper) {
6415 6416 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
6416 6417 PyErr_Clear();
6417 6418 if (obj && !PythonQtSlotFunction_Check(obj)) {
6418 6419 static const char* argumentList[] ={"QSize"};
6419 6420 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6420 6421 QSize returnValue;
6421 6422 void* args[1] = {NULL};
6422 6423 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6423 6424 if (result) {
6424 6425 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6425 6426 if (args[0]!=&returnValue) {
6426 6427 if (args[0]==NULL) {
6427 6428 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
6428 6429 } else {
6429 6430 returnValue = *((QSize*)args[0]);
6430 6431 }
6431 6432 }
6432 6433 }
6433 6434 if (result) { Py_DECREF(result); }
6434 6435 Py_DECREF(obj);
6435 6436 return returnValue;
6436 6437 }
6437 6438 }
6438 6439 return elfInfoWdgt::minimumSizeHint();
6439 6440 }
6440 6441 void PythonQtShell_elfInfoWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
6441 6442 {
6442 6443 if (_wrapper) {
6443 6444 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
6444 6445 PyErr_Clear();
6445 6446 if (obj && !PythonQtSlotFunction_Check(obj)) {
6446 6447 static const char* argumentList[] ={"" , "QMouseEvent*"};
6447 6448 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6448 6449 void* args[2] = {NULL, (void*)&arg__1};
6449 6450 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6450 6451 if (result) { Py_DECREF(result); }
6451 6452 Py_DECREF(obj);
6452 6453 return;
6453 6454 }
6454 6455 }
6455 6456 elfInfoWdgt::mouseDoubleClickEvent(arg__1);
6456 6457 }
6457 6458 void PythonQtShell_elfInfoWdgt::mouseMoveEvent(QMouseEvent* arg__1)
6458 6459 {
6459 6460 if (_wrapper) {
6460 6461 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
6461 6462 PyErr_Clear();
6462 6463 if (obj && !PythonQtSlotFunction_Check(obj)) {
6463 6464 static const char* argumentList[] ={"" , "QMouseEvent*"};
6464 6465 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6465 6466 void* args[2] = {NULL, (void*)&arg__1};
6466 6467 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6467 6468 if (result) { Py_DECREF(result); }
6468 6469 Py_DECREF(obj);
6469 6470 return;
6470 6471 }
6471 6472 }
6472 6473 elfInfoWdgt::mouseMoveEvent(arg__1);
6473 6474 }
6474 6475 void PythonQtShell_elfInfoWdgt::mousePressEvent(QMouseEvent* arg__1)
6475 6476 {
6476 6477 if (_wrapper) {
6477 6478 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
6478 6479 PyErr_Clear();
6479 6480 if (obj && !PythonQtSlotFunction_Check(obj)) {
6480 6481 static const char* argumentList[] ={"" , "QMouseEvent*"};
6481 6482 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6482 6483 void* args[2] = {NULL, (void*)&arg__1};
6483 6484 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6484 6485 if (result) { Py_DECREF(result); }
6485 6486 Py_DECREF(obj);
6486 6487 return;
6487 6488 }
6488 6489 }
6489 6490 elfInfoWdgt::mousePressEvent(arg__1);
6490 6491 }
6491 6492 void PythonQtShell_elfInfoWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
6492 6493 {
6493 6494 if (_wrapper) {
6494 6495 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
6495 6496 PyErr_Clear();
6496 6497 if (obj && !PythonQtSlotFunction_Check(obj)) {
6497 6498 static const char* argumentList[] ={"" , "QMouseEvent*"};
6498 6499 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6499 6500 void* args[2] = {NULL, (void*)&arg__1};
6500 6501 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6501 6502 if (result) { Py_DECREF(result); }
6502 6503 Py_DECREF(obj);
6503 6504 return;
6504 6505 }
6505 6506 }
6506 6507 elfInfoWdgt::mouseReleaseEvent(arg__1);
6507 6508 }
6508 6509 void PythonQtShell_elfInfoWdgt::moveEvent(QMoveEvent* arg__1)
6509 6510 {
6510 6511 if (_wrapper) {
6511 6512 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
6512 6513 PyErr_Clear();
6513 6514 if (obj && !PythonQtSlotFunction_Check(obj)) {
6514 6515 static const char* argumentList[] ={"" , "QMoveEvent*"};
6515 6516 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6516 6517 void* args[2] = {NULL, (void*)&arg__1};
6517 6518 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6518 6519 if (result) { Py_DECREF(result); }
6519 6520 Py_DECREF(obj);
6520 6521 return;
6521 6522 }
6522 6523 }
6523 6524 elfInfoWdgt::moveEvent(arg__1);
6524 6525 }
6525 6526 bool PythonQtShell_elfInfoWdgt::nativeEvent(const QByteArray& eventType, void* message, long* result)
6526 6527 {
6527 6528 if (_wrapper) {
6528 6529 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
6529 6530 PyErr_Clear();
6530 6531 if (obj && !PythonQtSlotFunction_Check(obj)) {
6531 6532 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
6532 6533 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
6533 6534 bool returnValue;
6534 6535 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
6535 6536 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6536 6537 if (result) {
6537 6538 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6538 6539 if (args[0]!=&returnValue) {
6539 6540 if (args[0]==NULL) {
6540 6541 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
6541 6542 } else {
6542 6543 returnValue = *((bool*)args[0]);
6543 6544 }
6544 6545 }
6545 6546 }
6546 6547 if (result) { Py_DECREF(result); }
6547 6548 Py_DECREF(obj);
6548 6549 return returnValue;
6549 6550 }
6550 6551 }
6551 6552 return elfInfoWdgt::nativeEvent(eventType, message, result);
6552 6553 }
6553 6554 QPaintEngine* PythonQtShell_elfInfoWdgt::paintEngine() const
6554 6555 {
6555 6556 if (_wrapper) {
6556 6557 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
6557 6558 PyErr_Clear();
6558 6559 if (obj && !PythonQtSlotFunction_Check(obj)) {
6559 6560 static const char* argumentList[] ={"QPaintEngine*"};
6560 6561 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6561 6562 QPaintEngine* returnValue;
6562 6563 void* args[1] = {NULL};
6563 6564 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6564 6565 if (result) {
6565 6566 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6566 6567 if (args[0]!=&returnValue) {
6567 6568 if (args[0]==NULL) {
6568 6569 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
6569 6570 } else {
6570 6571 returnValue = *((QPaintEngine**)args[0]);
6571 6572 }
6572 6573 }
6573 6574 }
6574 6575 if (result) { Py_DECREF(result); }
6575 6576 Py_DECREF(obj);
6576 6577 return returnValue;
6577 6578 }
6578 6579 }
6579 6580 return elfInfoWdgt::paintEngine();
6580 6581 }
6581 6582 void PythonQtShell_elfInfoWdgt::paintEvent(QPaintEvent* arg__1)
6582 6583 {
6583 6584 if (_wrapper) {
6584 6585 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
6585 6586 PyErr_Clear();
6586 6587 if (obj && !PythonQtSlotFunction_Check(obj)) {
6587 6588 static const char* argumentList[] ={"" , "QPaintEvent*"};
6588 6589 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6589 6590 void* args[2] = {NULL, (void*)&arg__1};
6590 6591 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6591 6592 if (result) { Py_DECREF(result); }
6592 6593 Py_DECREF(obj);
6593 6594 return;
6594 6595 }
6595 6596 }
6596 6597 elfInfoWdgt::paintEvent(arg__1);
6597 6598 }
6598 6599 QPaintDevice* PythonQtShell_elfInfoWdgt::redirected(QPoint* offset) const
6599 6600 {
6600 6601 if (_wrapper) {
6601 6602 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
6602 6603 PyErr_Clear();
6603 6604 if (obj && !PythonQtSlotFunction_Check(obj)) {
6604 6605 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
6605 6606 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6606 6607 QPaintDevice* returnValue;
6607 6608 void* args[2] = {NULL, (void*)&offset};
6608 6609 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6609 6610 if (result) {
6610 6611 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6611 6612 if (args[0]!=&returnValue) {
6612 6613 if (args[0]==NULL) {
6613 6614 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
6614 6615 } else {
6615 6616 returnValue = *((QPaintDevice**)args[0]);
6616 6617 }
6617 6618 }
6618 6619 }
6619 6620 if (result) { Py_DECREF(result); }
6620 6621 Py_DECREF(obj);
6621 6622 return returnValue;
6622 6623 }
6623 6624 }
6624 6625 return elfInfoWdgt::redirected(offset);
6625 6626 }
6626 6627 void PythonQtShell_elfInfoWdgt::resizeEvent(QResizeEvent* arg__1)
6627 6628 {
6628 6629 if (_wrapper) {
6629 6630 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
6630 6631 PyErr_Clear();
6631 6632 if (obj && !PythonQtSlotFunction_Check(obj)) {
6632 6633 static const char* argumentList[] ={"" , "QResizeEvent*"};
6633 6634 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6634 6635 void* args[2] = {NULL, (void*)&arg__1};
6635 6636 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6636 6637 if (result) { Py_DECREF(result); }
6637 6638 Py_DECREF(obj);
6638 6639 return;
6639 6640 }
6640 6641 }
6641 6642 elfInfoWdgt::resizeEvent(arg__1);
6642 6643 }
6643 6644 QPainter* PythonQtShell_elfInfoWdgt::sharedPainter() const
6644 6645 {
6645 6646 if (_wrapper) {
6646 6647 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
6647 6648 PyErr_Clear();
6648 6649 if (obj && !PythonQtSlotFunction_Check(obj)) {
6649 6650 static const char* argumentList[] ={"QPainter*"};
6650 6651 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6651 6652 QPainter* returnValue;
6652 6653 void* args[1] = {NULL};
6653 6654 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6654 6655 if (result) {
6655 6656 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6656 6657 if (args[0]!=&returnValue) {
6657 6658 if (args[0]==NULL) {
6658 6659 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
6659 6660 } else {
6660 6661 returnValue = *((QPainter**)args[0]);
6661 6662 }
6662 6663 }
6663 6664 }
6664 6665 if (result) { Py_DECREF(result); }
6665 6666 Py_DECREF(obj);
6666 6667 return returnValue;
6667 6668 }
6668 6669 }
6669 6670 return elfInfoWdgt::sharedPainter();
6670 6671 }
6671 6672 void PythonQtShell_elfInfoWdgt::showEvent(QShowEvent* arg__1)
6672 6673 {
6673 6674 if (_wrapper) {
6674 6675 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
6675 6676 PyErr_Clear();
6676 6677 if (obj && !PythonQtSlotFunction_Check(obj)) {
6677 6678 static const char* argumentList[] ={"" , "QShowEvent*"};
6678 6679 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6679 6680 void* args[2] = {NULL, (void*)&arg__1};
6680 6681 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6681 6682 if (result) { Py_DECREF(result); }
6682 6683 Py_DECREF(obj);
6683 6684 return;
6684 6685 }
6685 6686 }
6686 6687 elfInfoWdgt::showEvent(arg__1);
6687 6688 }
6688 6689 QSize PythonQtShell_elfInfoWdgt::sizeHint() const
6689 6690 {
6690 6691 if (_wrapper) {
6691 6692 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
6692 6693 PyErr_Clear();
6693 6694 if (obj && !PythonQtSlotFunction_Check(obj)) {
6694 6695 static const char* argumentList[] ={"QSize"};
6695 6696 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6696 6697 QSize returnValue;
6697 6698 void* args[1] = {NULL};
6698 6699 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6699 6700 if (result) {
6700 6701 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6701 6702 if (args[0]!=&returnValue) {
6702 6703 if (args[0]==NULL) {
6703 6704 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
6704 6705 } else {
6705 6706 returnValue = *((QSize*)args[0]);
6706 6707 }
6707 6708 }
6708 6709 }
6709 6710 if (result) { Py_DECREF(result); }
6710 6711 Py_DECREF(obj);
6711 6712 return returnValue;
6712 6713 }
6713 6714 }
6714 6715 return elfInfoWdgt::sizeHint();
6715 6716 }
6716 6717 void PythonQtShell_elfInfoWdgt::tabletEvent(QTabletEvent* arg__1)
6717 6718 {
6718 6719 if (_wrapper) {
6719 6720 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
6720 6721 PyErr_Clear();
6721 6722 if (obj && !PythonQtSlotFunction_Check(obj)) {
6722 6723 static const char* argumentList[] ={"" , "QTabletEvent*"};
6723 6724 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6724 6725 void* args[2] = {NULL, (void*)&arg__1};
6725 6726 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6726 6727 if (result) { Py_DECREF(result); }
6727 6728 Py_DECREF(obj);
6728 6729 return;
6729 6730 }
6730 6731 }
6731 6732 elfInfoWdgt::tabletEvent(arg__1);
6732 6733 }
6733 6734 void PythonQtShell_elfInfoWdgt::timerEvent(QTimerEvent* arg__1)
6734 6735 {
6735 6736 if (_wrapper) {
6736 6737 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
6737 6738 PyErr_Clear();
6738 6739 if (obj && !PythonQtSlotFunction_Check(obj)) {
6739 6740 static const char* argumentList[] ={"" , "QTimerEvent*"};
6740 6741 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6741 6742 void* args[2] = {NULL, (void*)&arg__1};
6742 6743 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6743 6744 if (result) { Py_DECREF(result); }
6744 6745 Py_DECREF(obj);
6745 6746 return;
6746 6747 }
6747 6748 }
6748 6749 elfInfoWdgt::timerEvent(arg__1);
6749 6750 }
6750 6751 void PythonQtShell_elfInfoWdgt::wheelEvent(QWheelEvent* arg__1)
6751 6752 {
6752 6753 if (_wrapper) {
6753 6754 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
6754 6755 PyErr_Clear();
6755 6756 if (obj && !PythonQtSlotFunction_Check(obj)) {
6756 6757 static const char* argumentList[] ={"" , "QWheelEvent*"};
6757 6758 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6758 6759 void* args[2] = {NULL, (void*)&arg__1};
6759 6760 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6760 6761 if (result) { Py_DECREF(result); }
6761 6762 Py_DECREF(obj);
6762 6763 return;
6763 6764 }
6764 6765 }
6765 6766 elfInfoWdgt::wheelEvent(arg__1);
6766 6767 }
6767 6768 elfInfoWdgt* PythonQtWrapper_elfInfoWdgt::new_elfInfoWdgt(QWidget* parent)
6768 6769 {
6769 6770 return new PythonQtShell_elfInfoWdgt(parent); }
6770 6771
6771 6772
6772 6773
6773 6774 elfparser* PythonQtWrapper_elfparser::new_elfparser()
6774 6775 {
6775 6776 return new elfparser(); }
6776 6777
6777 6778 int PythonQtWrapper_elfparser::closeFile(elfparser* theWrappedObject)
6778 6779 {
6779 6780 return ( theWrappedObject->closeFile());
6780 6781 }
6781 6782
6782 6783 QString PythonQtWrapper_elfparser::getABI(elfparser* theWrappedObject)
6783 6784 {
6784 6785 return ( theWrappedObject->getABI());
6785 6786 }
6786 6787
6787 6788 QString PythonQtWrapper_elfparser::getArchitecture(elfparser* theWrappedObject)
6788 6789 {
6789 6790 return ( theWrappedObject->getArchitecture());
6790 6791 }
6791 6792
6792 6793 QString PythonQtWrapper_elfparser::getClass(elfparser* theWrappedObject)
6793 6794 {
6794 6795 return ( theWrappedObject->getClass());
6795 6796 }
6796 6797
6797 6798 QString PythonQtWrapper_elfparser::getEndianness(elfparser* theWrappedObject)
6798 6799 {
6799 6800 return ( theWrappedObject->getEndianness());
6800 6801 }
6801 6802
6802 6803 qint64 PythonQtWrapper_elfparser::getEntryPointAddress(elfparser* theWrappedObject)
6803 6804 {
6804 6805 return ( theWrappedObject->getEntryPointAddress());
6805 6806 }
6806 6807
6807 6808 bool PythonQtWrapper_elfparser::getSectionData(elfparser* theWrappedObject, int index, char** buffer)
6808 6809 {
6809 6810 return ( theWrappedObject->getSectionData(index, buffer));
6810 6811 }
6811 6812
6812 6813 qint64 PythonQtWrapper_elfparser::getSectionDatasz(elfparser* theWrappedObject, int index)
6813 6814 {
6814 6815 return ( theWrappedObject->getSectionDatasz(index));
6815 6816 }
6816 6817
6817 6818 qint64 PythonQtWrapper_elfparser::getSectionMemsz(elfparser* theWrappedObject, int index)
6818 6819 {
6819 6820 return ( theWrappedObject->getSectionMemsz(index));
6820 6821 }
6821 6822
6822 6823 QString PythonQtWrapper_elfparser::getSectionName(elfparser* theWrappedObject, int index)
6823 6824 {
6824 6825 return ( theWrappedObject->getSectionName(index));
6825 6826 }
6826 6827
6827 6828 qint64 PythonQtWrapper_elfparser::getSectionPaddr(elfparser* theWrappedObject, int index)
6828 6829 {
6829 6830 return ( theWrappedObject->getSectionPaddr(index));
6830 6831 }
6831 6832
6832 6833 QString PythonQtWrapper_elfparser::getSectionType(elfparser* theWrappedObject, int index)
6833 6834 {
6834 6835 return ( theWrappedObject->getSectionType(index));
6835 6836 }
6836 6837
6837 6838 int PythonQtWrapper_elfparser::getSectioncount(elfparser* theWrappedObject)
6838 6839 {
6839 6840 return ( theWrappedObject->getSectioncount());
6840 6841 }
6841 6842
6842 6843 qint64 PythonQtWrapper_elfparser::getSegmentFilesz(elfparser* theWrappedObject, int index)
6843 6844 {
6844 6845 return ( theWrappedObject->getSegmentFilesz(index));
6845 6846 }
6846 6847
6847 6848 QString PythonQtWrapper_elfparser::getSegmentFlags(elfparser* theWrappedObject, int index)
6848 6849 {
6849 6850 return ( theWrappedObject->getSegmentFlags(index));
6850 6851 }
6851 6852
6852 6853 qint64 PythonQtWrapper_elfparser::getSegmentMemsz(elfparser* theWrappedObject, int index)
6853 6854 {
6854 6855 return ( theWrappedObject->getSegmentMemsz(index));
6855 6856 }
6856 6857
6857 6858 qint64 PythonQtWrapper_elfparser::getSegmentOffset(elfparser* theWrappedObject, int index)
6858 6859 {
6859 6860 return ( theWrappedObject->getSegmentOffset(index));
6860 6861 }
6861 6862
6862 6863 qint64 PythonQtWrapper_elfparser::getSegmentPaddr(elfparser* theWrappedObject, int index)
6863 6864 {
6864 6865 return ( theWrappedObject->getSegmentPaddr(index));
6865 6866 }
6866 6867
6867 6868 QString PythonQtWrapper_elfparser::getSegmentType(elfparser* theWrappedObject, int index)
6868 6869 {
6869 6870 return ( theWrappedObject->getSegmentType(index));
6870 6871 }
6871 6872
6872 6873 qint64 PythonQtWrapper_elfparser::getSegmentVaddr(elfparser* theWrappedObject, int index)
6873 6874 {
6874 6875 return ( theWrappedObject->getSegmentVaddr(index));
6875 6876 }
6876 6877
6877 6878 int PythonQtWrapper_elfparser::getSegmentcount(elfparser* theWrappedObject)
6878 6879 {
6879 6880 return ( theWrappedObject->getSegmentcount());
6880 6881 }
6881 6882
6882 6883 QString PythonQtWrapper_elfparser::getType(elfparser* theWrappedObject)
6883 6884 {
6884 6885 return ( theWrappedObject->getType());
6885 6886 }
6886 6887
6887 6888 qint64 PythonQtWrapper_elfparser::getVersion(elfparser* theWrappedObject)
6888 6889 {
6889 6890 return ( theWrappedObject->getVersion());
6890 6891 }
6891 6892
6892 6893 bool PythonQtWrapper_elfparser::static_elfparser_isElf(const QString& File)
6893 6894 {
6894 6895 return (elfparser::isElf(File));
6895 6896 }
6896 6897
6897 6898 bool PythonQtWrapper_elfparser::iself(elfparser* theWrappedObject)
6898 6899 {
6899 6900 return ( theWrappedObject->iself());
6900 6901 }
6901 6902
6902 6903 bool PythonQtWrapper_elfparser::isopened(elfparser* theWrappedObject)
6903 6904 {
6904 6905 return ( theWrappedObject->isopened());
6905 6906 }
6906 6907
6907 6908 int PythonQtWrapper_elfparser::setFilename(elfparser* theWrappedObject, const QString& name)
6908 6909 {
6909 6910 return ( theWrappedObject->setFilename(name));
6910 6911 }
6911 6912
6912 6913
6914
6915 PythonQtShell_srecFile::~PythonQtShell_srecFile() {
6916 PythonQtPrivate* priv = PythonQt::priv();
6917 if (priv) { priv->shellClassDeleted(this); }
6918 }
6919 int PythonQtShell_srecFile::closeFile()
6920 {
6921 if (_wrapper) {
6922 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
6923 PyErr_Clear();
6924 if (obj && !PythonQtSlotFunction_Check(obj)) {
6925 static const char* argumentList[] ={"int"};
6926 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6927 int returnValue;
6928 void* args[1] = {NULL};
6929 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6930 if (result) {
6931 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6932 if (args[0]!=&returnValue) {
6933 if (args[0]==NULL) {
6934 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
6935 } else {
6936 returnValue = *((int*)args[0]);
6937 }
6938 }
6939 }
6940 if (result) { Py_DECREF(result); }
6941 Py_DECREF(obj);
6942 return returnValue;
6943 }
6944 }
6945 return srecFile::closeFile();
6946 }
6947 QList<codeFragment* > PythonQtShell_srecFile::getFragments()
6948 {
6949 if (_wrapper) {
6950 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
6951 PyErr_Clear();
6952 if (obj && !PythonQtSlotFunction_Check(obj)) {
6953 static const char* argumentList[] ={"QList<codeFragment* >"};
6954 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6955 QList<codeFragment* > returnValue;
6956 void* args[1] = {NULL};
6957 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6958 if (result) {
6959 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6960 if (args[0]!=&returnValue) {
6961 if (args[0]==NULL) {
6962 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
6963 } else {
6964 returnValue = *((QList<codeFragment* >*)args[0]);
6965 }
6966 }
6967 }
6968 if (result) { Py_DECREF(result); }
6969 Py_DECREF(obj);
6970 return returnValue;
6971 }
6972 }
6973 return srecFile::getFragments();
6974 }
6975 bool PythonQtShell_srecFile::isopened()
6976 {
6977 if (_wrapper) {
6978 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
6979 PyErr_Clear();
6980 if (obj && !PythonQtSlotFunction_Check(obj)) {
6981 static const char* argumentList[] ={"bool"};
6982 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6983 bool returnValue;
6984 void* args[1] = {NULL};
6985 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6986 if (result) {
6987 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6988 if (args[0]!=&returnValue) {
6989 if (args[0]==NULL) {
6990 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
6991 } else {
6992 returnValue = *((bool*)args[0]);
6993 }
6994 }
6995 }
6996 if (result) { Py_DECREF(result); }
6997 Py_DECREF(obj);
6998 return returnValue;
6999 }
7000 }
7001 return srecFile::isopened();
7002 }
7003 bool PythonQtShell_srecFile::openFile(const QString& File)
7004 {
7005 if (_wrapper) {
7006 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
7007 PyErr_Clear();
7008 if (obj && !PythonQtSlotFunction_Check(obj)) {
7009 static const char* argumentList[] ={"bool" , "const QString&"};
7010 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7011 bool returnValue;
7012 void* args[2] = {NULL, (void*)&File};
7013 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7014 if (result) {
7015 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7016 if (args[0]!=&returnValue) {
7017 if (args[0]==NULL) {
7018 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
7019 } else {
7020 returnValue = *((bool*)args[0]);
7021 }
7022 }
7023 }
7024 if (result) { Py_DECREF(result); }
7025 Py_DECREF(obj);
7026 return returnValue;
7027 }
7028 }
7029 return srecFile::openFile(File);
7030 }
7031 srecFile* PythonQtWrapper_srecFile::new_srecFile()
7032 {
7033 return new PythonQtShell_srecFile(); }
7034
7035 srecFile* PythonQtWrapper_srecFile::new_srecFile(const QString& File)
7036 {
7037 return new PythonQtShell_srecFile(File); }
7038
7039 srecFile* PythonQtWrapper_srecFile::new_srecFile(const QStringList& Files)
7040 {
7041 return new PythonQtShell_srecFile(Files); }
7042
7043 int PythonQtWrapper_srecFile::closeFile(srecFile* theWrappedObject)
7044 {
7045 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_closeFile());
7046 }
7047
7048 QList<codeFragment* > PythonQtWrapper_srecFile::getFragments(srecFile* theWrappedObject)
7049 {
7050 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_getFragments());
7051 }
7052
7053 bool PythonQtWrapper_srecFile::isopened(srecFile* theWrappedObject)
7054 {
7055 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_isopened());
7056 }
7057
7058 bool PythonQtWrapper_srecFile::openFile(srecFile* theWrappedObject, const QString& File)
7059 {
7060 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_openFile(File));
7061 }
7062
7063 bool PythonQtWrapper_srecFile::openFiles(srecFile* theWrappedObject, const QStringList& Files)
7064 {
7065 return ( theWrappedObject->openFiles(Files));
7066 }
7067
7068
Show file before | Show file after | Hide comments
@@ -1,782 +1,828
1 1 #include <PythonQt.h>
2 2 #include <QIconEngine>
3 3 #include <QObject>
4 4 #include <QSpinBox>
5 5 #include <QVariant>
6 6 #include <QWidget>
7 7 #include <SocExplorerPlot.h>
8 8 #include <abstractexecfile.h>
9 9 #include <elffile.h>
10 10 #include <elffilewidget.h>
11 11 #include <elfinfowdgt.h>
12 12 #include <elfparser.h>
13 13 #include <memsizewdgt.h>
14 14 #include <qaction.h>
15 15 #include <qbitmap.h>
16 16 #include <qbytearray.h>
17 17 #include <qcolor.h>
18 18 #include <qcoreevent.h>
19 19 #include <qcursor.h>
20 20 #include <qevent.h>
21 #include <qfile.h>
21 22 #include <qfont.h>
22 23 #include <qgraphicseffect.h>
23 24 #include <qgraphicsproxywidget.h>
24 25 #include <qhexedit.h>
25 26 #include <qhexspinbox.h>
26 27 #include <qkeysequence.h>
27 28 #include <qlayout.h>
28 29 #include <qlineedit.h>
29 30 #include <qlist.h>
30 31 #include <qlocale.h>
31 32 #include <qmargins.h>
32 33 #include <qobject.h>
33 34 #include <qpaintdevice.h>
34 35 #include <qpaintengine.h>
35 36 #include <qpainter.h>
36 37 #include <qpalette.h>
37 38 #include <qpen.h>
38 39 #include <qpixmap.h>
39 40 #include <qpoint.h>
40 41 #include <qrect.h>
41 42 #include <qregion.h>
42 43 #include <qscrollarea.h>
43 44 #include <qscrollbar.h>
44 45 #include <qsize.h>
45 46 #include <qsizepolicy.h>
46 47 #include <qspinbox.h>
47 48 #include <qstringlist.h>
48 49 #include <qstyle.h>
49 50 #include <qstyleoption.h>
50 51 #include <qwidget.h>
52 #include <srecfile.h>
51 53 #include <tcp_terminal_client.h>
52 54 #include <xbytearray.h>
53 55
54 56
55 57
56 58 class PythonQtShell_ElfFile : public ElfFile
57 59 {
58 60 public:
59 61 PythonQtShell_ElfFile():ElfFile(),_wrapper(NULL) {};
60 62 PythonQtShell_ElfFile(const QString& File):ElfFile(File),_wrapper(NULL) {};
61 63
62 64 ~PythonQtShell_ElfFile();
63 65
64 66 virtual int closeFile();
65 67 virtual QList<codeFragment* > getFragments();
66 68 virtual bool isopened();
67 69 virtual bool openFile(const QString& File);
68 70
69 71 PythonQtInstanceWrapper* _wrapper;
70 72 };
71 73
72 74 class PythonQtPublicPromoter_ElfFile : public ElfFile
73 75 { public:
74 76 inline int promoted_closeFile() { return ElfFile::closeFile(); }
75 77 inline QList<codeFragment* > promoted_getFragments() { return ElfFile::getFragments(); }
76 78 inline bool promoted_isopened() { return ElfFile::isopened(); }
77 79 inline bool promoted_openFile(const QString& File) { return ElfFile::openFile(File); }
78 80 };
79 81
80 82 class PythonQtWrapper_ElfFile : public QObject
81 83 { Q_OBJECT
82 84 public:
83 85 public slots:
84 86 ElfFile* new_ElfFile();
85 87 ElfFile* new_ElfFile(const QString& File);
86 88 void delete_ElfFile(ElfFile* obj) { delete obj; }
87 89 int closeFile(ElfFile* theWrappedObject);
88 90 QString getABI(ElfFile* theWrappedObject);
89 91 QString getArchitecture(ElfFile* theWrappedObject);
90 92 QString getClass(ElfFile* theWrappedObject);
91 93 QString getEndianness(ElfFile* theWrappedObject);
92 94 qint64 getEntryPointAddress(ElfFile* theWrappedObject);
93 95 QList<codeFragment* > getFragments(ElfFile* theWrappedObject);
94 96 QList<codeFragment* > getFragments(ElfFile* theWrappedObject, QStringList fragmentList);
95 97 int getSectionCount(ElfFile* theWrappedObject);
96 98 bool getSectionData(ElfFile* theWrappedObject, int index, char** buffer);
97 99 qint64 getSectionDatasz(ElfFile* theWrappedObject, int index);
98 100 int getSectionIndex(ElfFile* theWrappedObject, QString name);
99 101 qint64 getSectionMemsz(ElfFile* theWrappedObject, int index);
100 102 QString getSectionName(ElfFile* theWrappedObject, int index);
101 103 qint64 getSectionPaddr(ElfFile* theWrappedObject, int index);
102 104 QString getSectionType(ElfFile* theWrappedObject, int index);
103 105 int getSegmentCount(ElfFile* theWrappedObject);
104 106 qint64 getSegmentFilesz(ElfFile* theWrappedObject, int index);
105 107 QString getSegmentFlags(ElfFile* theWrappedObject, int index);
106 108 qint64 getSegmentMemsz(ElfFile* theWrappedObject, int index);
107 109 qint64 getSegmentOffset(ElfFile* theWrappedObject, int index);
108 110 qint64 getSegmentPaddr(ElfFile* theWrappedObject, int index);
109 111 QString getSegmentType(ElfFile* theWrappedObject, int index);
110 112 qint64 getSegmentVaddr(ElfFile* theWrappedObject, int index);
111 113 quint64 getSymbolAddress(ElfFile* theWrappedObject, int index);
112 114 int getSymbolCount(ElfFile* theWrappedObject);
113 115 QString getSymbolLinkType(ElfFile* theWrappedObject, int index);
114 116 QString getSymbolName(ElfFile* theWrappedObject, int index);
115 117 int getSymbolSectionIndex(ElfFile* theWrappedObject, int index);
116 118 QString getSymbolSectionName(ElfFile* theWrappedObject, int index);
117 119 quint64 getSymbolSize(ElfFile* theWrappedObject, int index);
118 120 QString getSymbolType(ElfFile* theWrappedObject, int index);
119 121 QString getType(ElfFile* theWrappedObject);
120 122 qint64 getVersion(ElfFile* theWrappedObject);
121 123 bool static_ElfFile_isElf(const QString& File);
122 124 bool iself(ElfFile* theWrappedObject);
123 125 bool isopened(ElfFile* theWrappedObject);
124 126 bool openFile(ElfFile* theWrappedObject, const QString& File);
125 127 };
126 128
127 129
128 130
129 131
130 132
131 133 class PythonQtShell_MemSizeWdgt : public MemSizeWdgt
132 134 {
133 135 public:
134 136 PythonQtShell_MemSizeWdgt(QWidget* parent = 0):MemSizeWdgt(parent),_wrapper(NULL) {};
135 137 PythonQtShell_MemSizeWdgt(int defaultSize, QWidget* parent = 0):MemSizeWdgt(defaultSize, parent),_wrapper(NULL) {};
136 138
137 139 ~PythonQtShell_MemSizeWdgt();
138 140
139 141 virtual void actionEvent(QActionEvent* arg__1);
140 142 virtual void changeEvent(QEvent* arg__1);
141 143 virtual void childEvent(QChildEvent* arg__1);
142 144 virtual void closeEvent(QCloseEvent* arg__1);
143 145 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
144 146 virtual void customEvent(QEvent* arg__1);
145 147 virtual int devType() const;
146 148 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
147 149 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
148 150 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
149 151 virtual void dropEvent(QDropEvent* arg__1);
150 152 virtual void enterEvent(QEvent* arg__1);
151 153 virtual bool event(QEvent* arg__1);
152 154 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
153 155 virtual void focusInEvent(QFocusEvent* arg__1);
154 156 virtual bool focusNextPrevChild(bool next);
155 157 virtual void focusOutEvent(QFocusEvent* arg__1);
156 158 virtual bool hasHeightForWidth() const;
157 159 virtual int heightForWidth(int arg__1) const;
158 160 virtual void hideEvent(QHideEvent* arg__1);
159 161 virtual void initPainter(QPainter* painter) const;
160 162 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
161 163 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
162 164 virtual void keyPressEvent(QKeyEvent* arg__1);
163 165 virtual void keyReleaseEvent(QKeyEvent* arg__1);
164 166 virtual void leaveEvent(QEvent* arg__1);
165 167 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
166 168 virtual QSize minimumSizeHint() const;
167 169 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
168 170 virtual void mouseMoveEvent(QMouseEvent* arg__1);
169 171 virtual void mousePressEvent(QMouseEvent* arg__1);
170 172 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
171 173 virtual void moveEvent(QMoveEvent* arg__1);
172 174 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
173 175 virtual QPaintEngine* paintEngine() const;
174 176 virtual void paintEvent(QPaintEvent* arg__1);
175 177 virtual QPaintDevice* redirected(QPoint* offset) const;
176 178 virtual void resizeEvent(QResizeEvent* arg__1);
177 179 virtual QPainter* sharedPainter() const;
178 180 virtual void showEvent(QShowEvent* arg__1);
179 181 virtual QSize sizeHint() const;
180 182 virtual void tabletEvent(QTabletEvent* arg__1);
181 183 virtual void timerEvent(QTimerEvent* arg__1);
182 184 virtual void wheelEvent(QWheelEvent* arg__1);
183 185
184 186 PythonQtInstanceWrapper* _wrapper;
185 187 };
186 188
187 189 class PythonQtWrapper_MemSizeWdgt : public QObject
188 190 { Q_OBJECT
189 191 public:
190 192 public slots:
191 193 MemSizeWdgt* new_MemSizeWdgt(QWidget* parent = 0);
192 194 MemSizeWdgt* new_MemSizeWdgt(int defaultSize, QWidget* parent = 0);
193 195 void delete_MemSizeWdgt(MemSizeWdgt* obj) { delete obj; }
194 196 int getsize(MemSizeWdgt* theWrappedObject);
195 197 void setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max);
196 198 void show(MemSizeWdgt* theWrappedObject);
197 199 void updateSizeValue(MemSizeWdgt* theWrappedObject);
198 200 };
199 201
200 202
201 203
202 204
203 205
204 206 class PythonQtShell_QHexEdit : public QHexEdit
205 207 {
206 208 public:
207 209 PythonQtShell_QHexEdit(QWidget* parent = 0):QHexEdit(parent),_wrapper(NULL) {};
208 210
209 211 ~PythonQtShell_QHexEdit();
210 212
211 213 virtual void actionEvent(QActionEvent* arg__1);
212 214 virtual void changeEvent(QEvent* arg__1);
213 215 virtual void childEvent(QChildEvent* arg__1);
214 216 virtual void closeEvent(QCloseEvent* arg__1);
215 217 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
216 218 virtual void customEvent(QEvent* arg__1);
217 219 virtual int devType() const;
218 220 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
219 221 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
220 222 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
221 223 virtual void dropEvent(QDropEvent* arg__1);
222 224 virtual void enterEvent(QEvent* arg__1);
223 225 virtual bool event(QEvent* arg__1);
224 226 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
225 227 virtual void focusInEvent(QFocusEvent* arg__1);
226 228 virtual bool focusNextPrevChild(bool next);
227 229 virtual void focusOutEvent(QFocusEvent* arg__1);
228 230 virtual bool hasHeightForWidth() const;
229 231 virtual int heightForWidth(int arg__1) const;
230 232 virtual void hideEvent(QHideEvent* arg__1);
231 233 virtual void initPainter(QPainter* painter) const;
232 234 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
233 235 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
234 236 virtual void keyPressEvent(QKeyEvent* arg__1);
235 237 virtual void keyReleaseEvent(QKeyEvent* arg__1);
236 238 virtual void leaveEvent(QEvent* arg__1);
237 239 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
238 240 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
239 241 virtual void mouseMoveEvent(QMouseEvent* arg__1);
240 242 virtual void mousePressEvent(QMouseEvent* arg__1);
241 243 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
242 244 virtual void moveEvent(QMoveEvent* arg__1);
243 245 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
244 246 virtual QPaintEngine* paintEngine() const;
245 247 virtual void paintEvent(QPaintEvent* arg__1);
246 248 virtual QPaintDevice* redirected(QPoint* offset) const;
247 249 virtual void resizeEvent(QResizeEvent* arg__1);
248 250 virtual void scrollContentsBy(int dx, int dy);
249 251 virtual void setupViewport(QWidget* viewport);
250 252 virtual QPainter* sharedPainter() const;
251 253 virtual void showEvent(QShowEvent* arg__1);
252 254 virtual void tabletEvent(QTabletEvent* arg__1);
253 255 virtual void timerEvent(QTimerEvent* arg__1);
254 256 virtual bool viewportEvent(QEvent* arg__1);
255 257 virtual QSize viewportSizeHint() const;
256 258 virtual void wheelEvent(QWheelEvent* arg__1);
257 259
258 260 PythonQtInstanceWrapper* _wrapper;
259 261 };
260 262
261 263 class PythonQtWrapper_QHexEdit : public QObject
262 264 { Q_OBJECT
263 265 public:
264 266 public slots:
265 267 QHexEdit* new_QHexEdit(QWidget* parent = 0);
266 268 void delete_QHexEdit(QHexEdit* obj) { delete obj; }
267 269 QColor addressAreaColor(QHexEdit* theWrappedObject);
268 270 int addressOffset(QHexEdit* theWrappedObject);
269 271 int cursorPosition(QHexEdit* theWrappedObject);
270 272 QByteArray data(QHexEdit* theWrappedObject);
271 273 const QFont* font(QHexEdit* theWrappedObject) const;
272 274 QColor highlightingColor(QHexEdit* theWrappedObject);
273 275 int indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
274 276 void insert(QHexEdit* theWrappedObject, int i, char ch);
275 277 void insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba);
276 278 bool isReadOnly(QHexEdit* theWrappedObject);
277 279 int lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
278 280 bool overwriteMode(QHexEdit* theWrappedObject);
279 281 void remove(QHexEdit* theWrappedObject, int pos, int len = 1);
280 282 void replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after);
281 283 QColor selectionColor(QHexEdit* theWrappedObject);
282 284 QString selectionToReadableString(QHexEdit* theWrappedObject);
283 285 void setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color);
284 286 void setAddressOffset(QHexEdit* theWrappedObject, int offset);
285 287 void setCursorPosition(QHexEdit* theWrappedObject, int cusorPos);
286 288 void setData(QHexEdit* theWrappedObject, const QByteArray& data);
287 289 void setFont(QHexEdit* theWrappedObject, const QFont& arg__1);
288 290 void setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color);
289 291 void setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1);
290 292 void setReadOnly(QHexEdit* theWrappedObject, bool arg__1);
291 293 void setSelectionColor(QHexEdit* theWrappedObject, const QColor& color);
292 294 QString toReadableString(QHexEdit* theWrappedObject);
293 295 };
294 296
295 297
296 298
297 299
298 300
299 301 class PythonQtShell_QHexSpinBox : public QHexSpinBox
300 302 {
301 303 public:
302 304 PythonQtShell_QHexSpinBox(QWidget* parent = 0):QHexSpinBox(parent),_wrapper(NULL) {};
303 305
304 306 ~PythonQtShell_QHexSpinBox();
305 307
306 308 virtual void actionEvent(QActionEvent* arg__1);
307 309 virtual void changeEvent(QEvent* event);
308 310 virtual void childEvent(QChildEvent* arg__1);
309 311 virtual void clear();
310 312 virtual void closeEvent(QCloseEvent* event);
311 313 virtual void contextMenuEvent(QContextMenuEvent* event);
312 314 virtual void customEvent(QEvent* arg__1);
313 315 virtual int devType() const;
314 316 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
315 317 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
316 318 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
317 319 virtual void dropEvent(QDropEvent* arg__1);
318 320 virtual void enterEvent(QEvent* arg__1);
319 321 virtual bool event(QEvent* event);
320 322 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
321 323 virtual void fixup(QString& str) const;
322 324 virtual void focusInEvent(QFocusEvent* event);
323 325 virtual bool focusNextPrevChild(bool next);
324 326 virtual void focusOutEvent(QFocusEvent* event);
325 327 virtual bool hasHeightForWidth() const;
326 328 virtual int heightForWidth(int arg__1) const;
327 329 virtual void hideEvent(QHideEvent* event);
328 330 virtual void initPainter(QPainter* painter) const;
329 331 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
330 332 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
331 333 virtual void keyPressEvent(QKeyEvent* event);
332 334 virtual void keyReleaseEvent(QKeyEvent* event);
333 335 virtual void leaveEvent(QEvent* arg__1);
334 336 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
335 337 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
336 338 virtual void mouseMoveEvent(QMouseEvent* event);
337 339 virtual void mousePressEvent(QMouseEvent* event);
338 340 virtual void mouseReleaseEvent(QMouseEvent* event);
339 341 virtual void moveEvent(QMoveEvent* arg__1);
340 342 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
341 343 virtual QPaintEngine* paintEngine() const;
342 344 virtual void paintEvent(QPaintEvent* event);
343 345 virtual QPaintDevice* redirected(QPoint* offset) const;
344 346 virtual void resizeEvent(QResizeEvent* event);
345 347 virtual QPainter* sharedPainter() const;
346 348 virtual void showEvent(QShowEvent* event);
347 349 virtual void stepBy(int steps);
348 350 virtual QAbstractSpinBox::StepEnabled stepEnabled() const;
349 351 virtual void tabletEvent(QTabletEvent* arg__1);
350 352 virtual QString textFromValue(int value) const;
351 353 virtual void timerEvent(QTimerEvent* event);
352 354 virtual QValidator::State validate(QString& input, int& pos) const;
353 355 virtual int valueFromText(const QString& text) const;
354 356 virtual void wheelEvent(QWheelEvent* event);
355 357
356 358 PythonQtInstanceWrapper* _wrapper;
357 359 };
358 360
359 361 class PythonQtPublicPromoter_QHexSpinBox : public QHexSpinBox
360 362 { public:
361 363 inline QString promoted_textFromValue(int value) const { return QHexSpinBox::textFromValue(value); }
362 364 inline QValidator::State promoted_validate(QString& input, int& pos) const { return QHexSpinBox::validate(input, pos); }
363 365 inline int promoted_valueFromText(const QString& text) const { return QHexSpinBox::valueFromText(text); }
364 366 };
365 367
366 368 class PythonQtWrapper_QHexSpinBox : public QObject
367 369 { Q_OBJECT
368 370 public:
369 371 public slots:
370 372 QHexSpinBox* new_QHexSpinBox(QWidget* parent = 0);
371 373 void delete_QHexSpinBox(QHexSpinBox* obj) { delete obj; }
372 374 void show(QHexSpinBox* theWrappedObject);
373 375 QString textFromValue(QHexSpinBox* theWrappedObject, int value) const;
374 376 QValidator::State validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const;
375 377 int valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const;
376 378 };
377 379
378 380
379 381
380 382
381 383
382 384 class PythonQtShell_SocExplorerPlot : public SocExplorerPlot
383 385 {
384 386 public:
385 387 PythonQtShell_SocExplorerPlot(QWidget* parent = 0):SocExplorerPlot(parent),_wrapper(NULL) {};
386 388
387 389 ~PythonQtShell_SocExplorerPlot();
388 390
389 391 virtual void actionEvent(QActionEvent* arg__1);
390 392 virtual void changeEvent(QEvent* arg__1);
391 393 virtual void childEvent(QChildEvent* arg__1);
392 394 virtual void closeEvent(QCloseEvent* arg__1);
393 395 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
394 396 virtual void customEvent(QEvent* arg__1);
395 397 virtual int devType() const;
396 398 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
397 399 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
398 400 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
399 401 virtual void dropEvent(QDropEvent* arg__1);
400 402 virtual void enterEvent(QEvent* arg__1);
401 403 virtual bool event(QEvent* arg__1);
402 404 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
403 405 virtual void focusInEvent(QFocusEvent* arg__1);
404 406 virtual bool focusNextPrevChild(bool next);
405 407 virtual void focusOutEvent(QFocusEvent* arg__1);
406 408 virtual bool hasHeightForWidth() const;
407 409 virtual int heightForWidth(int arg__1) const;
408 410 virtual void hideEvent(QHideEvent* arg__1);
409 411 virtual void initPainter(QPainter* painter) const;
410 412 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
411 413 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
412 414 virtual void keyPressEvent(QKeyEvent* arg__1);
413 415 virtual void keyReleaseEvent(QKeyEvent* arg__1);
414 416 virtual void leaveEvent(QEvent* arg__1);
415 417 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
416 418 virtual QSize minimumSizeHint() const;
417 419 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
418 420 virtual void mouseMoveEvent(QMouseEvent* arg__1);
419 421 virtual void mousePressEvent(QMouseEvent* arg__1);
420 422 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
421 423 virtual void moveEvent(QMoveEvent* arg__1);
422 424 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
423 425 virtual QPaintEngine* paintEngine() const;
424 426 virtual void paintEvent(QPaintEvent* arg__1);
425 427 virtual QPaintDevice* redirected(QPoint* offset) const;
426 428 virtual void resizeEvent(QResizeEvent* arg__1);
427 429 virtual QPainter* sharedPainter() const;
428 430 virtual void showEvent(QShowEvent* arg__1);
429 431 virtual QSize sizeHint() const;
430 432 virtual void tabletEvent(QTabletEvent* arg__1);
431 433 virtual void timerEvent(QTimerEvent* arg__1);
432 434 virtual void wheelEvent(QWheelEvent* arg__1);
433 435
434 436 PythonQtInstanceWrapper* _wrapper;
435 437 };
436 438
437 439 class PythonQtPublicPromoter_SocExplorerPlot : public SocExplorerPlot
438 440 { public:
439 441 inline void promoted_keyPressEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyPressEvent(arg__1); }
440 442 inline void promoted_keyReleaseEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyReleaseEvent(arg__1); }
441 443 inline void promoted_mouseMoveEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseMoveEvent(arg__1); }
442 444 inline void promoted_mousePressEvent(QMouseEvent* arg__1) { SocExplorerPlot::mousePressEvent(arg__1); }
443 445 inline void promoted_mouseReleaseEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseReleaseEvent(arg__1); }
444 446 inline void promoted_wheelEvent(QWheelEvent* arg__1) { SocExplorerPlot::wheelEvent(arg__1); }
445 447 };
446 448
447 449 class PythonQtWrapper_SocExplorerPlot : public QObject
448 450 { Q_OBJECT
449 451 public:
450 452 public slots:
451 453 SocExplorerPlot* new_SocExplorerPlot(QWidget* parent = 0);
452 454 void delete_SocExplorerPlot(SocExplorerPlot* obj) { delete obj; }
453 455 int addGraph(SocExplorerPlot* theWrappedObject);
454 456 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
455 457 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y);
456 458 QPen getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex);
457 459 void keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
458 460 void keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
459 461 void mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
460 462 void mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
461 463 void mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
462 464 void rescaleAxis(SocExplorerPlot* theWrappedObject);
463 465 void setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable);
464 466 void setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
465 467 void setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle);
466 468 void setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name);
467 469 void setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen);
468 470 void setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle);
469 471 void setLegendFont(SocExplorerPlot* theWrappedObject, QFont font);
470 472 void setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font);
471 473 void setTitle(SocExplorerPlot* theWrappedObject, QString title);
472 474 void setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
473 475 void setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
474 476 void setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
475 477 void setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
476 478 void show(SocExplorerPlot* theWrappedObject);
477 479 void wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1);
478 480 };
479 481
480 482
481 483
482 484
483 485
484 486 class PythonQtShell_TCP_Terminal_Client : public TCP_Terminal_Client
485 487 {
486 488 public:
487 489 PythonQtShell_TCP_Terminal_Client(QObject* parent = 0):TCP_Terminal_Client(parent),_wrapper(NULL) {};
488 490
489 491 ~PythonQtShell_TCP_Terminal_Client();
490 492
491 493 virtual void childEvent(QChildEvent* arg__1);
492 494 virtual void customEvent(QEvent* arg__1);
493 495 virtual bool event(QEvent* arg__1);
494 496 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
495 497 virtual void timerEvent(QTimerEvent* arg__1);
496 498
497 499 PythonQtInstanceWrapper* _wrapper;
498 500 };
499 501
500 502 class PythonQtWrapper_TCP_Terminal_Client : public QObject
501 503 { Q_OBJECT
502 504 public:
503 505 public slots:
504 506 TCP_Terminal_Client* new_TCP_Terminal_Client(QObject* parent = 0);
505 507 void delete_TCP_Terminal_Client(TCP_Terminal_Client* obj) { delete obj; }
506 508 void connectToServer(TCP_Terminal_Client* theWrappedObject);
507 509 void connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port);
508 510 bool isConnected(TCP_Terminal_Client* theWrappedObject);
509 511 void sendText(TCP_Terminal_Client* theWrappedObject, const QString& text);
510 512 void startServer(TCP_Terminal_Client* theWrappedObject);
511 513 void startServer(TCP_Terminal_Client* theWrappedObject, int port);
512 514 };
513 515
514 516
515 517
516 518
517 519
518 520 class PythonQtWrapper_XByteArray : public QObject
519 521 { Q_OBJECT
520 522 public:
521 523 public slots:
522 524 XByteArray* new_XByteArray();
523 525 void delete_XByteArray(XByteArray* obj) { delete obj; }
524 526 int addressOffset(XByteArray* theWrappedObject);
525 527 int addressWidth(XByteArray* theWrappedObject);
526 528 QChar asciiChar(XByteArray* theWrappedObject, int index);
527 529 QByteArray* data(XByteArray* theWrappedObject);
528 530 bool dataChanged(XByteArray* theWrappedObject, int i);
529 531 QByteArray dataChanged(XByteArray* theWrappedObject, int i, int len);
530 532 QByteArray* insert(XByteArray* theWrappedObject, int i, char ch);
531 533 QByteArray* insert(XByteArray* theWrappedObject, int i, const QByteArray& ba);
532 534 int realAddressNumbers(XByteArray* theWrappedObject);
533 535 QByteArray* remove(XByteArray* theWrappedObject, int pos, int len);
534 536 QByteArray* replace(XByteArray* theWrappedObject, int index, char ch);
535 537 QByteArray* replace(XByteArray* theWrappedObject, int index, const QByteArray& ba);
536 538 QByteArray* replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba);
537 539 void setAddressOffset(XByteArray* theWrappedObject, int offset);
538 540 void setAddressWidth(XByteArray* theWrappedObject, int width);
539 541 void setData(XByteArray* theWrappedObject, QByteArray data);
540 542 void setDataChanged(XByteArray* theWrappedObject, int i, bool state);
541 543 void setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state);
542 544 int size(XByteArray* theWrappedObject);
543 545 QString toRedableString(XByteArray* theWrappedObject, int start = 0, int end = -1);
544 546 };
545 547
546 548
547 549
548 550
549 551
550 552 class PythonQtShell_abstractExecFile : public abstractExecFile
551 553 {
552 554 public:
553 555 PythonQtShell_abstractExecFile():abstractExecFile(),_wrapper(NULL) {};
554 556
555 557 ~PythonQtShell_abstractExecFile();
556 558
557 559 virtual void childEvent(QChildEvent* arg__1);
558 560 virtual int closeFile();
559 561 virtual void customEvent(QEvent* arg__1);
560 562 virtual bool event(QEvent* arg__1);
561 563 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
562 564 virtual QList<codeFragment* > getFragments();
563 565 virtual bool isopened();
564 566 virtual bool openFile(const QString& File);
565 567 virtual void timerEvent(QTimerEvent* arg__1);
566 568
567 569 PythonQtInstanceWrapper* _wrapper;
568 570 };
569 571
570 572 class PythonQtWrapper_abstractExecFile : public QObject
571 573 { Q_OBJECT
572 574 public:
573 575 public slots:
574 576 abstractExecFile* new_abstractExecFile();
575 577 void delete_abstractExecFile(abstractExecFile* obj) { delete obj; }
576 578 };
577 579
578 580
579 581
580 582
581 583
582 584 class PythonQtShell_codeFragment : public codeFragment
583 585 {
584 586 public:
585 587 PythonQtShell_codeFragment():codeFragment(),_wrapper(NULL) {};
586 588 PythonQtShell_codeFragment(char* data, unsigned int size, unsigned int address):codeFragment(data, size, address),_wrapper(NULL) {};
587 589
588 590 ~PythonQtShell_codeFragment();
589 591
590 592
591 593 PythonQtInstanceWrapper* _wrapper;
592 594 };
593 595
594 596 class PythonQtWrapper_codeFragment : public QObject
595 597 { Q_OBJECT
596 598 public:
597 599 public slots:
598 600 codeFragment* new_codeFragment();
599 601 codeFragment* new_codeFragment(char* data, unsigned int size, unsigned int address);
600 602 void delete_codeFragment(codeFragment* obj) { delete obj; }
601 603 void py_set_address(codeFragment* theWrappedObject, unsigned int address){ theWrappedObject->address = address; }
602 604 unsigned int py_get_address(codeFragment* theWrappedObject){ return theWrappedObject->address; }
603 605 void py_set_data(codeFragment* theWrappedObject, char* data){ theWrappedObject->data = data; }
604 606 char* py_get_data(codeFragment* theWrappedObject){ return theWrappedObject->data; }
605 607 void py_set_size(codeFragment* theWrappedObject, unsigned int size){ theWrappedObject->size = size; }
606 608 unsigned int py_get_size(codeFragment* theWrappedObject){ return theWrappedObject->size; }
607 609 };
608 610
609 611
610 612
611 613
612 614
613 615 class PythonQtShell_elfFileWidget : public elfFileWidget
614 616 {
615 617 public:
616 618 PythonQtShell_elfFileWidget(QWidget* parent = 0):elfFileWidget(parent),_wrapper(NULL) {};
617 619
618 620 ~PythonQtShell_elfFileWidget();
619 621
620 622 virtual void actionEvent(QActionEvent* arg__1);
621 623 virtual void changeEvent(QEvent* arg__1);
622 624 virtual void childEvent(QChildEvent* arg__1);
623 625 virtual void closeEvent(QCloseEvent* arg__1);
624 626 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
625 627 virtual void customEvent(QEvent* arg__1);
626 628 virtual int devType() const;
627 629 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
628 630 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
629 631 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
630 632 virtual void dropEvent(QDropEvent* arg__1);
631 633 virtual void enterEvent(QEvent* arg__1);
632 634 virtual bool event(QEvent* arg__1);
633 635 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
634 636 virtual void focusInEvent(QFocusEvent* arg__1);
635 637 virtual bool focusNextPrevChild(bool next);
636 638 virtual void focusOutEvent(QFocusEvent* arg__1);
637 639 virtual bool hasHeightForWidth() const;
638 640 virtual int heightForWidth(int arg__1) const;
639 641 virtual void hideEvent(QHideEvent* arg__1);
640 642 virtual void initPainter(QPainter* painter) const;
641 643 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
642 644 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
643 645 virtual void keyPressEvent(QKeyEvent* arg__1);
644 646 virtual void keyReleaseEvent(QKeyEvent* arg__1);
645 647 virtual void leaveEvent(QEvent* arg__1);
646 648 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
647 649 virtual QSize minimumSizeHint() const;
648 650 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
649 651 virtual void mouseMoveEvent(QMouseEvent* arg__1);
650 652 virtual void mousePressEvent(QMouseEvent* arg__1);
651 653 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
652 654 virtual void moveEvent(QMoveEvent* arg__1);
653 655 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
654 656 virtual QPaintEngine* paintEngine() const;
655 657 virtual void paintEvent(QPaintEvent* arg__1);
656 658 virtual QPaintDevice* redirected(QPoint* offset) const;
657 659 virtual void resizeEvent(QResizeEvent* arg__1);
658 660 virtual QPainter* sharedPainter() const;
659 661 virtual void showEvent(QShowEvent* arg__1);
660 662 virtual QSize sizeHint() const;
661 663 virtual void tabletEvent(QTabletEvent* arg__1);
662 664 virtual void timerEvent(QTimerEvent* arg__1);
663 665 virtual void wheelEvent(QWheelEvent* arg__1);
664 666
665 667 PythonQtInstanceWrapper* _wrapper;
666 668 };
667 669
668 670 class PythonQtWrapper_elfFileWidget : public QObject
669 671 { Q_OBJECT
670 672 public:
671 673 public slots:
672 674 elfFileWidget* new_elfFileWidget(QWidget* parent = 0);
673 675 void delete_elfFileWidget(elfFileWidget* obj) { delete obj; }
674 676 };
675 677
676 678
677 679
678 680
679 681
680 682 class PythonQtShell_elfInfoWdgt : public elfInfoWdgt
681 683 {
682 684 public:
683 685 PythonQtShell_elfInfoWdgt(QWidget* parent = 0):elfInfoWdgt(parent),_wrapper(NULL) {};
684 686
685 687 ~PythonQtShell_elfInfoWdgt();
686 688
687 689 virtual void actionEvent(QActionEvent* arg__1);
688 690 virtual void changeEvent(QEvent* arg__1);
689 691 virtual void childEvent(QChildEvent* arg__1);
690 692 virtual void closeEvent(QCloseEvent* arg__1);
691 693 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
692 694 virtual void customEvent(QEvent* arg__1);
693 695 virtual int devType() const;
694 696 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
695 697 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
696 698 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
697 699 virtual void dropEvent(QDropEvent* arg__1);
698 700 virtual void enterEvent(QEvent* arg__1);
699 701 virtual bool event(QEvent* arg__1);
700 702 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
701 703 virtual void focusInEvent(QFocusEvent* arg__1);
702 704 virtual bool focusNextPrevChild(bool next);
703 705 virtual void focusOutEvent(QFocusEvent* arg__1);
704 706 virtual bool hasHeightForWidth() const;
705 707 virtual int heightForWidth(int arg__1) const;
706 708 virtual void hideEvent(QHideEvent* arg__1);
707 709 virtual void initPainter(QPainter* painter) const;
708 710 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
709 711 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
710 712 virtual void keyPressEvent(QKeyEvent* arg__1);
711 713 virtual void keyReleaseEvent(QKeyEvent* arg__1);
712 714 virtual void leaveEvent(QEvent* arg__1);
713 715 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
714 716 virtual QSize minimumSizeHint() const;
715 717 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
716 718 virtual void mouseMoveEvent(QMouseEvent* arg__1);
717 719 virtual void mousePressEvent(QMouseEvent* arg__1);
718 720 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
719 721 virtual void moveEvent(QMoveEvent* arg__1);
720 722 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
721 723 virtual QPaintEngine* paintEngine() const;
722 724 virtual void paintEvent(QPaintEvent* arg__1);
723 725 virtual QPaintDevice* redirected(QPoint* offset) const;
724 726 virtual void resizeEvent(QResizeEvent* arg__1);
725 727 virtual QPainter* sharedPainter() const;
726 728 virtual void showEvent(QShowEvent* arg__1);
727 729 virtual QSize sizeHint() const;
728 730 virtual void tabletEvent(QTabletEvent* arg__1);
729 731 virtual void timerEvent(QTimerEvent* arg__1);
730 732 virtual void wheelEvent(QWheelEvent* arg__1);
731 733
732 734 PythonQtInstanceWrapper* _wrapper;
733 735 };
734 736
735 737 class PythonQtWrapper_elfInfoWdgt : public QObject
736 738 { Q_OBJECT
737 739 public:
738 740 public slots:
739 741 elfInfoWdgt* new_elfInfoWdgt(QWidget* parent = 0);
740 742 void delete_elfInfoWdgt(elfInfoWdgt* obj) { delete obj; }
741 743 };
742 744
743 745
744 746
745 747
746 748
747 749 class PythonQtWrapper_elfparser : public QObject
748 750 { Q_OBJECT
749 751 public:
750 752 public slots:
751 753 elfparser* new_elfparser();
752 754 void delete_elfparser(elfparser* obj) { delete obj; }
753 755 int closeFile(elfparser* theWrappedObject);
754 756 QString getABI(elfparser* theWrappedObject);
755 757 QString getArchitecture(elfparser* theWrappedObject);
756 758 QString getClass(elfparser* theWrappedObject);
757 759 QString getEndianness(elfparser* theWrappedObject);
758 760 qint64 getEntryPointAddress(elfparser* theWrappedObject);
759 761 bool getSectionData(elfparser* theWrappedObject, int index, char** buffer);
760 762 qint64 getSectionDatasz(elfparser* theWrappedObject, int index);
761 763 qint64 getSectionMemsz(elfparser* theWrappedObject, int index);
762 764 QString getSectionName(elfparser* theWrappedObject, int index);
763 765 qint64 getSectionPaddr(elfparser* theWrappedObject, int index);
764 766 QString getSectionType(elfparser* theWrappedObject, int index);
765 767 int getSectioncount(elfparser* theWrappedObject);
766 768 qint64 getSegmentFilesz(elfparser* theWrappedObject, int index);
767 769 QString getSegmentFlags(elfparser* theWrappedObject, int index);
768 770 qint64 getSegmentMemsz(elfparser* theWrappedObject, int index);
769 771 qint64 getSegmentOffset(elfparser* theWrappedObject, int index);
770 772 qint64 getSegmentPaddr(elfparser* theWrappedObject, int index);
771 773 QString getSegmentType(elfparser* theWrappedObject, int index);
772 774 qint64 getSegmentVaddr(elfparser* theWrappedObject, int index);
773 775 int getSegmentcount(elfparser* theWrappedObject);
774 776 QString getType(elfparser* theWrappedObject);
775 777 qint64 getVersion(elfparser* theWrappedObject);
776 778 bool static_elfparser_isElf(const QString& File);
777 779 bool iself(elfparser* theWrappedObject);
778 780 bool isopened(elfparser* theWrappedObject);
779 781 int setFilename(elfparser* theWrappedObject, const QString& name);
780 782 };
781 783
782 784
785
786
787
788 class PythonQtShell_srecFile : public srecFile
789 {
790 public:
791 PythonQtShell_srecFile():srecFile(),_wrapper(NULL) {};
792 PythonQtShell_srecFile(const QString& File):srecFile(File),_wrapper(NULL) {};
793 PythonQtShell_srecFile(const QStringList& Files):srecFile(Files),_wrapper(NULL) {};
794
795 ~PythonQtShell_srecFile();
796
797 virtual int closeFile();
798 virtual QList<codeFragment* > getFragments();
799 virtual bool isopened();
800 virtual bool openFile(const QString& File);
801
802 PythonQtInstanceWrapper* _wrapper;
803 };
804
805 class PythonQtPublicPromoter_srecFile : public srecFile
806 { public:
807 inline int promoted_closeFile() { return srecFile::closeFile(); }
808 inline QList<codeFragment* > promoted_getFragments() { return srecFile::getFragments(); }
809 inline bool promoted_isopened() { return srecFile::isopened(); }
810 inline bool promoted_openFile(const QString& File) { return srecFile::openFile(File); }
811 };
812
813 class PythonQtWrapper_srecFile : public QObject
814 { Q_OBJECT
815 public:
816 public slots:
817 srecFile* new_srecFile();
818 srecFile* new_srecFile(const QString& File);
819 srecFile* new_srecFile(const QStringList& Files);
820 void delete_srecFile(srecFile* obj) { delete obj; }
821 int closeFile(srecFile* theWrappedObject);
822 QList<codeFragment* > getFragments(srecFile* theWrappedObject);
823 bool isopened(srecFile* theWrappedObject);
824 bool openFile(srecFile* theWrappedObject, const QString& File);
825 bool openFiles(srecFile* theWrappedObject, const QStringList& Files);
826 };
827
828
Show file before | Show file after | Hide comments
@@ -1,20 +1,22
1 1 #include <PythonQt.h>
2 2 #include "PySocExplorer0.h"
3 3
4 4
5 5 void PythonQt_init_PySocExplorer(PyObject* module) {
6 6 PythonQt::priv()->registerClass(&ElfFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_ElfFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_ElfFile>, module, 0);
7 7 PythonQt::self()->addParentClass("ElfFile", "abstractExecFile",PythonQtUpcastingOffset<ElfFile,abstractExecFile>());
8 8 PythonQt::priv()->registerClass(&MemSizeWdgt::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_MemSizeWdgt>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_MemSizeWdgt>, module, 0);
9 9 PythonQt::priv()->registerClass(&QHexEdit::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_QHexEdit>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QHexEdit>, module, 0);
10 10 PythonQt::priv()->registerClass(&QHexSpinBox::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_QHexSpinBox>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QHexSpinBox>, module, 0);
11 11 PythonQt::priv()->registerClass(&SocExplorerPlot::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_SocExplorerPlot>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_SocExplorerPlot>, module, 0);
12 12 PythonQt::priv()->registerClass(&TCP_Terminal_Client::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_TCP_Terminal_Client>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_TCP_Terminal_Client>, module, 0);
13 13 PythonQt::priv()->registerCPPClass("XByteArray", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_XByteArray>, NULL, module, 0);
14 14 PythonQt::priv()->registerClass(&abstractExecFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_abstractExecFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_abstractExecFile>, module, 0);
15 15 PythonQt::priv()->registerCPPClass("codeFragment", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_codeFragment>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_codeFragment>, module, 0);
16 16 PythonQt::priv()->registerClass(&elfFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_elfFileWidget>, module, 0);
17 17 PythonQt::priv()->registerClass(&elfInfoWdgt::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfInfoWdgt>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_elfInfoWdgt>, module, 0);
18 18 PythonQt::priv()->registerCPPClass("elfparser", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfparser>, NULL, module, 0);
19 PythonQt::priv()->registerClass(&srecFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_srecFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_srecFile>, module, 0);
20 PythonQt::self()->addParentClass("srecFile", "abstractExecFile",PythonQtUpcastingOffset<srecFile,abstractExecFile>());
19 21
20 22 }
Show file before | Show file after | Hide comments
@@ -1,55 +1,56
1 1 <typesystem package="PySocExplorer" 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
7 7 <object-type name="QHexSpinBox">
8 8 <extra-includes>
9 9 <include file-name="QWidget" location="global"/>
10 10 <include file-name="QObject" location="global"/>
11 11 <include file-name="QSpinBox" location="global"/>
12 12 </extra-includes>
13 13 </object-type>
14 14 <object-type name="MemSizeWdgt" />
15 15 <object-type name="QHexEdit" />
16 16 <object-type name="XByteArray" />
17 17 <object-type name="SocExplorerPlot" />
18 18 <object-type name="TCP_Terminal_Client" />
19 19 <object-type name="codeFragment" />
20 <object-type name="srecFile" />
20 21 <rejection class="Elf_Section"/>
21 22 <object-type name="elfparser" />
22 23 <interface-type name="abstractExecFile">
23 24 <extra-includes>
24 25 <include file-name="QWidget" location="global"/>
25 26 <include file-name="QObject" location="global"/>
26 27 </extra-includes>
27 28 </interface-type>
28 29 <object-type name="ElfFile">
29 30 <extra-includes>
30 31 <include file-name="QWidget" location="global"/>
31 32 <include file-name="QObject" location="global"/>
32 33 </extra-includes>
33 34 </object-type>
34 35 <object-type name="elfFileWidget">
35 36 <extra-includes>
36 37 <include file-name="QWidget" location="global"/>
37 38 <include file-name="QObject" location="global"/>
38 39 </extra-includes>
39 40 </object-type>
40 41 <object-type name="elfInfoWdgt">
41 42 <extra-includes>
42 43 <include file-name="QWidget" location="global"/>
43 44 <include file-name="QObject" location="global"/>
44 45 </extra-includes>
45 46 </object-type>
46 47
47 48 </typesystem>
48 49
49 50
50 51
51 52
52 53
53 54
54 55
55 56
Show file before | Show file after | Hide comments
@@ -1,6 +1,6
1 1 #!/bin/bash
2 2
3 3 #export QTDIR=/usr/include
4 4 #export QTDIR=/usr/include/qt5
5 5
6 pythonqt_generator --include-paths=./elf:/usr/include/qt5:/usr/include/qt5/QtCore:/usr/include/qt5/QtWidgets --output-directory=pythonQtOut PySocExplorer.h pythonQtgeneratorCfg.txt
6 pythonqt_generator --include-paths=./elf:./srec:/usr/include/qt5:/usr/include/qt5/QtCore:/usr/include/qt5/QtWidgets --output-directory=pythonQtOut PySocExplorer.h pythonQtgeneratorCfg.txt
Show file before | Show file after | Hide comments
@@ -1,133 +1,134
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/plugins/socexplorerplugin.prf )
19 19
20 20 INCLUDEPATH+=$${PWD} \
21 21 $${PWD}/common \
22 22 $${PWD}/common/qhexedit \
23 23 $${PWD}/common/QCustomPlot \
24 24 $${PWD}/common/elf \
25 $${PWD}/common/srec \
25 26 SocExplorerEngine/engine \
26 27 SocExplorerEngine/pluginloader \
27 28 SocExplorerEngine/pluginsInterface \
28 29 SocExplorerEngine/proxy \
29 30 SocExplorerEngine/pluginManagerWdgt \
30 31 SocExplorerEngine/plugins \
31 32 SocExplorerEngine/RegisterMVS \
32 33 SocExplorerEngine/XmlEngine \
33 34 SocExplorerEngine/SOC \
34 35 SocExplorerEngine/PeripheralWidget/src
35 36
36 37 win32:INCLUDEPATH+= \
37 38 $${PWD}/common/elf/libelfWin32/include \
38 39 $${PWD}/common/elf/libelfWin32/include/libelf \
39 40
40 41
41 42 RC_FILE = ../win32cfg/socexplorer.rc
42 43
43 44
44 45 unix:LIBS+=-L$${SOCEXPLORER_ROOT}/bin/linux -lsocexplorercommon$${DEBUG_EXT} -L$${SOCEXPLORER_ROOT}/bin/linux -lsocexplorerengine$${DEBUG_EXT}
45 46
46 47 win32-g++:LIBS += $${SOCEXPLORER_ROOT}/bin/win32/socexplorercommon$${DEBUG_EXT}.dll $${SOCEXPLORER_ROOT}/bin/win32/socexplorerengine$${DEBUG_EXT}.dll
47 48
48 49
49 50 unix{
50 51 translation.files = $${SOCEXPLORER_ROOT}/translations/socexplorer_fr.qm \
51 52 $${SOCEXPLORER_ROOT}/translations/socexplorer_en.qm
52 53 translation.path = $${SOCEXPLORER_TRANSLATION_INSTALL_PATH}
53 54 target.path = /usr/bin
54 55 INSTALLS += translation target
55 56 }
56 57
57 58 header.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common
58 59 header.files = \
59 60 socexplorer.h
60 61 INSTALLS += header
61 62
62 63
63 64 SOURCES += main.cpp\
64 65 mainwindow.cpp \
65 66 PyWdgt/pythonconsole.cpp \
66 67 PyWdgt/pythonqtscriptingconsoledandd.cpp \
67 68 dockablepluginmanager.cpp \
68 69 toolbar.cpp \
69 70 toolbarcontainer.cpp \
70 71 regsExplorer/regsexplorer.cpp \
71 72 regsExplorer/regsviewer.cpp \
72 73 regsExplorer/regsexplorercfg.cpp \
73 74 aboutsocexplorer.cpp
74 75
75 76 # regWidget/xmltagtextedit.cpp \
76 77 # regWidget/xmltaglabeledit.cpp \
77 78 # regWidget/xmlelementslistwidget.cpp \
78 79 # regWidget/xmlelementslistview.cpp \
79 80 # regWidget/regpropeditor.cpp \
80 81 # regWidget/registerwdgt.cpp \
81 82 # regWidget/registereditor.cpp \
82 83 # regWidget/registercel.cpp \
83 84 # regWidget/periphpropeditor.cpp \
84 85 # regWidget/peripherialregs.cpp \
85 86 # regWidget/bitfieldpropeditor.cpp \
86 87 # regWidget/bitfield.cpp
87 88
88 89
89 90 HEADERS += mainwindow.h \
90 91 PyWdgt/pythonconsole.h \
91 92 PyWdgt/pythonqtscriptingconsoledandd.h \
92 93 dockablepluginmanager.h \
93 94 toolbar.h \
94 95 toolbarcontainer.h \
95 96 regsExplorer/regsexplorer.h \
96 97 regsExplorer/regsviewer.h \
97 98 regsExplorer/regsexplorercfg.h \
98 99 socexplorer.h \
99 100 SocExplorerEngine/plugins/socexplorerplugin.h \
100 101 aboutsocexplorer.h
101 102 # regWidget/xmltagtextedit.h \
102 103 # regWidget/xmltaglabeledit.h \
103 104 # regWidget/xmlelementslistwidget.h \
104 105 # regWidget/xmlelementslistview.h \
105 106 # regWidget/regpropeditor.h \
106 107 # regWidget/registerwdgt.h \
107 108 # regWidget/registereditor.h \
108 109 # regWidget/registercel.h \
109 110 # regWidget/periphpropeditor.h \
110 111 # regWidget/peripherialregs.h \
111 112 # regWidget/bitfieldpropeditor.h \
112 113 # regWidget/bitfield.h
113 114
114 115
115 116 include ( NicePyConsole/NicePyConsole.pri)
116 117
117 118 win32{
118 119 RESOURCES = ../ressources/SocExplorer.qrc
119 120 }
120 121
121 122 unix{
122 123 RESOURCES = ../ressources/SocExplorer.qrc
123 124 }
124 125
125 126 TRANSLATIONS = ../translations/socexplorer_fr.ts \
126 127 ../translations/socexplorer_en.ts
127 128
128 129
129 130
130 131
131 132
132 133
133 134
General Comments 0
You need to be logged in to leave comments. Login now