##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » SocExplorer
RSS
Elf viewer almost completed.
Jeandet Alexis -
r43:10bc9884d696 default
parent child
Show More
Show file before | Show file after | Hide comments
@@ -0,0 +1,51
1 #include "qtablewidgetintitem.h"
2
3 QTableWidgetIntItem::QTableWidgetIntItem(const QString &text,int Type)
4 :QTableWidgetItem(text,Type)
5 {
6 }
7
8 bool QTableWidgetIntItem::operator <(const QTableWidgetItem& other) const
9 {
10 return toInt() < toInt(other);
11 }
12
13 bool QTableWidgetIntItem::operator >(const QTableWidgetItem &other) const
14 {
15 return toInt() > toInt(other);
16 }
17
18 bool QTableWidgetIntItem::operator ==(const QTableWidgetItem &other) const
19 {
20 return toInt() == toInt(other);
21 }
22
23 int QTableWidgetIntItem::toInt() const
24 {
25 bool ok=true;
26 if(type()==DecimalItem)
27 {
28 return text().toInt();
29 }
30 else if(type()==HexaDecimalItem)
31 {
32 return text().replace("0x","").toInt(&ok,16);
33 }
34 return 0;
35 }
36
37 int QTableWidgetIntItem::toInt(const QTableWidgetItem &item) const
38 {
39 bool ok=true;
40 if(item.type()==DecimalItem)
41 {
42 return item.text().toInt();
43 }
44 else if(item.type()==HexaDecimalItem)
45 {
46 return item.text().replace("0x","").toInt(&ok,16);
47 }
48 return 0;
49 }
50
51
Show file before | Show file after | Hide comments
@@ -0,0 +1,22
1 #ifndef QTABLEWIDGETINTITEM_H
2 #define QTABLEWIDGETINTITEM_H
3
4 #include <QTableWidgetItem>
5
6 #define DecimalItem 0
7 #define HexaDecimalItem 1
8
9 class QTableWidgetIntItem : public QTableWidgetItem
10 {
11
12 public:
13 explicit QTableWidgetIntItem(const QString& text, int Type);
14 bool operator <(const QTableWidgetItem &other)const;
15 bool operator >(const QTableWidgetItem &other)const;
16 bool operator ==(const QTableWidgetItem &other)const;
17 int toInt() const;
18 int toInt(const QTableWidgetItem &item) const;
19
20 };
21
22 #endif // QTABLEWIDGETINTITEM_H
Show file before | Show file after | Hide comments
@@ -1,117 +1,120
1 SOCEXPLORER_ROOT = \"$${PWD}/../..\"
1 SOCEXPLORER_ROOT = \"$${PWD}/../..\"
2 include($${PWD}/../../build_cfg/socexplorer.pri)
2 include($${PWD}/../../build_cfg/socexplorer.pri)
3 include($${PWD}/lppserial/lppserial.pri)
3 include($${PWD}/lppserial/lppserial.pri)
4
4
5 TEMPLATE = lib
5 TEMPLATE = lib
6 TARGET = socexplorercommon$${DEBUG_EXT}
6 TARGET = socexplorercommon$${DEBUG_EXT}
7
7
8 win32:CONFIG += dll
8 win32:CONFIG += dll
9 win32:CONFIG -= static
9 win32:CONFIG -= static
10
10
11 win32:INCLUDEPATH += $${PWD}/elf/libelfWin32/include
11 win32:INCLUDEPATH += $${PWD}/elf/libelfWin32/include
12 win32:INCLUDEPATH += $${PWD}/elf/libelfWin32/include/libelf
12 win32:INCLUDEPATH += $${PWD}/elf/libelfWin32/include/libelf
13 win32:DEFINES+=_ELF_WINDOWS_
13 win32:DEFINES+=_ELF_WINDOWS_
14 DEFINES+=RS232_debug
14 DEFINES+=RS232_debug
15
15
16 win32:LIBS += $${PWD}/elf/libelfWin32/bin/libelf.a
16 win32:LIBS += $${PWD}/elf/libelfWin32/bin/libelf.a
17 unix:LIBS += -lelf
17 unix:LIBS += -lelf
18
18
19 QMAKE_LFLAGS_RELEASE += --enable-auto-import
19 QMAKE_LFLAGS_RELEASE += --enable-auto-import
20 QMAKE_LFLAGS_DEBUG += --enable-auto-import
20 QMAKE_LFLAGS_DEBUG += --enable-auto-import
21
21
22 target.path = $$[QT_INSTALL_LIBS]
22 target.path = $$[QT_INSTALL_LIBS]
23 isEmpty(target.path) {
23 isEmpty(target.path) {
24 error(can\'t get QT_INSTALL_LIBS)
24 error(can\'t get QT_INSTALL_LIBS)
25 }
25 }
26
26
27 header.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common
27 header.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common
28 header.files = \
28 header.files = \
29 memsizewdgt.h \
29 memsizewdgt.h \
30 qhexspinbox.h \
30 qhexspinbox.h \
31 qsvgicon.h \
31 qsvgicon.h \
32 qhexedit/qhexedit_p.h \
32 qhexedit/qhexedit_p.h \
33 qhexedit/qhexedit.h \
33 qhexedit/qhexedit.h \
34 qhexedit/xbytearray.h \
34 qhexedit/xbytearray.h \
35 QCustomPlot/qcustomplot.h \
35 QCustomPlot/qcustomplot.h \
36 SocExplorerPlot.h \
36 SocExplorerPlot.h \
37 tcp_terminal_client.h \
37 tcp_terminal_client.h \
38 elf/elfinfowdgt.h \
38 elf/elfinfowdgt.h \
39 elf/elfparser.h \
39 elf/elfparser.h \
40 elf/elffile.h \
40 elf/elffile.h \
41 elf/elffilewidget.h \
41 elf/elffilewidget.h \
42 qipdialogbox.h \
42 qipdialogbox.h \
43 lppserial/src/RS232.h
43 lppserial/src/RS232.h \
44 qtablewidgetintitem.h
44
45
45 win32{
46 win32{
46 elfheader.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common/libelf
47 elfheader.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common/libelf
47 elfheader.files += \
48 elfheader.files += \
48 elf/libelfWin32/include/libelf/byteswap.h \
49 elf/libelfWin32/include/libelf/byteswap.h \
49 elf/libelfWin32/include/libelf/errors.h \
50 elf/libelfWin32/include/libelf/errors.h \
50 elf/libelfWin32/include/libelf/gelf.h \
51 elf/libelfWin32/include/libelf/gelf.h \
51 elf/libelfWin32/include/libelf/nlist.h \
52 elf/libelfWin32/include/libelf/nlist.h \
52 elf/libelfWin32/include/libelf/sys_elf.h \
53 elf/libelfWin32/include/libelf/sys_elf.h \
53 elf/libelfWin32/include/libelf/verneed.h \
54 elf/libelfWin32/include/libelf/verneed.h \
54 elf/libelfWin32/include/libelf/elf_repl.h \
55 elf/libelfWin32/include/libelf/elf_repl.h \
55 elf/libelfWin32/include/libelf/ext_types.h \
56 elf/libelfWin32/include/libelf/ext_types.h \
56 elf/libelfWin32/include/libelf/libelf.h \
57 elf/libelfWin32/include/libelf/libelf.h \
57 elf/libelfWin32/include/libelf/private.h \
58 elf/libelfWin32/include/libelf/private.h \
58 elf/libelfWin32/include/libelf/verdef.h
59 elf/libelfWin32/include/libelf/verdef.h
59 INSTALLS += elfheader
60 INSTALLS += elfheader
60 }
61 }
61
62
62
63
63 isEmpty(header.path) {
64 isEmpty(header.path) {
64 error(can\'t get QT_INSTALL_HEADERS)
65 error(can\'t get QT_INSTALL_HEADERS)
65 }
66 }
66
67
67 INSTALLS += target header
68 INSTALLS += target header
68
69
69 INCLUDEPATH += QCustomPlot qhexedit
70 INCLUDEPATH += QCustomPlot qhexedit
70
71
71 HEADERS += \
72 HEADERS += \
72 memsizewdgt.h \
73 memsizewdgt.h \
73 qhexspinbox.h \
74 qhexspinbox.h \
74 qsvgicon.h \
75 qsvgicon.h \
75 qhexedit/qhexedit_p.h \
76 qhexedit/qhexedit_p.h \
76 qhexedit/qhexedit.h \
77 qhexedit/qhexedit.h \
77 qhexedit/xbytearray.h \
78 qhexedit/xbytearray.h \
78 qhexedit/commands.h \
79 qhexedit/commands.h \
79 QCustomPlot/qcustomplot.h \
80 QCustomPlot/qcustomplot.h \
80 tcp_terminal_client.h \
81 tcp_terminal_client.h \
81 elf/elfinfowdgt.h \
82 elf/elfinfowdgt.h \
82 elf/elfparser.h \
83 elf/elfparser.h \
83 abstractexecfile.h \
84 abstractexecfile.h \
84 elf/elffile.h \
85 elf/elffile.h \
85 qipdialogbox.h \
86 qipdialogbox.h \
86 PySocExplorer.h \
87 PySocExplorer.h \
87 SocExplorerPlot.h \
88 SocExplorerPlot.h \
88 elf/elffilewidget.h
89 elf/elffilewidget.h \
90 qtablewidgetintitem.h
89
91
90
92
91 SOURCES += \
93 SOURCES += \
92 memsizewdgt.cpp \
94 memsizewdgt.cpp \
93 qhexspinbox.cpp \
95 qhexspinbox.cpp \
94 qsvgicon.cpp \
96 qsvgicon.cpp \
95 qhexedit/qhexedit_p.cpp \
97 qhexedit/qhexedit_p.cpp \
96 qhexedit/qhexedit.cpp \
98 qhexedit/qhexedit.cpp \
97 qhexedit/xbytearray.cpp \
99 qhexedit/xbytearray.cpp \
98 qhexedit/commands.cpp \
100 qhexedit/commands.cpp \
99 QCustomPlot/qcustomplot.cpp \
101 QCustomPlot/qcustomplot.cpp \
100 tcp_terminal_client.cpp \
102 tcp_terminal_client.cpp \
101 elf/elfinfowdgt.cpp \
103 elf/elfinfowdgt.cpp \
102 elf/elfparser.cpp \
104 elf/elfparser.cpp \
103 abstractexecfile.cpp \
105 abstractexecfile.cpp \
104 elf/elffile.cpp \
106 elf/elffile.cpp \
105 qipdialogbox.cpp \
107 qipdialogbox.cpp \
106 SocExplorerPlot.cpp \
108 SocExplorerPlot.cpp \
107 elf/elffilewidget.cpp
109 elf/elffilewidget.cpp \
110 qtablewidgetintitem.cpp
108
111
109 FORMS += \
112 FORMS += \
110 elf/elffilewidget.ui
113 elf/elffilewidget.ui
111
114
112 OTHER_FILES += \
115 OTHER_FILES += \
113 ./pythongenerator.sh \
116 ./pythongenerator.sh \
114 ./pythonQtgeneratorCfg.txt
117 ./pythonQtgeneratorCfg.txt
115
118
116
119
117
120
Show file before | Show file after | Hide comments
@@ -1,1006 +1,1041
1 /*------------------------------------------------------------------------------
1 /*------------------------------------------------------------------------------
2 -- This file is a part of the SocExplorer Software
2 -- This file is a part of the SocExplorer Software
3 -- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
3 -- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
4 --
4 --
5 -- This program is free software; you can redistribute it and/or modify
5 -- This program is free software; you can redistribute it and/or modify
6 -- it under the terms of the GNU General Public License as published by
6 -- it under the terms of the GNU General Public License as published by
7 -- the Free Software Foundation; either version 2 of the License, or
7 -- the Free Software Foundation; either version 2 of the License, or
8 -- (at your option) any later version.
8 -- (at your option) any later version.
9 --
9 --
10 -- This program is distributed in the hope that it will be useful,
10 -- This program is distributed in the hope that it will be useful,
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 -- GNU General Public License for more details.
13 -- GNU General Public License for more details.
14 --
14 --
15 -- You should have received a copy of the GNU General Public License
15 -- You should have received a copy of the GNU General Public License
16 -- along with this program; if not, write to the Free Software
16 -- along with this program; if not, write to the Free Software
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 -------------------------------------------------------------------------------*/
18 -------------------------------------------------------------------------------*/
19 /*-- Author :
19 /*-- Author :
20 Alexis Jeandet
20 Alexis Jeandet
21 -- Mail :
21 -- Mail :
22 alexis.jeandet@member.fsf.org
22 alexis.jeandet@member.fsf.org
23 ----------------------------------------------------------------------------*/
23 ----------------------------------------------------------------------------*/
24 #include "elffile.h"
24 #include "elffile.h"
25
25
26 ElfFile::ElfFile()
26 ElfFile::ElfFile()
27 :abstractExecFile()
27 :abstractExecFile()
28 {
28 {
29 this->opened = false;
29 this->opened = false;
30 this->type_elf = false;
30 this->type_elf = false;
31 this->elfFile = NULL;
31 this->elfFile = NULL;
32 this->e = NULL;
32 this->e = NULL;
33 }
33 }
34
34
35 ElfFile::ElfFile(const QString &File)
35 ElfFile::ElfFile(const QString &File)
36 :abstractExecFile()
36 :abstractExecFile()
37 {
37 {
38 this->opened = false;
38 this->opened = false;
39 this->type_elf = false;
39 this->type_elf = false;
40 this->elfFile = NULL;
40 this->elfFile = NULL;
41 this->e = NULL;
41 this->e = NULL;
42 this->p_fileName = File;
42 this->p_fileName = File;
43 openFile(File);
43 openFile(File);
44 }
44 }
45
45
46 ElfFile::~ElfFile()
47 {
48 closeFile();
49 if(scn)free(scn);
50 if(data)free(data);
51 for(int i=0;i<this->sections.count();i++)
52 {
53 delete this->sections.at(i);
54 }
55 this->sections.clear();
56 for(int i=0;i<this->Segments.count();i++)
57 {
58 free(this->Segments.at(i));
59 }
60 this->Segments.clear();
61 for(int i=0;i<symbols.count();i++)
62 {
63 delete this->symbols.at(i);
64 }
65 this->symbols.clear();
66 }
67
46 bool ElfFile::openFile(const QString &File)
68 bool ElfFile::openFile(const QString &File)
47 {
69 {
48 this->p_fileName = File;
70 this->p_fileName = File;
49 this->closeFile();
71 this->closeFile();
50 if(elf_version(EV_CURRENT)==EV_NONE)return 0;
72 if(elf_version(EV_CURRENT)==EV_NONE)return 0;
51 #ifdef _ELF_WINDOWS_
73 #ifdef _ELF_WINDOWS_
52 this->elfFile = open(File.toStdString().c_str(),O_RDONLY|O_BINARY ,0);
74 this->elfFile = open(File.toStdString().c_str(),O_RDONLY|O_BINARY ,0);
53 #else
75 #else
54 this->elfFile = open(File.toStdString().c_str(),O_RDONLY ,0);
76 this->elfFile = open(File.toStdString().c_str(),O_RDONLY ,0);
55 #endif
77 #endif
56 if(this->elfFile==NULL)return 0;
78 if(this->elfFile==NULL)return 0;
57 this->e = elf_begin(this->elfFile,ELF_C_READ,NULL);
79 this->e = elf_begin(this->elfFile,ELF_C_READ,NULL);
58 if(this->e==NULL)return 0;
80 if(this->e==NULL)return 0;
59 this->ek = elf_kind(this->e);
81 this->ek = elf_kind(this->e);
60 gelf_getehdr (this->e, &this->ehdr );
82 gelf_getehdr (this->e, &this->ehdr );
61 elf_getshdrstrndx (this->e, &this->shstrndx);
83 elf_getshdrstrndx (this->e, &this->shstrndx);
62 this->updateSegments();
84 this->updateSegments();
63 this->updateSections();
85 this->updateSections();
64 this->updateSymbols();
86 this->updateSymbols();
65 this->opened = true;
87 this->opened = true;
66 return 1;
88 return 1;
67 }
89 }
68
90
69 bool ElfFile::isopened()
91 bool ElfFile::isopened()
70 {
92 {
71 return this->opened;
93 return this->opened;
72 }
94 }
73
95
74 int ElfFile::closeFile()
96 int ElfFile::closeFile()
75 {
97 {
76 if(this->elfFile!=NULL)
98 if(this->elfFile!=NULL)
77 {
99 {
78 if(this->e!=NULL)
100 if(this->e!=NULL)
79 {
101 {
80 elf_end(this->e);
102 elf_end(this->e);
81 this->e = NULL;
103 this->e = NULL;
82 }
104 }
83 close(this->elfFile);
105 close(this->elfFile);
84 this->elfFile = NULL;
106 this->elfFile = NULL;
85 }
107 }
86 this->opened = false;
108 this->opened = false;
87 return 0;
109 return 0;
88 }
110 }
89
111
90
112
91 QList<codeFragment*> ElfFile::getFragments(QStringList fragmentList)
113 QList<codeFragment*> ElfFile::getFragments(QStringList fragmentList)
92 {
114 {
93 QList<codeFragment*> fragments;
115 QList<codeFragment*> fragments;
94 if (isopened())
116 if (isopened())
95 {
117 {
96 for(int i =0;i<fragmentList.count();i++)
118 for(int i =0;i<fragmentList.count();i++)
97 {
119 {
98 fragments.append(getFragment(fragmentList.at(i)));
120 fragments.append(getFragment(fragmentList.at(i)));
99 }
121 }
100 }
122 }
101 return fragments;
123 return fragments;
102 }
124 }
103
125
104 QList<codeFragment*> ElfFile::getFragments()
126 QList<codeFragment*> ElfFile::getFragments()
105 {
127 {
106 return getFragments(QStringList()<<".data"<<".text");
128 return getFragments(QStringList()<<".data"<<".text");
107 }
129 }
108
130
109 codeFragment *ElfFile::getFragment(const QString &name)
131 codeFragment *ElfFile::getFragment(const QString &name)
110 {
132 {
111 codeFragment* fragment= new codeFragment();
133 codeFragment* fragment= new codeFragment();
112 for(int i=0;i<getSectionCount();i++)
134 for(int i=0;i<getSectionCount();i++)
113 {
135 {
114 if(getSectionName(i) == name)
136 if(getSectionName(i) == name)
115 {
137 {
116 fragment->data =NULL;
138 fragment->data =NULL;
117 fragment->size = getSectionDatasz(i);
139 fragment->size = getSectionDatasz(i);
118 fragment->address = getSectionPaddr(i);
140 fragment->address = getSectionPaddr(i);
119 getSectionData(i,&fragment->data);
141 getSectionData(i,&fragment->data);
120 }
142 }
121 }
143 }
122
144
123 }
145 }
124
146
125
147
126
148
127
149
128
150
129
151
130
152
131 QString elfresolveMachine(Elf64_Half e_machine)
153 QString elfresolveMachine(Elf64_Half e_machine)
132 {
154 {
133 QString machineName;
155 QString machineName;
134 //Update from with bash script don't write it by yourself!
156 //Update from with bash script don't write it by yourself!
135 switch(e_machine)
157 switch(e_machine)
136 {
158 {
137 case EM_NONE:
159 case EM_NONE:
138 machineName = " No machine ";
160 machineName = " No machine ";
139 break;
161 break;
140 case EM_M32:
162 case EM_M32:
141 machineName = " AT&T WE 32100 ";
163 machineName = " AT&T WE 32100 ";
142 break;
164 break;
143 case EM_SPARC:
165 case EM_SPARC:
144 machineName = " SUN SPARC ";
166 machineName = " SUN SPARC ";
145 break;
167 break;
146 case EM_386:
168 case EM_386:
147 machineName = " Intel 80386 ";
169 machineName = " Intel 80386 ";
148 break;
170 break;
149 case EM_68K:
171 case EM_68K:
150 machineName = " Motorola m68k family ";
172 machineName = " Motorola m68k family ";
151 break;
173 break;
152 case EM_88K:
174 case EM_88K:
153 machineName = " Motorola m88k family ";
175 machineName = " Motorola m88k family ";
154 break;
176 break;
155 case EM_860:
177 case EM_860:
156 machineName = " Intel 80860 ";
178 machineName = " Intel 80860 ";
157 break;
179 break;
158 case EM_MIPS:
180 case EM_MIPS:
159 machineName = " MIPS R3000 big-endian ";
181 machineName = " MIPS R3000 big-endian ";
160 break;
182 break;
161 case EM_S370:
183 case EM_S370:
162 machineName = " IBM System/370 ";
184 machineName = " IBM System/370 ";
163 break;
185 break;
164 case EM_MIPS_RS3_LE:
186 case EM_MIPS_RS3_LE:
165 machineName = " MIPS R3000 little-endian ";
187 machineName = " MIPS R3000 little-endian ";
166 break;
188 break;
167 case EM_PARISC:
189 case EM_PARISC:
168 machineName = " HPPA ";
190 machineName = " HPPA ";
169 break;
191 break;
170 case EM_VPP500:
192 case EM_VPP500:
171 machineName = " Fujitsu VPP500 ";
193 machineName = " Fujitsu VPP500 ";
172 break;
194 break;
173 case EM_SPARC32PLUS:
195 case EM_SPARC32PLUS:
174 machineName = " Sun's \"v8plus\" ";
196 machineName = " Sun's \"v8plus\" ";
175 break;
197 break;
176 case EM_960:
198 case EM_960:
177 machineName = " Intel 80960 ";
199 machineName = " Intel 80960 ";
178 break;
200 break;
179 case EM_PPC:
201 case EM_PPC:
180 machineName = " PowerPC ";
202 machineName = " PowerPC ";
181 break;
203 break;
182 case EM_PPC64:
204 case EM_PPC64:
183 machineName = " PowerPC 64-bit ";
205 machineName = " PowerPC 64-bit ";
184 break;
206 break;
185 case EM_S390:
207 case EM_S390:
186 machineName = " IBM S390 ";
208 machineName = " IBM S390 ";
187 break;
209 break;
188 case EM_V800:
210 case EM_V800:
189 machineName = " NEC V800 series ";
211 machineName = " NEC V800 series ";
190 break;
212 break;
191 case EM_FR20:
213 case EM_FR20:
192 machineName = " Fujitsu FR20 ";
214 machineName = " Fujitsu FR20 ";
193 break;
215 break;
194 case EM_RH32:
216 case EM_RH32:
195 machineName = " TRW RH-32 ";
217 machineName = " TRW RH-32 ";
196 break;
218 break;
197 case EM_RCE:
219 case EM_RCE:
198 machineName = " Motorola RCE ";
220 machineName = " Motorola RCE ";
199 break;
221 break;
200 case EM_ARM:
222 case EM_ARM:
201 machineName = " ARM ";
223 machineName = " ARM ";
202 break;
224 break;
203 case EM_FAKE_ALPHA:
225 case EM_FAKE_ALPHA:
204 machineName = " Digital Alpha ";
226 machineName = " Digital Alpha ";
205 break;
227 break;
206 case EM_SH:
228 case EM_SH:
207 machineName = " Hitachi SH ";
229 machineName = " Hitachi SH ";
208 break;
230 break;
209 case EM_SPARCV9:
231 case EM_SPARCV9:
210 machineName = " SPARC v9 64-bit ";
232 machineName = " SPARC v9 64-bit ";
211 break;
233 break;
212 case EM_TRICORE:
234 case EM_TRICORE:
213 machineName = " Siemens Tricore ";
235 machineName = " Siemens Tricore ";
214 break;
236 break;
215 case EM_ARC:
237 case EM_ARC:
216 machineName = " Argonaut RISC Core ";
238 machineName = " Argonaut RISC Core ";
217 break;
239 break;
218 case EM_H8_300:
240 case EM_H8_300:
219 machineName = " Hitachi H8/300 ";
241 machineName = " Hitachi H8/300 ";
220 break;
242 break;
221 case EM_H8_300H:
243 case EM_H8_300H:
222 machineName = " Hitachi H8/300H ";
244 machineName = " Hitachi H8/300H ";
223 break;
245 break;
224 case EM_H8S:
246 case EM_H8S:
225 machineName = " Hitachi H8S ";
247 machineName = " Hitachi H8S ";
226 break;
248 break;
227 case EM_H8_500:
249 case EM_H8_500:
228 machineName = " Hitachi H8/500 ";
250 machineName = " Hitachi H8/500 ";
229 break;
251 break;
230 case EM_IA_64:
252 case EM_IA_64:
231 machineName = " Intel Merced ";
253 machineName = " Intel Merced ";
232 break;
254 break;
233 case EM_MIPS_X:
255 case EM_MIPS_X:
234 machineName = " Stanford MIPS-X ";
256 machineName = " Stanford MIPS-X ";
235 break;
257 break;
236 case EM_COLDFIRE:
258 case EM_COLDFIRE:
237 machineName = " Motorola Coldfire ";
259 machineName = " Motorola Coldfire ";
238 break;
260 break;
239 case EM_68HC12:
261 case EM_68HC12:
240 machineName = " Motorola M68HC12 ";
262 machineName = " Motorola M68HC12 ";
241 break;
263 break;
242 case EM_MMA:
264 case EM_MMA:
243 machineName = " Fujitsu MMA Multimedia Accelerator";
265 machineName = " Fujitsu MMA Multimedia Accelerator";
244 break;
266 break;
245 case EM_PCP:
267 case EM_PCP:
246 machineName = " Siemens PCP ";
268 machineName = " Siemens PCP ";
247 break;
269 break;
248 case EM_NCPU:
270 case EM_NCPU:
249 machineName = " Sony nCPU embeeded RISC ";
271 machineName = " Sony nCPU embeeded RISC ";
250 break;
272 break;
251 case EM_NDR1:
273 case EM_NDR1:
252 machineName = " Denso NDR1 microprocessor ";
274 machineName = " Denso NDR1 microprocessor ";
253 break;
275 break;
254 case EM_STARCORE:
276 case EM_STARCORE:
255 machineName = " Motorola Start*Core processor ";
277 machineName = " Motorola Start*Core processor ";
256 break;
278 break;
257 case EM_ME16:
279 case EM_ME16:
258 machineName = " Toyota ME16 processor ";
280 machineName = " Toyota ME16 processor ";
259 break;
281 break;
260 case EM_ST100:
282 case EM_ST100:
261 machineName = " STMicroelectronic ST100 processor ";
283 machineName = " STMicroelectronic ST100 processor ";
262 break;
284 break;
263 case EM_TINYJ:
285 case EM_TINYJ:
264 machineName = " Advanced Logic Corp. Tinyj emb.fam";
286 machineName = " Advanced Logic Corp. Tinyj emb.fam";
265 break;
287 break;
266 case EM_X86_64:
288 case EM_X86_64:
267 machineName = " AMD x86-64 architecture ";
289 machineName = " AMD x86-64 architecture ";
268 break;
290 break;
269 case EM_PDSP:
291 case EM_PDSP:
270 machineName = " Sony DSP Processor ";
292 machineName = " Sony DSP Processor ";
271 break;
293 break;
272 case EM_FX66:
294 case EM_FX66:
273 machineName = " Siemens FX66 microcontroller ";
295 machineName = " Siemens FX66 microcontroller ";
274 break;
296 break;
275 case EM_ST9PLUS:
297 case EM_ST9PLUS:
276 machineName = " STMicroelectronics ST9+ 8/16 mc ";
298 machineName = " STMicroelectronics ST9+ 8/16 mc ";
277 break;
299 break;
278 case EM_ST7:
300 case EM_ST7:
279 machineName = " STmicroelectronics ST7 8 bit mc ";
301 machineName = " STmicroelectronics ST7 8 bit mc ";
280 break;
302 break;
281 case EM_68HC16:
303 case EM_68HC16:
282 machineName = " Motorola MC68HC16 microcontroller ";
304 machineName = " Motorola MC68HC16 microcontroller ";
283 break;
305 break;
284 case EM_68HC11:
306 case EM_68HC11:
285 machineName = " Motorola MC68HC11 microcontroller ";
307 machineName = " Motorola MC68HC11 microcontroller ";
286 break;
308 break;
287 case EM_68HC08:
309 case EM_68HC08:
288 machineName = " Motorola MC68HC08 microcontroller ";
310 machineName = " Motorola MC68HC08 microcontroller ";
289 break;
311 break;
290 case EM_68HC05:
312 case EM_68HC05:
291 machineName = " Motorola MC68HC05 microcontroller ";
313 machineName = " Motorola MC68HC05 microcontroller ";
292 break;
314 break;
293 case EM_SVX:
315 case EM_SVX:
294 machineName = " Silicon Graphics SVx ";
316 machineName = " Silicon Graphics SVx ";
295 break;
317 break;
296 case EM_ST19:
318 case EM_ST19:
297 machineName = " STMicroelectronics ST19 8 bit mc ";
319 machineName = " STMicroelectronics ST19 8 bit mc ";
298 break;
320 break;
299 case EM_VAX:
321 case EM_VAX:
300 machineName = " Digital VAX ";
322 machineName = " Digital VAX ";
301 break;
323 break;
302 case EM_CRIS:
324 case EM_CRIS:
303 machineName = " Axis Communications 32-bit embedded processor ";
325 machineName = " Axis Communications 32-bit embedded processor ";
304 break;
326 break;
305 case EM_JAVELIN:
327 case EM_JAVELIN:
306 machineName = " Infineon Technologies 32-bit embedded processor ";
328 machineName = " Infineon Technologies 32-bit embedded processor ";
307 break;
329 break;
308 case EM_FIREPATH:
330 case EM_FIREPATH:
309 machineName = " Element 14 64-bit DSP Processor ";
331 machineName = " Element 14 64-bit DSP Processor ";
310 break;
332 break;
311 case EM_ZSP:
333 case EM_ZSP:
312 machineName = " LSI Logic 16-bit DSP Processor ";
334 machineName = " LSI Logic 16-bit DSP Processor ";
313 break;
335 break;
314 case EM_MMIX:
336 case EM_MMIX:
315 machineName = " Donald Knuth's educational 64-bit processor ";
337 machineName = " Donald Knuth's educational 64-bit processor ";
316 break;
338 break;
317 case EM_HUANY:
339 case EM_HUANY:
318 machineName = " Harvard University machine-independent object files ";
340 machineName = " Harvard University machine-independent object files ";
319 break;
341 break;
320 case EM_PRISM:
342 case EM_PRISM:
321 machineName = " SiTera Prism ";
343 machineName = " SiTera Prism ";
322 break;
344 break;
323 case EM_AVR:
345 case EM_AVR:
324 machineName = " Atmel AVR 8-bit microcontroller ";
346 machineName = " Atmel AVR 8-bit microcontroller ";
325 break;
347 break;
326 case EM_FR30:
348 case EM_FR30:
327 machineName = " Fujitsu FR30 ";
349 machineName = " Fujitsu FR30 ";
328 break;
350 break;
329 case EM_D10V:
351 case EM_D10V:
330 machineName = " Mitsubishi D10V ";
352 machineName = " Mitsubishi D10V ";
331 break;
353 break;
332 case EM_D30V:
354 case EM_D30V:
333 machineName = " Mitsubishi D30V ";
355 machineName = " Mitsubishi D30V ";
334 break;
356 break;
335 case EM_V850:
357 case EM_V850:
336 machineName = " NEC v850 ";
358 machineName = " NEC v850 ";
337 break;
359 break;
338 case EM_M32R:
360 case EM_M32R:
339 machineName = " Mitsubishi M32R ";
361 machineName = " Mitsubishi M32R ";
340 break;
362 break;
341 case EM_MN10300:
363 case EM_MN10300:
342 machineName = " Matsushita MN10300 ";
364 machineName = " Matsushita MN10300 ";
343 break;
365 break;
344 case EM_MN10200:
366 case EM_MN10200:
345 machineName = " Matsushita MN10200 ";
367 machineName = " Matsushita MN10200 ";
346 break;
368 break;
347 case EM_PJ:
369 case EM_PJ:
348 machineName = " picoJava ";
370 machineName = " picoJava ";
349 break;
371 break;
350 case EM_OPENRISC:
372 case EM_OPENRISC:
351 machineName = " OpenRISC 32-bit embedded processor ";
373 machineName = " OpenRISC 32-bit embedded processor ";
352 break;
374 break;
353 case EM_ARC_A5:
375 case EM_ARC_A5:
354 machineName = " ARC Cores Tangent-A5 ";
376 machineName = " ARC Cores Tangent-A5 ";
355 break;
377 break;
356 case EM_XTENSA:
378 case EM_XTENSA:
357 machineName = " Tensilica Xtensa Architecture ";
379 machineName = " Tensilica Xtensa Architecture ";
358 break;
380 break;
359 case EM_AARCH64:
381 case EM_AARCH64:
360 machineName = " ARM AARCH64 ";
382 machineName = " ARM AARCH64 ";
361 break;
383 break;
362 case EM_TILEPRO:
384 case EM_TILEPRO:
363 machineName = " Tilera TILEPro ";
385 machineName = " Tilera TILEPro ";
364 break;
386 break;
365 case EM_MICROBLAZE:
387 case EM_MICROBLAZE:
366 machineName = " Xilinx MicroBlaze ";
388 machineName = " Xilinx MicroBlaze ";
367 break;
389 break;
368 case EM_TILEGX:
390 case EM_TILEGX:
369 machineName = " Tilera TILE-Gx ";
391 machineName = " Tilera TILE-Gx ";
370 break;
392 break;
371 case EM_NUM:
393 case EM_NUM:
372 machineName = "";
394 machineName = "";
373 break;
395 break;
374 default:
396 default:
375 machineName ="Unknow Machine";
397 machineName ="Unknow Machine";
376 break;
398 break;
377 }
399 }
378 return machineName;
400 return machineName;
379 }
401 }
380
402
381
403
382
404
383
405
384 QString ElfFile::getClass()
406 QString ElfFile::getClass()
385 {
407 {
386 if(this->e!=NULL)
408 if(this->e!=NULL)
387 {
409 {
388 int eclass = gelf_getclass(this->e);
410 int eclass = gelf_getclass(this->e);
389 if(eclass==ELFCLASS32)return "ELF32";
411 if(eclass==ELFCLASS32)return "ELF32";
390 if(eclass==ELFCLASS64)return "ELF64";
412 if(eclass==ELFCLASS64)return "ELF64";
391 }
413 }
392 return "none";
414 return "none";
393 }
415 }
394
416
395
417
396 bool ElfFile::iself()
418 bool ElfFile::iself()
397 {
419 {
398 return (this->getType()!="Unknow");
420 return (this->getType()!="Unknow");
399 }
421 }
400
422
401 QString ElfFile::getArchitecture()
423 QString ElfFile::getArchitecture()
402 {
424 {
403 if(this->e!=NULL)
425 if(this->e!=NULL)
404 {
426 {
405 return elfresolveMachine(this->ehdr.e_machine);
427 return elfresolveMachine(this->ehdr.e_machine);
406 }
428 }
407 return "";
429 return "";
408 }
430 }
409
431
410
432
411 QString ElfFile::getType()
433 QString ElfFile::getType()
412 {
434 {
413 QString kind("");
435 QString kind("");
414 if(this->e!=NULL)
436 if(this->e!=NULL)
415 {
437 {
416 switch(this->ek)
438 switch(this->ek)
417 {
439 {
418 case ELF_K_AR:
440 case ELF_K_AR:
419 kind = "Archive";
441 kind = "Archive";
420 break;
442 break;
421 case ELF_K_ELF:
443 case ELF_K_ELF:
422 kind = "Elf";
444 kind = "Elf";
423 break;
445 break;
424 case ELF_K_COFF:
446 case ELF_K_COFF:
425 kind = "COFF";
447 kind = "COFF";
426 break;
448 break;
427 case ELF_K_NUM:
449 case ELF_K_NUM:
428 kind = "NUM";
450 kind = "NUM";
429 break;
451 break;
430 case ELF_K_NONE:
452 case ELF_K_NONE:
431 kind = "Data";
453 kind = "Data";
432 break;
454 break;
433 default:
455 default:
434 kind = "Unknow";
456 kind = "Unknow";
435 break;
457 break;
436 }
458 }
437 }
459 }
438 return kind;
460 return kind;
439 }
461 }
440
462
441 QString ElfFile::getEndianness()
463 QString ElfFile::getEndianness()
442 {
464 {
443 if(this->e!=NULL)
465 if(this->e!=NULL)
444 {
466 {
445 if(this->ehdr.e_ident[EI_DATA]==ELFDATA2LSB)return "2's complement, little endian";
467 if(this->ehdr.e_ident[EI_DATA]==ELFDATA2LSB)return "2's complement, little endian";
446 if(this->ehdr.e_ident[EI_DATA]==ELFDATA2MSB)return "2's complement, big endian";
468 if(this->ehdr.e_ident[EI_DATA]==ELFDATA2MSB)return "2's complement, big endian";
447 }
469 }
448 return "none";
470 return "none";
449 }
471 }
450
472
451 QString ElfFile::getABI()
473 QString ElfFile::getABI()
452 {
474 {
453 if(this->e!=NULL)
475 if(this->e!=NULL)
454 {
476 {
455 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_NONE)return "UNIX System V ABI";
477 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_NONE)return "UNIX System V ABI";
456 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_SYSV)return "Alias";
478 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_SYSV)return "Alias";
457 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_HPUX)return "HP-UX";
479 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_HPUX)return "HP-UX";
458 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_NETBSD)return "NetBSD";
480 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_NETBSD)return "NetBSD";
459 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_GNU)return "Object uses GNU ELF extensions";
481 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_GNU)return "Object uses GNU ELF extensions";
460 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_LINUX)return "Compatibility alias";
482 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_LINUX)return "Compatibility alias";
461 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_SOLARIS)return "Sun Solaris";
483 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_SOLARIS)return "Sun Solaris";
462 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_AIX)return "IBM AIX";
484 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_AIX)return "IBM AIX";
463 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_IRIX)return "SGI Irix";
485 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_IRIX)return "SGI Irix";
464 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_FREEBSD)return "FreeBSD";
486 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_FREEBSD)return "FreeBSD";
465 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_TRU64)return "Compaq TRU64 UNIX";
487 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_TRU64)return "Compaq TRU64 UNIX";
466 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_MODESTO)return " Novell Modesto";
488 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_MODESTO)return " Novell Modesto";
467 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_OPENBSD)return "OpenBSD";
489 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_OPENBSD)return "OpenBSD";
468 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_ARM_AEABI)return "ARM EABI";
490 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_ARM_AEABI)return "ARM EABI";
469 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_ARM)return "ARM";
491 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_ARM)return "ARM";
470 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_STANDALONE)return "Standalone (embedded) application";
492 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_STANDALONE)return "Standalone (embedded) application";
471 }
493 }
472 return "none";
494 return "none";
473 }
495 }
474
496
475
497
476 qint64 ElfFile::getVersion()
498 qint64 ElfFile::getVersion()
477 {
499 {
478 if(this->e!=NULL)
500 if(this->e!=NULL)
479 {
501 {
480 return this->ehdr.e_version;
502 return this->ehdr.e_version;
481 }
503 }
482 }
504 }
483
505
484 qint64 ElfFile::getEntryPointAddress()
506 qint64 ElfFile::getEntryPointAddress()
485 {
507 {
486 if(this->e!=NULL)
508 if(this->e!=NULL)
487 {
509 {
488 return this->ehdr.e_entry;
510 return this->ehdr.e_entry;
489 }
511 }
490 }
512 }
491
513
492
514
493 int ElfFile::getSectionCount()
515 int ElfFile::getSectionCount()
494 {
516 {
495 return (int)this->SectionCount;
517 return (int)this->SectionCount;
496 }
518 }
497
519
498 int ElfFile::getSymbolCount()
520 int ElfFile::getSymbolCount()
499 {
521 {
500 return (int)this->SymbolCount;
522 return (int)this->SymbolCount;
501 }
523 }
502
524
503
525
504 int ElfFile::getSegmentCount()
526 int ElfFile::getSegmentCount()
505 {
527 {
506 return (int)this->SegmentCount;
528 return (int)this->SegmentCount;
507 }
529 }
508
530
509
531
510 QString ElfFile::getSegmentType(int index)
532 QString ElfFile::getSegmentType(int index)
511 {
533 {
512 QString type("");
534 QString type("");
513 if(this->e!=NULL)
535 if(this->e!=NULL)
514 {
536 {
515 if(index < this->Segments.count())
537 if(index < this->Segments.count())
516 {
538 {
517 switch(this->Segments.at(index)->p_type)
539 switch(this->Segments.at(index)->p_type)
518 {
540 {
519 case PT_NULL:
541 case PT_NULL:
520 type = "Program header table entry unused";
542 type = "Program header table entry unused";
521 break;
543 break;
522 case PT_LOAD:
544 case PT_LOAD:
523 type = "Loadable program segment";
545 type = "Loadable program segment";
524 break;
546 break;
525 case PT_DYNAMIC :
547 case PT_DYNAMIC :
526 type = "Dynamic linking information";
548 type = "Dynamic linking information";
527 break;
549 break;
528 case PT_INTERP:
550 case PT_INTERP:
529 type ="Program interpreter";
551 type ="Program interpreter";
530 break;
552 break;
531 case PT_NOTE:
553 case PT_NOTE:
532 type = "Auxiliary information";
554 type = "Auxiliary information";
533 break;
555 break;
534 case PT_SHLIB:
556 case PT_SHLIB:
535 type = "Reserved";
557 type = "Reserved";
536 break;
558 break;
537 case PT_PHDR:
559 case PT_PHDR:
538 type = "Entry for header table itself";
560 type = "Entry for header table itself";
539 break;
561 break;
540 case PT_TLS:
562 case PT_TLS:
541 type = "Thread-local storage segment";
563 type = "Thread-local storage segment";
542 break;
564 break;
543 case PT_NUM:
565 case PT_NUM:
544 type = "Number of defined types";
566 type = "Number of defined types";
545 break;
567 break;
546 case PT_LOOS:
568 case PT_LOOS:
547 type = "Start of OS-specific";
569 type = "Start of OS-specific";
548 break;
570 break;
549 case PT_SUNWSTACK:
571 case PT_SUNWSTACK:
550 type = "Stack segment";
572 type = "Stack segment";
551 break;
573 break;
552 case PT_LOPROC:
574 case PT_LOPROC:
553 type = "Start of processor-specific";
575 type = "Start of processor-specific";
554 break;
576 break;
555 case PT_HIPROC:
577 case PT_HIPROC:
556 type = "End of processor-specific";
578 type = "End of processor-specific";
557 break;
579 break;
558 default:
580 default:
559 type = "Unknow Section Type";
581 type = "Unknow Section Type";
560 break;
582 break;
561 }
583 }
562 }
584 }
563 }
585 }
564
586
565 return type;
587 return type;
566 }
588 }
567
589
568
590
569 qint64 ElfFile::getSegmentOffset(int index)
591 qint64 ElfFile::getSegmentOffset(int index)
570 {
592 {
571 int64_t Offset;
593 int64_t Offset;
572 if(this->e!=NULL)
594 if(this->e!=NULL)
573 {
595 {
574 if(index < this->Segments.count())
596 if(index < this->Segments.count())
575 {
597 {
576 Offset = (int64_t)this->Segments.at(index)->p_offset;
598 Offset = (int64_t)this->Segments.at(index)->p_offset;
577 }
599 }
578 }
600 }
579 return Offset;
601 return Offset;
580 }
602 }
581
603
582
604
583 qint64 ElfFile::getSegmentVaddr(int index)
605 qint64 ElfFile::getSegmentVaddr(int index)
584 {
606 {
585 int64_t Vaddr = 0;
607 int64_t Vaddr = 0;
586 if(this->e!=NULL)
608 if(this->e!=NULL)
587 {
609 {
588 if(index < this->Segments.count())
610 if(index < this->Segments.count())
589 {
611 {
590 Vaddr = (int64_t)this->Segments.at(index)->p_vaddr;
612 Vaddr = (int64_t)this->Segments.at(index)->p_vaddr;
591 }
613 }
592 }
614 }
593 return Vaddr;
615 return Vaddr;
594 }
616 }
595
617
596
618
597 qint64 ElfFile::getSegmentPaddr(int index)
619 qint64 ElfFile::getSegmentPaddr(int index)
598 {
620 {
599 int64_t Paddr=0;
621 int64_t Paddr=0;
600 if(this->e!=NULL)
622 if(this->e!=NULL)
601 {
623 {
602 if(index < this->Segments.count())
624 if(index < this->Segments.count())
603 {
625 {
604 Paddr = (int64_t)this->Segments.at(index)->p_paddr;
626 Paddr = (int64_t)this->Segments.at(index)->p_paddr;
605 }
627 }
606 }
628 }
607 return Paddr;
629 return Paddr;
608 }
630 }
609
631
610 qint64 ElfFile::getSectionPaddr(int index)
632 qint64 ElfFile::getSectionPaddr(int index)
611 {
633 {
612 int64_t Paddr=0;
634 int64_t Paddr=0;
613 if(this->e!=NULL)
635 if(this->e!=NULL)
614 {
636 {
615 if(index < this->sections.count())
637 if(index < this->sections.count())
616 {
638 {
617 Paddr = (int64_t)this->sections.at(index)->section_header->sh_addr;
639 Paddr = (int64_t)this->sections.at(index)->section_header->sh_addr;
618 }
640 }
619 }
641 }
620 return Paddr;
642 return Paddr;
621 }
643 }
622
644
623
645
624 qint64 ElfFile::getSegmentFilesz(int index)
646 qint64 ElfFile::getSegmentFilesz(int index)
625 {
647 {
626 int64_t FileSz=0;
648 int64_t FileSz=0;
627 if(this->e!=NULL)
649 if(this->e!=NULL)
628 {
650 {
629 if(index < this->Segments.count())
651 if(index < this->Segments.count())
630 {
652 {
631 FileSz = (int64_t)this->Segments.at(index)->p_filesz;
653 FileSz = (int64_t)this->Segments.at(index)->p_filesz;
632 }
654 }
633 }
655 }
634 return FileSz;
656 return FileSz;
635 }
657 }
636
658
637 qint64 ElfFile::getSectionDatasz(int index)
659 qint64 ElfFile::getSectionDatasz(int index)
638 {
660 {
639 int64_t DataSz=0;
661 int64_t DataSz=0;
640 if(this->e!=NULL)
662 if(this->e!=NULL)
641 {
663 {
642 if(index < this->sections.count())
664 if(index < this->sections.count())
643 {
665 {
644 DataSz = (int64_t)this->sections.at(index)->data->d_size;
666 DataSz = (int64_t)this->sections.at(index)->data->d_size;
645 }
667 }
646 }
668 }
647 return DataSz;
669 return DataSz;
648 }
670 }
649
671
650 bool ElfFile::getSectionData(int index, char **buffer)
672 bool ElfFile::getSectionData(int index, char **buffer)
651 {
673 {
652 if(this->e!=NULL)
674 if(this->e!=NULL)
653 {
675 {
654 if(index < this->sections.count())
676 if(index < this->sections.count())
655 {
677 {
656 *buffer = (char *)this->sections.at(index)->data->d_buf;
678 *buffer = (char *)this->sections.at(index)->data->d_buf;
657 return true;
679 return true;
658 }
680 }
659 }
681 }
660 return false;
682 return false;
661 }
683 }
662
684
663
685
664 qint64 ElfFile::getSegmentMemsz(int index)
686 qint64 ElfFile::getSegmentMemsz(int index)
665 {
687 {
666 int64_t MemSz=0;
688 int64_t MemSz=0;
667 if(this->e!=NULL)
689 if(this->e!=NULL)
668 {
690 {
669 if(index < this->Segments.count())
691 if(index < this->Segments.count())
670 {
692 {
671 MemSz = (int64_t)this->Segments.at(index)->p_memsz;
693 MemSz = (int64_t)this->Segments.at(index)->p_memsz;
672 }
694 }
673 }
695 }
674 return MemSz;
696 return MemSz;
675 }
697 }
676
698
677 qint64 ElfFile::getSectionMemsz(int index)
699 qint64 ElfFile::getSectionMemsz(int index)
678 {
700 {
679 int64_t MemSz=0;
701 int64_t MemSz=0;
680 if(this->e!=NULL)
702 if(this->e!=NULL)
681 {
703 {
682 if(index < this->sections.count())
704 if(index < this->sections.count())
683 {
705 {
684 MemSz = (int64_t)this->sections.at(index)->section_header->sh_size;
706 MemSz = (int64_t)this->sections.at(index)->section_header->sh_size;
685 }
707 }
686 }
708 }
687 return MemSz;
709 return MemSz;
688 }
710 }
689
711
690
712
691 QString ElfFile::getSegmentFlags(int index)
713 QString ElfFile::getSegmentFlags(int index)
692 {
714 {
693 QString flags("");
715 QString flags("");
694 if(this->e!=NULL)
716 if(this->e!=NULL)
695 {
717 {
696 if(index < this->Segments.count())
718 if(index < this->Segments.count())
697 {
719 {
698 if((this->Segments.at(index)->p_flags&PF_X) == PF_X)flags+="x";
720 if((this->Segments.at(index)->p_flags&PF_X) == PF_X)flags+="x";
699 if((this->Segments.at(index)->p_flags&PF_W) == PF_W)flags+="w";
721 if((this->Segments.at(index)->p_flags&PF_W) == PF_W)flags+="w";
700 if((this->Segments.at(index)->p_flags&PF_R) == PF_R)flags+="r";
722 if((this->Segments.at(index)->p_flags&PF_R) == PF_R)flags+="r";
701 if((this->Segments.at(index)->p_flags&PF_MASKOS) == PF_MASKOS)flags+=" OS-specific";
723 if((this->Segments.at(index)->p_flags&PF_MASKOS) == PF_MASKOS)flags+=" OS-specific";
702 if((this->Segments.at(index)->p_flags&PF_MASKPROC) == PF_MASKPROC)flags+=" Processor-specific";
724 if((this->Segments.at(index)->p_flags&PF_MASKPROC) == PF_MASKPROC)flags+=" Processor-specific";
703 }
725 }
704 }
726 }
705 return flags;
727 return flags;
706 }
728 }
707
729
708
730
709 QString ElfFile::getSectionName(int index)
731 QString ElfFile::getSectionName(int index)
710 {
732 {
711 if((index<sections.count()) && (index>=0))
733 if((index<sections.count()) && (index>=0))
712 {
734 {
713 char* nameChr = elf_strptr(this->e , this->shstrndx , this->sections.at(index)->section_header->sh_name);
735 char* nameChr = elf_strptr(this->e , this->shstrndx , this->sections.at(index)->section_header->sh_name);
714 return QString(nameChr);
736 return QString(nameChr);
715 }
737 }
716 return "";
738 return "";
717 }
739 }
718
740
719
741
720 void ElfFile::updateSections()
742 void ElfFile::updateSections()
721 {
743 {
722 for(int i=0;i<this->sections.count();i++)
744 for(int i=0;i<this->sections.count();i++)
723 {
745 {
724 delete this->sections.at(i);
746 delete this->sections.at(i);
725 }
747 }
726 this->sections.clear();
748 this->sections.clear();
727 this->scn = elf_nextscn (this->e , NULL );
749 this->scn = elf_nextscn (this->e , NULL );
728 this->SectionCount = 0;
750 this->SectionCount = 0;
729 while( this->scn != NULL )
751 while( this->scn != NULL )
730 {
752 {
731 GElf_Shdr* shdr = (GElf_Shdr*)malloc(sizeof(GElf_Shdr));
753 GElf_Shdr* shdr = (GElf_Shdr*)malloc(sizeof(GElf_Shdr));
732 gelf_getshdr ( this->scn , shdr );
754 gelf_getshdr ( this->scn , shdr );
733 Elf_Data* data = elf_getdata(this->scn, NULL);
755 Elf_Data* data = elf_getdata(this->scn, NULL);
734 this->sections.append(new Elf_Section(data,shdr));
756 this->sections.append(new Elf_Section(data,shdr));
735 this->SectionCount+=1;
757 this->SectionCount+=1;
736 this->scn = elf_nextscn(e , scn);
758 this->scn = elf_nextscn(e , scn);
737 }
759 }
738 }
760 }
739
761
740
762
741 void ElfFile::updateSegments()
763 void ElfFile::updateSegments()
742 {
764 {
743 elf_getphdrnum (this->e , &this->SegmentCount);
765 elf_getphdrnum (this->e , &this->SegmentCount);
744 for(int i=0;i<this->Segments.count();i++)
766 for(int i=0;i<this->Segments.count();i++)
745 {
767 {
746 free(this->Segments.at(i));
768 free(this->Segments.at(i));
747 }
769 }
748 this->Segments.clear();
770 this->Segments.clear();
749 for(int i=0;i<this->SegmentCount;i++)
771 for(int i=0;i<this->SegmentCount;i++)
750 {
772 {
751 GElf_Phdr* header=(GElf_Phdr*)malloc(sizeof(GElf_Phdr));
773 GElf_Phdr* header=(GElf_Phdr*)malloc(sizeof(GElf_Phdr));
752 gelf_getphdr (this->e , i , header );
774 gelf_getphdr (this->e , i , header );
753 this->Segments.append(header);
775 this->Segments.append(header);
754 }
776 }
755 }
777 }
756
778
757 void ElfFile::updateSymbols()
779 void ElfFile::updateSymbols()
758 {
780 {
759 for(int i=0;i<symbols.count();i++)
781 for(int i=0;i<symbols.count();i++)
760 {
782 {
761 delete this->symbols.at(i);
783 delete this->symbols.at(i);
762 }
784 }
763 this->symbols.clear();
785 this->symbols.clear();
764 updateSections(); //Useless in most case but safer to do it
786 updateSections(); //Useless in most case but safer to do it
765 for(int i=0;i<SectionCount;i++)
787 for(int i=0;i<SectionCount;i++)
766 {
788 {
767 //First find Symbol table
789 //First find Symbol table
768 if(this->getSectionName(i)==".symtab")
790 if(this->getSectionName(i)==".symtab")
769 {
791 {
770 Elf_Section* sec = sections.at(i);
792 Elf_Section* sec = sections.at(i);
771 this->SymbolCount = sec->section_header->sh_size / sec->section_header->sh_entsize;
793 this->SymbolCount = sec->section_header->sh_size / sec->section_header->sh_entsize;
772 //Then list all symbols
794 //Then list all symbols
773 for(int j=0;j<this->SymbolCount;j++)
795 for(int j=0;j<this->SymbolCount;j++)
774 {
796 {
775 GElf_Sym* esym = (GElf_Sym*)malloc(sizeof(GElf_Sym));
797 GElf_Sym* esym = (GElf_Sym*)malloc(sizeof(GElf_Sym));
776 gelf_getsym(sec->data, j, esym);
798 gelf_getsym(sec->data, j, esym);
777 QString name = elf_strptr(this->e,sec->section_header->sh_link,esym->st_name);
799 QString name = elf_strptr(this->e,sec->section_header->sh_link,esym->st_name);
778 Elf_Symbol* sym = new Elf_Symbol(name,esym);
800 Elf_Symbol* sym = new Elf_Symbol(name,esym);
779 symbols.append(sym);
801 symbols.append(sym);
780 }
802 }
781 }
803 }
782 }
804 }
783
805
784 }
806 }
785
807
786
808
787
809
788 QString ElfFile::getSectionType(int index)
810 QString ElfFile::getSectionType(int index)
789 {
811 {
790 QString type("");
812 QString type("");
791 if(this->e!=NULL)
813 if(this->e!=NULL)
792 {
814 {
793 if(index < this->Segments.count())
815 if(index < this->Segments.count())
794 {
816 {
795 switch(this->Segments.at(index)->p_type)
817 switch(this->Segments.at(index)->p_type)
796 {
818 {
797 case SHT_NULL : type = "Section header table entry unused"; break;
819 case SHT_NULL : type = "Section header table entry unused"; break;
798 case SHT_PROGBITS : type = "Program data"; break;
820 case SHT_PROGBITS : type = "Program data"; break;
799 case SHT_SYMTAB : type = "Symbol table"; break;
821 case SHT_SYMTAB : type = "Symbol table"; break;
800 case SHT_STRTAB : type = "String table"; break;
822 case SHT_STRTAB : type = "String table"; break;
801 case SHT_RELA : type = "Relocation entries with addends"; break;
823 case SHT_RELA : type = "Relocation entries with addends"; break;
802 case SHT_HASH : type = "Symbol hash table"; break;
824 case SHT_HASH : type = "Symbol hash table"; break;
803 case SHT_DYNAMIC : type = "Dynamic linking information"; break;
825 case SHT_DYNAMIC : type = "Dynamic linking information"; break;
804 case SHT_NOTE : type = "Notes"; break;
826 case SHT_NOTE : type = "Notes"; break;
805 case SHT_NOBITS :type = "Program space with no data (bss)"; break;
827 case SHT_NOBITS :type = "Program space with no data (bss)"; break;
806 case SHT_REL :type = "Relocation entries, no addends"; break;
828 case SHT_REL :type = "Relocation entries, no addends"; break;
807 case SHT_SHLIB : type = "Reserved"; break;
829 case SHT_SHLIB : type = "Reserved"; break;
808 case SHT_DYNSYM : type = "Dynamic linker symbol table"; break;
830 case SHT_DYNSYM : type = "Dynamic linker symbol table"; break;
809 case SHT_INIT_ARRAY : type = "Array of constructors"; break;
831 case SHT_INIT_ARRAY : type = "Array of constructors"; break;
810 case SHT_FINI_ARRAY : type = "Array of destructors"; break;
832 case SHT_FINI_ARRAY : type = "Array of destructors"; break;
811 case SHT_PREINIT_ARRAY : type = "Array of pre-constructors"; break;
833 case SHT_PREINIT_ARRAY : type = "Array of pre-constructors"; break;
812 case SHT_GROUP : type = "Section group"; break;
834 case SHT_GROUP : type = "Section group"; break;
813 case SHT_SYMTAB_SHNDX : type = "Extended section indeces"; break;
835 case SHT_SYMTAB_SHNDX : type = "Extended section indeces"; break;
814 case SHT_NUM : type = "Number of defined types. "; break;
836 case SHT_NUM : type = "Number of defined types. "; break;
815 case SHT_LOOS : type = "Start OS-specific. "; break;
837 case SHT_LOOS : type = "Start OS-specific. "; break;
816 case SHT_LOSUNW : type = "Sun-specific low bound. "; break;
838 case SHT_LOSUNW : type = "Sun-specific low bound. "; break;
817 case SHT_SUNW_COMDAT : type = " "; break;
839 case SHT_SUNW_COMDAT : type = " "; break;
818 case SHT_SUNW_syminfo : type = " "; break;
840 case SHT_SUNW_syminfo : type = " "; break;
819 case SHT_GNU_verdef : type = "Version definition section. "; break;
841 case SHT_GNU_verdef : type = "Version definition section. "; break;
820 case SHT_GNU_verneed : type = "Version needs section. "; break;
842 case SHT_GNU_verneed : type = "Version needs section. "; break;
821 case SHT_GNU_versym : type = "Version symbol table. "; break;
843 case SHT_GNU_versym : type = "Version symbol table. "; break;
822 case SHT_LOPROC : type = "Start of processor-specific"; break;
844 case SHT_LOPROC : type = "Start of processor-specific"; break;
823 case SHT_HIPROC : type = "End of processor-specific"; break;
845 case SHT_HIPROC : type = "End of processor-specific"; break;
824 case SHT_HIUSER : type = "End of application-specific"; break;
846 case SHT_HIUSER : type = "End of application-specific"; break;
825 }
847 }
826 }
848 }
827 }
849 }
828 return type;
850 return type;
829 }
851 }
830
852
853 int ElfFile::getSectionIndex(QString name)
854 {
855 if(this->e!=NULL)
856 {
857 for(int i=0;i<sections.count();i++)
858 {
859 if(getSectionName(i)==name)
860 return i;
861 }
862 }
863 return -1;
864 }
865
831 QString ElfFile::getSymbolName(int index)
866 QString ElfFile::getSymbolName(int index)
832 {
867 {
833 if(this->e!=NULL)
868 if(this->e!=NULL)
834 {
869 {
835 if(index < this->symbols.count())
870 if(index < this->symbols.count())
836 {
871 {
837 return symbols.at(index)->name;
872 return symbols.at(index)->name;
838 }
873 }
839 }
874 }
840 return "";
875 return "";
841 }
876 }
842
877
843 QString ElfFile::getSymbolType(int index)
878 QString ElfFile::getSymbolType(int index)
844 {
879 {
845 if(this->e!=NULL)
880 if(this->e!=NULL)
846 {
881 {
847 if(index < this->symbols.count())
882 if(index < this->symbols.count())
848 {
883 {
849 int type = GELF_ST_TYPE(symbols.at(index)->sym->st_info);
884 int type = GELF_ST_TYPE(symbols.at(index)->sym->st_info);
850 switch(type)
885 switch(type)
851 {
886 {
852 case STT_NOTYPE:
887 case STT_NOTYPE:
853 return "No Type";
888 return "No Type";
854 break;
889 break;
855 case STT_OBJECT:
890 case STT_OBJECT:
856 return "Object";
891 return "Object";
857 break;
892 break;
858 case STT_FUNC:
893 case STT_FUNC:
859 return "Function";
894 return "Function";
860 break;
895 break;
861 case STT_SECTION:
896 case STT_SECTION:
862 return "Section";
897 return "Section";
863 break;
898 break;
864 case STT_FILE:
899 case STT_FILE:
865 return "File";
900 return "File";
866 break;
901 break;
867 case STT_COMMON:
902 case STT_COMMON:
868 return "Common data object";
903 return "Common data object";
869 break;
904 break;
870 case STT_TLS:
905 case STT_TLS:
871 return "Thread-local data object";
906 return "Thread-local data object";
872 break;
907 break;
873 case STT_NUM:
908 case STT_NUM:
874 return "Number of defined types";
909 return "Number of defined types";
875 break;
910 break;
876 case STT_LOOS:
911 case STT_LOOS:
877 return "Start of OS-specific";
912 return "Start of OS-specific";
878 break;
913 break;
879 case STT_HIOS:
914 case STT_HIOS:
880 return "End of OS-specific";
915 return "End of OS-specific";
881 break;
916 break;
882 case STT_LOPROC:
917 case STT_LOPROC:
883 return "Start of processor-specific";
918 return "Start of processor-specific";
884 break;
919 break;
885 case STT_HIPROC:
920 case STT_HIPROC:
886 return "End of processor-specific";
921 return "End of processor-specific";
887 break;
922 break;
888 default:
923 default:
889 return "none";
924 return "none";
890 break;
925 break;
891 }
926 }
892 }
927 }
893 }
928 }
894 return "none";
929 return "none";
895 }
930 }
896
931
897 quint64 ElfFile::getSymbolSize(int index)
932 quint64 ElfFile::getSymbolSize(int index)
898 {
933 {
899 if(this->e!=NULL)
934 if(this->e!=NULL)
900 {
935 {
901 if((index < this->symbols.count()) && (index>=0))
936 if((index < this->symbols.count()) && (index>=0))
902 {
937 {
903 return symbols.at(index)->sym->st_size;
938 return symbols.at(index)->sym->st_size;
904 }
939 }
905 }
940 }
906 return 0;
941 return 0;
907 }
942 }
908
943
909 QString ElfFile::getSymbolSectionName(int index)
944 QString ElfFile::getSymbolSectionName(int index)
910 {
945 {
911 if(this->e!=NULL)
946 if(this->e!=NULL)
912 {
947 {
913 if((index < this->symbols.count()) && (index>=0))
948 if((index < this->symbols.count()) && (index>=0))
914 {
949 {
915 return getSectionName(symbols.at(index)->sym->st_shndx-1);
950 return getSectionName(symbols.at(index)->sym->st_shndx-1);
916 }
951 }
917 }
952 }
918 return "none";
953 return "none";
919 }
954 }
920
955
921 int ElfFile::getSymbolSectionIndex(int index)
956 int ElfFile::getSymbolSectionIndex(int index)
922 {
957 {
923 if(this->e!=NULL)
958 if(this->e!=NULL)
924 {
959 {
925 if((index < this->symbols.count()) && (index>=0))
960 if((index < this->symbols.count()) && (index>=0))
926 {
961 {
927 return symbols.at(index)->sym->st_shndx;
962 return symbols.at(index)->sym->st_shndx;
928 }
963 }
929 }
964 }
930 return 0;
965 return 0;
931 }
966 }
932
967
933 quint64 ElfFile::getSymbolAddress(int index)
968 quint64 ElfFile::getSymbolAddress(int index)
934 {
969 {
935 if(this->e!=NULL)
970 if(this->e!=NULL)
936 {
971 {
937 if((index < this->symbols.count()) && (index>=0))
972 if((index < this->symbols.count()) && (index>=0))
938 {
973 {
939 return symbols.at(index)->sym->st_value;
974 return symbols.at(index)->sym->st_value;
940 }
975 }
941 }
976 }
942 return 0;
977 return 0;
943 }
978 }
944
979
945 QString ElfFile::getSymbolLinkType(int index)
980 QString ElfFile::getSymbolLinkType(int index)
946 {
981 {
947 if(this->e!=NULL)
982 if(this->e!=NULL)
948 {
983 {
949 if(index < this->symbols.count())
984 if(index < this->symbols.count())
950 {
985 {
951 int btype = GELF_ST_BIND(symbols.at(index)->sym->st_info);
986 int btype = GELF_ST_BIND(symbols.at(index)->sym->st_info);
952 switch(btype)
987 switch(btype)
953 {
988 {
954 case STB_LOCAL:
989 case STB_LOCAL:
955 return "Local";
990 return "Local";
956 break;
991 break;
957 case STB_GLOBAL:
992 case STB_GLOBAL:
958 return "Global";
993 return "Global";
959 break;
994 break;
960 case STB_WEAK:
995 case STB_WEAK:
961 return "Weak";
996 return "Weak";
962 break;
997 break;
963 case STB_NUM:
998 case STB_NUM:
964 return "Number of defined types";
999 return "Number of defined types";
965 break;
1000 break;
966 case STB_LOOS:
1001 case STB_LOOS:
967 return "Start of OS-specific";
1002 return "Start of OS-specific";
968 break;
1003 break;
969 case STB_HIOS:
1004 case STB_HIOS:
970 return "End of OS-specific";
1005 return "End of OS-specific";
971 break;
1006 break;
972 case STB_LOPROC:
1007 case STB_LOPROC:
973 return "Start of processor-specific";
1008 return "Start of processor-specific";
974 break;
1009 break;
975 case STB_HIPROC:
1010 case STB_HIPROC:
976 return "End of processor-specific";
1011 return "End of processor-specific";
977 break;
1012 break;
978 default:
1013 default:
979 return "none";
1014 return "none";
980 break;
1015 break;
981 }
1016 }
982 }
1017 }
983 }
1018 }
984 return "none";
1019 return "none";
985 }
1020 }
986
1021
987 bool ElfFile::isElf(const QString &File)
1022 bool ElfFile::isElf(const QString &File)
988 {
1023 {
989 int file =0;
1024 int file =0;
990 #ifdef _ELF_WINDOWS_
1025 #ifdef _ELF_WINDOWS_
991 file = open(File.toStdString().c_str(),O_RDONLY|O_BINARY ,0);
1026 file = open(File.toStdString().c_str(),O_RDONLY|O_BINARY ,0);
992 #else
1027 #else
993 file = open(File.toStdString().c_str(),O_RDONLY ,0);
1028 file = open(File.toStdString().c_str(),O_RDONLY ,0);
994 #endif
1029 #endif
995 char Magic[4];
1030 char Magic[4];
996 if(file!=-1)
1031 if(file!=-1)
997 {
1032 {
998 read(file,Magic,4);
1033 read(file,Magic,4);
999 close(file);
1034 close(file);
1000 if(Magic[0]==0x7f && Magic[1]==0x45 && Magic[2]==0x4c && Magic[3]==0x46)
1035 if(Magic[0]==0x7f && Magic[1]==0x45 && Magic[2]==0x4c && Magic[3]==0x46)
1001 {
1036 {
1002 return true;
1037 return true;
1003 }
1038 }
1004 }
1039 }
1005 return false;
1040 return false;
1006 }
1041 }
Show file before | Show file after | Hide comments
@@ -1,130 +1,132
1 /*------------------------------------------------------------------------------
1 /*------------------------------------------------------------------------------
2 -- This file is a part of the SocExplorer Software
2 -- This file is a part of the SocExplorer Software
3 -- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
3 -- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
4 --
4 --
5 -- This program is free software; you can redistribute it and/or modify
5 -- This program is free software; you can redistribute it and/or modify
6 -- it under the terms of the GNU General Public License as published by
6 -- it under the terms of the GNU General Public License as published by
7 -- the Free Software Foundation; either version 2 of the License, or
7 -- the Free Software Foundation; either version 2 of the License, or
8 -- (at your option) any later version.
8 -- (at your option) any later version.
9 --
9 --
10 -- This program is distributed in the hope that it will be useful,
10 -- This program is distributed in the hope that it will be useful,
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 -- GNU General Public License for more details.
13 -- GNU General Public License for more details.
14 --
14 --
15 -- You should have received a copy of the GNU General Public License
15 -- You should have received a copy of the GNU General Public License
16 -- along with this program; if not, write to the Free Software
16 -- along with this program; if not, write to the Free Software
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 -------------------------------------------------------------------------------*/
18 -------------------------------------------------------------------------------*/
19 /*-- Author : Alexis Jeandet
19 /*-- Author : Alexis Jeandet
20 -- Mail : alexis.jeandet@member.fsf.org
20 -- Mail : alexis.jeandet@member.fsf.org
21 ----------------------------------------------------------------------------*/
21 ----------------------------------------------------------------------------*/
22 #include <abstractexecfile.h>
22 #include <abstractexecfile.h>
23 #include <QtCore/QObject>
23 #include <QtCore/QObject>
24 #include <QtCore/QStringList>
24 #include <QtCore/QStringList>
25 #include <libelf.h>
25 #include <libelf.h>
26 #include <gelf.h>
26 #include <gelf.h>
27 #include <sys/types.h>
27 #include <sys/types.h>
28 #include <sys/stat.h>
28 #include <sys/stat.h>
29 #include <fcntl.h>
29 #include <fcntl.h>
30 #include <unistd.h>
30 #include <unistd.h>
31 #ifndef ELFFILE_H
31 #ifndef ELFFILE_H
32 #define ELFFILE_H
32 #define ELFFILE_H
33
33
34 class Elf_Section
34 class Elf_Section
35 {
35 {
36 public:
36 public:
37 Elf_Section(){}
37 Elf_Section(){}
38 Elf_Section(Elf_Data* data,GElf_Shdr* section_header)
38 Elf_Section(Elf_Data* data,GElf_Shdr* section_header)
39 {
39 {
40 this->data = data;
40 this->data = data;
41 this->section_header = section_header;
41 this->section_header = section_header;
42 }
42 }
43 ~Elf_Section()
43 ~Elf_Section()
44 {
44 {
45 free(section_header);
45 free(section_header);
46 }
46 }
47 Elf_Data* data;
47 Elf_Data* data;
48 GElf_Shdr* section_header;
48 GElf_Shdr* section_header;
49 };
49 };
50
50
51 class Elf_Symbol
51 class Elf_Symbol
52 {
52 {
53 public:
53 public:
54 Elf_Symbol(){}
54 Elf_Symbol(){}
55 Elf_Symbol(const QString& name,GElf_Sym* sym):name(name),sym(sym){}
55 Elf_Symbol(const QString& name,GElf_Sym* sym):name(name),sym(sym){}
56 ~Elf_Symbol(){free(sym);}
56 ~Elf_Symbol(){free(sym);}
57 QString name;
57 QString name;
58 GElf_Sym* sym;
58 GElf_Sym* sym;
59 };
59 };
60
60
61 class ElfFile : public abstractExecFile
61 class ElfFile : public abstractExecFile
62 {
62 {
63 Q_OBJECT
63 Q_OBJECT
64 public:
64 public:
65 ElfFile();
65 ElfFile();
66 ElfFile(const QString& File);
66 ElfFile(const QString& File);
67 ~ElfFile();
67 bool openFile(const QString& File);
68 bool openFile(const QString& File);
68 bool isopened();
69 bool isopened();
69 int closeFile();
70 int closeFile();
70 QList<codeFragment*> getFragments();
71 QList<codeFragment*> getFragments();
71 QList<codeFragment*> getFragments(QStringList fragmentList);
72 QList<codeFragment*> getFragments(QStringList fragmentList);
72
73
73 QString getClass();
74 QString getClass();
74 QString getArchitecture();
75 QString getArchitecture();
75 QString getType();
76 QString getType();
76 QString getEndianness();
77 QString getEndianness();
77 QString getABI();
78 QString getABI();
78 qint64 getVersion();
79 qint64 getVersion();
79 qint64 getEntryPointAddress();
80 qint64 getEntryPointAddress();
80
81
81 int getSectionCount();
82 int getSectionCount();
82 int getSymbolCount();
83 int getSymbolCount();
83 int getSegmentCount();
84 int getSegmentCount();
84
85
85 QString getSegmentType(int index);
86 QString getSegmentType(int index);
86 qint64 getSegmentOffset(int index);
87 qint64 getSegmentOffset(int index);
87 qint64 getSegmentVaddr(int index);
88 qint64 getSegmentVaddr(int index);
88 qint64 getSegmentPaddr(int index);
89 qint64 getSegmentPaddr(int index);
89 qint64 getSegmentFilesz(int index);
90 qint64 getSegmentFilesz(int index);
90 qint64 getSectionDatasz(int index);
91 qint64 getSectionDatasz(int index);
91 qint64 getSegmentMemsz(int index);
92 qint64 getSegmentMemsz(int index);
92 QString getSegmentFlags(int index);
93 QString getSegmentFlags(int index);
93
94
94 bool getSectionData(int index, char **buffer);
95 bool getSectionData(int index, char **buffer);
95 qint64 getSectionPaddr(int index);
96 qint64 getSectionPaddr(int index);
96 qint64 getSectionMemsz(int index);
97 qint64 getSectionMemsz(int index);
97 QString getSectionName(int index);
98 QString getSectionName(int index);
98 QString getSectionType(int index);
99 QString getSectionType(int index);
100 int getSectionIndex(QString name);
99
101
100 QString getSymbolName(int index);
102 QString getSymbolName(int index);
101 QString getSymbolType(int index);
103 QString getSymbolType(int index);
102 quint64 getSymbolSize(int index);
104 quint64 getSymbolSize(int index);
103 QString getSymbolSectionName(int index);
105 QString getSymbolSectionName(int index);
104 int getSymbolSectionIndex(int index);
106 int getSymbolSectionIndex(int index);
105 quint64 getSymbolAddress(int index);
107 quint64 getSymbolAddress(int index);
106 QString getSymbolLinkType(int index);
108 QString getSymbolLinkType(int index);
107 bool iself();
109 bool iself();
108 static bool isElf(const QString& File);
110 static bool isElf(const QString& File);
109
111
110 private:
112 private:
111 codeFragment* getFragment(const QString& name);
113 codeFragment* getFragment(const QString& name);
112 void updateSections();
114 void updateSections();
113 void updateSegments();
115 void updateSegments();
114 void updateSymbols();
116 void updateSymbols();
115 int elfFile;
117 int elfFile;
116 bool opened;
118 bool opened;
117 bool type_elf;
119 bool type_elf;
118 Elf* e;
120 Elf* e;
119 Elf_Kind ek;
121 Elf_Kind ek;
120 GElf_Ehdr ehdr;
122 GElf_Ehdr ehdr;
121 Elf_Scn * scn;
123 Elf_Scn * scn;
122 Elf_Data * data;
124 Elf_Data * data;
123 size_t SymbolCount,SectionCount,SegmentCount, shstrndx;
125 size_t SymbolCount,SectionCount,SegmentCount, shstrndx;
124 QList<GElf_Phdr*> Segments;
126 QList<GElf_Phdr*> Segments;
125 QList<Elf_Section*> sections;
127 QList<Elf_Section*> sections;
126 QList<Elf_Symbol*> symbols;
128 QList<Elf_Symbol*> symbols;
127
129
128 };
130 };
129
131
130 #endif // ELFFILE_H
132 #endif // ELFFILE_H
Show file before | Show file after | Hide comments
@@ -1,81 +1,135
1 #include "elffilewidget.h"
1 #include "elffilewidget.h"
2 #include "ui_elffilewidget.h"
2 #include "ui_elffilewidget.h"
3 #include <QtWidgets/QTableWidgetItem>
3 #include <QtWidgets/QTableWidgetItem>
4 #include "qhexedit.h"
5 #include "qtablewidgetintitem.h"
4
6
5 elfFileWidget::elfFileWidget(QWidget *parent) :
7 elfFileWidget::elfFileWidget(QWidget *parent) :
6 QWidget(parent),
8 QWidget(parent),
7 ui(new Ui::elfFileWidget)
9 ui(new Ui::elfFileWidget)
8 {
10 {
9 ui->setupUi(this);
11 ui->setupUi(this);
12 connect(this->ui->sectionsList,SIGNAL(cellActivated(int,int)),this,SLOT(sectionCellActivated(int,int)));
10 }
13 }
11
14
15
16
12 elfFileWidget::~elfFileWidget()
17 elfFileWidget::~elfFileWidget()
13 {
18 {
14 delete ui;
19 delete ui;
15 }
20 }
16
21
22
23
17 void elfFileWidget::updateElfFile(ElfFile *file)
24 void elfFileWidget::updateElfFile(ElfFile *file)
18 {
25 {
19 this->p_elf = file;
26 this->p_elf = file;
20 if(p_elf->isopened() && p_elf->iself())
27 if(p_elf->isopened() && p_elf->iself())
21 {
28 {
22 this->ui->classLabel->setText(p_elf->getClass());
29 this->ui->classLabel->setText(p_elf->getClass());
23 this->ui->VersionLabel->setText(QString::number(p_elf->getVersion()));
30 this->ui->VersionLabel->setText(QString::number(p_elf->getVersion()));
24 this->ui->machineLabel->setText(p_elf->getArchitecture());
31 this->ui->machineLabel->setText(p_elf->getArchitecture());
25 this->ui->endiannesLabel->setText(p_elf->getEndianness());
32 this->ui->endiannesLabel->setText(p_elf->getEndianness());
26 this->ui->abiLabel->setText(p_elf->getABI());
33 this->ui->abiLabel->setText(p_elf->getABI());
27 this->ui->entryPointLabel->setText(QString("0x%1").arg((uint)p_elf->getEntryPointAddress(),8,16));
34 this->ui->entryPointLabel->setText(QString("0x%1").arg((uint)p_elf->getEntryPointAddress(),8,16));
28 this->ui->typeLabel->setText(p_elf->getType());
35 this->ui->typeLabel->setText(p_elf->getType());
29 this->ui->sectionCountLabel->setText(QString::number(p_elf->getSectionCount()));
36 this->ui->sectionCountLabel->setText(QString::number(p_elf->getSectionCount()));
30 this->ui->symbolCountLabel->setText(QString::number(p_elf->getSymbolCount()));
37 this->ui->symbolCountLabel->setText(QString::number(p_elf->getSymbolCount()));
31 }
38 }
32 updateSymbols();
39 updateSymbols();
40 updateSections();
33 }
41 }
34
42
43
44
35 void elfFileWidget::updateSymbols()
45 void elfFileWidget::updateSymbols()
36 {
46 {
37 this->ui->symbolsList->clear();
47 this->ui->symbolsList->clear();
38 this->ui->symbolsList->setRowCount(p_elf->getSymbolCount());
48 this->ui->symbolsList->setRowCount(p_elf->getSymbolCount());
39 this->ui->symbolsList->setHorizontalHeaderLabels(QStringList()<<"Value"<<"Size"<<"Type"<<"Link"<<"Section"<<"Name");
49 this->ui->symbolsList->setHorizontalHeaderLabels(QStringList()<<"Index"<<"Value"<<"Size"<<"Type"<<"Link"<<"Section"<<"Name");
40 for(int i=0;i<p_elf->getSymbolCount();i++)
50 for(int i=0;i<p_elf->getSymbolCount();i++)
41 {
51 {
42 QTableWidgetItem *newItem = new QTableWidgetItem(QString("0x%1").arg(p_elf->getSymbolAddress(i),8,16));
52 QTableWidgetItem *newItem = (QTableWidgetItem*)new QTableWidgetIntItem(QString("%1").arg(i),DecimalItem);
43 newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
53 newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
44 this->ui->symbolsList->setItem(i, 0, newItem);
54 this->ui->symbolsList->setItem(i, 0, newItem);
45
55
46 newItem = new QTableWidgetItem(QString("0x%1").arg(p_elf->getSymbolSize(i),8,16));
56 newItem = (QTableWidgetItem*)new QTableWidgetIntItem(QString("0x%1").arg(p_elf->getSymbolAddress(i),8,16).replace(" ","0"),HexaDecimalItem);
47 newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
57 newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
48 this->ui->symbolsList->setItem(i, 1, newItem);
58 this->ui->symbolsList->setItem(i, 1, newItem);
49
59
60 newItem = (QTableWidgetItem*)new QTableWidgetIntItem(QString("%1").arg(p_elf->getSymbolSize(i)),DecimalItem);
61 newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
62 this->ui->symbolsList->setItem(i, 2, newItem);
63
50 newItem = new QTableWidgetItem(p_elf->getSymbolType(i));
64 newItem = new QTableWidgetItem(p_elf->getSymbolType(i));
51 newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
65 newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
52 this->ui->symbolsList->setItem(i, 2, newItem);
66 this->ui->symbolsList->setItem(i, 3, newItem);
53
67
54 newItem = new QTableWidgetItem(p_elf->getSymbolLinkType(i));
68 newItem = new QTableWidgetItem(p_elf->getSymbolLinkType(i));
55 newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
69 newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
56 this->ui->symbolsList->setItem(i, 3, newItem);
70 this->ui->symbolsList->setItem(i, 4, newItem);
57
71
58 newItem = new QTableWidgetItem(p_elf->getSymbolSectionName(i));
72 newItem = new QTableWidgetItem(p_elf->getSymbolSectionName(i));
59 newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
73 newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
60 this->ui->symbolsList->setItem(i, 4, newItem);
74 this->ui->symbolsList->setItem(i, 5, newItem);
61
75
62 newItem = new QTableWidgetItem(p_elf->getSymbolName(i));
76 newItem = new QTableWidgetItem(p_elf->getSymbolName(i));
63 newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
77 newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
64 this->ui->symbolsList->setItem(i, 5, newItem);
78 this->ui->symbolsList->setItem(i, 6, newItem);
65 }
79 }
66 this->ui->symbolsList->resizeColumnsToContents();
80 this->ui->symbolsList->resizeColumnsToContents();
67 }
81 }
68
82
69
83
70
84
85 void elfFileWidget::updateSections()
86 {
87 this->ui->sectionsList->clear();
88 this->ui->sectionsList->setRowCount(p_elf->getSectionCount());
89 this->ui->sectionsList->setHorizontalHeaderLabels(QStringList()<<"Index"<<"Name"<<"Address"<<"Size");
90 for(int i=0;i<p_elf->getSectionCount();i++)
91 {
92 QTableWidgetItem *newItem = (QTableWidgetItem*) new QTableWidgetIntItem(QString("%1").arg(i),DecimalItem);
93 newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
94 this->ui->sectionsList->setItem(i,0, newItem);
95
96 newItem = new QTableWidgetItem(p_elf->getSectionName(i));
97 newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
98 this->ui->sectionsList->setItem(i, 1, newItem);
99
100 newItem = (QTableWidgetItem*) new QTableWidgetIntItem(QString("0x%1").arg(p_elf->getSectionPaddr(i),8,16).replace(" ","0"),HexaDecimalItem);
101 newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
102 this->ui->sectionsList->setItem(i, 2, newItem);
103
104 newItem = (QTableWidgetItem*) new QTableWidgetIntItem(QString("%1").arg(p_elf->getSectionDatasz(i)),DecimalItem);
105 newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
106 this->ui->sectionsList->setItem(i, 3, newItem);
107 }
108 this->ui->sectionsList->resizeColumnsToContents();
109 }
110
111 void elfFileWidget::sectionCellActivated(int row, int column)
112 {
113 Q_UNUSED(column)
114 char* buff=NULL;
115 int sectionIndex = p_elf->getSectionIndex(this->ui->sectionsList->item(row,1)->text());
116 if(sectionIndex!=-1)
117 {
118 this->p_elf->getSectionData(sectionIndex,&buff);
119 this->ui->sectionsHexView->setData(QByteArray(buff,this->p_elf->getSectionDatasz(sectionIndex)));
120 }
121 }
122
123
124
71
125
72
126
73
127
74
128
75
129
76
130
77
131
78
132
79
133
80
134
81
135
Show file before | Show file after | Hide comments
@@ -1,28 +1,32
1 #ifndef ELFFILEWIDGET_H
1 #ifndef ELFFILEWIDGET_H
2 #define ELFFILEWIDGET_H
2 #define ELFFILEWIDGET_H
3
3
4 #include <QtWidgets/QWidget>
4 #include <QtWidgets/QWidget>
5 #include "elffile.h"
5 #include "elffile.h"
6
6
7 namespace Ui {
7 namespace Ui {
8 class elfFileWidget;
8 class elfFileWidget;
9 }
9 }
10
10
11 class elfFileWidget : public QWidget
11 class elfFileWidget : public QWidget
12 {
12 {
13 Q_OBJECT
13 Q_OBJECT
14
14
15 public:
15 public:
16 elfFileWidget(QWidget *parent = 0);
16 elfFileWidget(QWidget *parent = 0);
17 ~elfFileWidget();
17 ~elfFileWidget();
18
18
19 public slots:
19 public slots:
20 void updateElfFile(ElfFile* file);
20 void updateElfFile(ElfFile* file);
21 void updateSymbols();
21 void updateSymbols();
22 void updateSections();
23
24 private slots:
25 void sectionCellActivated(int row, int column);
22
26
23 private:
27 private:
24 Ui::elfFileWidget *ui;
28 Ui::elfFileWidget *ui;
25 ElfFile* p_elf;
29 ElfFile* p_elf;
26 };
30 };
27
31
28 #endif // ELFFILEWIDGET_H
32 #endif // ELFFILEWIDGET_H
Show file before | Show file after | Hide comments
@@ -1,260 +1,301
1 <?xml version="1.0" encoding="UTF-8"?>
1 <?xml version="1.0" encoding="UTF-8"?>
2 <ui version="4.0">
2 <ui version="4.0">
3 <class>elfFileWidget</class>
3 <class>elfFileWidget</class>
4 <widget class="QWidget" name="elfFileWidget">
4 <widget class="QWidget" name="elfFileWidget">
5 <property name="geometry">
5 <property name="geometry">
6 <rect>
6 <rect>
7 <x>0</x>
7 <x>0</x>
8 <y>0</y>
8 <y>0</y>
9 <width>786</width>
9 <width>786</width>
10 <height>387</height>
10 <height>387</height>
11 </rect>
11 </rect>
12 </property>
12 </property>
13 <property name="minimumSize">
13 <property name="minimumSize">
14 <size>
14 <size>
15 <width>0</width>
15 <width>0</width>
16 <height>0</height>
16 <height>0</height>
17 </size>
17 </size>
18 </property>
18 </property>
19 <property name="focusPolicy">
19 <property name="focusPolicy">
20 <enum>Qt::NoFocus</enum>
20 <enum>Qt::NoFocus</enum>
21 </property>
21 </property>
22 <property name="windowTitle">
22 <property name="windowTitle">
23 <string>Form</string>
23 <string>Form</string>
24 </property>
24 </property>
25 <layout class="QGridLayout" name="gridLayout">
25 <layout class="QGridLayout" name="gridLayout">
26 <item row="0" column="0">
26 <item row="0" column="0">
27 <widget class="QTabWidget" name="tabWidget">
27 <widget class="QTabWidget" name="tabWidget">
28 <property name="currentIndex">
28 <property name="currentIndex">
29 <number>1</number>
29 <number>2</number>
30 </property>
30 </property>
31 <widget class="QWidget" name="generalInfoTab">
31 <widget class="QWidget" name="generalInfoTab">
32 <attribute name="title">
32 <attribute name="title">
33 <string>File Informations</string>
33 <string>File Informations</string>
34 </attribute>
34 </attribute>
35 <layout class="QGridLayout" name="gridLayout_4">
35 <layout class="QGridLayout" name="gridLayout_4">
36 <item row="0" column="0">
36 <item row="0" column="0">
37 <widget class="QGroupBox" name="groupBox">
37 <widget class="QGroupBox" name="groupBox">
38 <property name="title">
38 <property name="title">
39 <string>Elf header</string>
39 <string>Elf header</string>
40 </property>
40 </property>
41 <layout class="QFormLayout" name="formLayout">
41 <layout class="QFormLayout" name="formLayout">
42 <item row="0" column="0">
42 <item row="0" column="0">
43 <widget class="QLabel" name="label">
43 <widget class="QLabel" name="label">
44 <property name="text">
44 <property name="text">
45 <string>Class:</string>
45 <string>Class:</string>
46 </property>
46 </property>
47 </widget>
47 </widget>
48 </item>
48 </item>
49 <item row="0" column="1">
49 <item row="0" column="1">
50 <widget class="QLabel" name="classLabel">
50 <widget class="QLabel" name="classLabel">
51 <property name="text">
51 <property name="text">
52 <string>none</string>
52 <string>none</string>
53 </property>
53 </property>
54 </widget>
54 </widget>
55 </item>
55 </item>
56 <item row="1" column="0">
56 <item row="1" column="0">
57 <widget class="QLabel" name="label_3">
57 <widget class="QLabel" name="label_3">
58 <property name="text">
58 <property name="text">
59 <string>Endianness:</string>
59 <string>Endianness:</string>
60 </property>
60 </property>
61 </widget>
61 </widget>
62 </item>
62 </item>
63 <item row="1" column="1">
63 <item row="1" column="1">
64 <widget class="QLabel" name="endiannesLabel">
64 <widget class="QLabel" name="endiannesLabel">
65 <property name="text">
65 <property name="text">
66 <string>none</string>
66 <string>none</string>
67 </property>
67 </property>
68 </widget>
68 </widget>
69 </item>
69 </item>
70 <item row="2" column="0">
70 <item row="2" column="0">
71 <widget class="QLabel" name="label_5">
71 <widget class="QLabel" name="label_5">
72 <property name="text">
72 <property name="text">
73 <string>Version:</string>
73 <string>Version:</string>
74 </property>
74 </property>
75 </widget>
75 </widget>
76 </item>
76 </item>
77 <item row="3" column="0">
77 <item row="3" column="0">
78 <widget class="QLabel" name="label_6">
78 <widget class="QLabel" name="label_6">
79 <property name="text">
79 <property name="text">
80 <string>Type:</string>
80 <string>Type:</string>
81 </property>
81 </property>
82 </widget>
82 </widget>
83 </item>
83 </item>
84 <item row="4" column="0">
84 <item row="4" column="0">
85 <widget class="QLabel" name="label_7">
85 <widget class="QLabel" name="label_7">
86 <property name="text">
86 <property name="text">
87 <string>Machine:</string>
87 <string>Machine:</string>
88 </property>
88 </property>
89 </widget>
89 </widget>
90 </item>
90 </item>
91 <item row="6" column="0">
91 <item row="6" column="0">
92 <widget class="QLabel" name="label_8">
92 <widget class="QLabel" name="label_8">
93 <property name="text">
93 <property name="text">
94 <string>Entry point address:</string>
94 <string>Entry point address:</string>
95 </property>
95 </property>
96 </widget>
96 </widget>
97 </item>
97 </item>
98 <item row="2" column="1">
98 <item row="2" column="1">
99 <widget class="QLabel" name="VersionLabel">
99 <widget class="QLabel" name="VersionLabel">
100 <property name="text">
100 <property name="text">
101 <string>none</string>
101 <string>none</string>
102 </property>
102 </property>
103 </widget>
103 </widget>
104 </item>
104 </item>
105 <item row="3" column="1">
105 <item row="3" column="1">
106 <widget class="QLabel" name="typeLabel">
106 <widget class="QLabel" name="typeLabel">
107 <property name="text">
107 <property name="text">
108 <string>none</string>
108 <string>none</string>
109 </property>
109 </property>
110 </widget>
110 </widget>
111 </item>
111 </item>
112 <item row="4" column="1">
112 <item row="4" column="1">
113 <widget class="QLabel" name="machineLabel">
113 <widget class="QLabel" name="machineLabel">
114 <property name="text">
114 <property name="text">
115 <string>none</string>
115 <string>none</string>
116 </property>
116 </property>
117 </widget>
117 </widget>
118 </item>
118 </item>
119 <item row="6" column="1">
119 <item row="6" column="1">
120 <widget class="QLabel" name="entryPointLabel">
120 <widget class="QLabel" name="entryPointLabel">
121 <property name="text">
121 <property name="text">
122 <string>none</string>
122 <string>none</string>
123 </property>
123 </property>
124 </widget>
124 </widget>
125 </item>
125 </item>
126 <item row="5" column="0">
126 <item row="5" column="0">
127 <widget class="QLabel" name="label_17">
127 <widget class="QLabel" name="label_17">
128 <property name="text">
128 <property name="text">
129 <string>OS/ABI:</string>
129 <string>OS/ABI:</string>
130 </property>
130 </property>
131 </widget>
131 </widget>
132 </item>
132 </item>
133 <item row="5" column="1">
133 <item row="5" column="1">
134 <widget class="QLabel" name="abiLabel">
134 <widget class="QLabel" name="abiLabel">
135 <property name="text">
135 <property name="text">
136 <string>none</string>
136 <string>none</string>
137 </property>
137 </property>
138 </widget>
138 </widget>
139 </item>
139 </item>
140 </layout>
140 </layout>
141 </widget>
141 </widget>
142 </item>
142 </item>
143 <item row="1" column="0">
143 <item row="1" column="0">
144 <widget class="QGroupBox" name="groupBox_2">
144 <widget class="QGroupBox" name="groupBox_2">
145 <property name="title">
145 <property name="title">
146 <string>Sections &amp; Symbols</string>
146 <string>Sections &amp; Symbols</string>
147 </property>
147 </property>
148 <layout class="QFormLayout" name="formLayout_2">
148 <layout class="QFormLayout" name="formLayout_2">
149 <item row="0" column="0">
149 <item row="0" column="0">
150 <widget class="QLabel" name="label_9">
150 <widget class="QLabel" name="label_9">
151 <property name="text">
151 <property name="text">
152 <string>Section count:</string>
152 <string>Section count:</string>
153 </property>
153 </property>
154 </widget>
154 </widget>
155 </item>
155 </item>
156 <item row="1" column="0">
156 <item row="1" column="0">
157 <widget class="QLabel" name="label_10">
157 <widget class="QLabel" name="label_10">
158 <property name="text">
158 <property name="text">
159 <string>Symbols count:</string>
159 <string>Symbols count:</string>
160 </property>
160 </property>
161 </widget>
161 </widget>
162 </item>
162 </item>
163 <item row="0" column="1">
163 <item row="0" column="1">
164 <widget class="QLabel" name="sectionCountLabel">
164 <widget class="QLabel" name="sectionCountLabel">
165 <property name="text">
165 <property name="text">
166 <string>none</string>
166 <string>none</string>
167 </property>
167 </property>
168 </widget>
168 </widget>
169 </item>
169 </item>
170 <item row="1" column="1">
170 <item row="1" column="1">
171 <widget class="QLabel" name="symbolCountLabel">
171 <widget class="QLabel" name="symbolCountLabel">
172 <property name="text">
172 <property name="text">
173 <string>none</string>
173 <string>none</string>
174 </property>
174 </property>
175 </widget>
175 </widget>
176 </item>
176 </item>
177 </layout>
177 </layout>
178 </widget>
178 </widget>
179 </item>
179 </item>
180 </layout>
180 </layout>
181 </widget>
181 </widget>
182 <widget class="QWidget" name="symbolsTab">
182 <widget class="QWidget" name="symbolsTab">
183 <attribute name="title">
183 <attribute name="title">
184 <string>Symbols</string>
184 <string>Symbols</string>
185 </attribute>
185 </attribute>
186 <layout class="QGridLayout" name="gridLayout_2">
186 <layout class="QGridLayout" name="gridLayout_2">
187 <item row="0" column="0">
187 <item row="0" column="0">
188 <widget class="QTableWidget" name="symbolsList">
188 <widget class="QTableWidget" name="symbolsList">
189 <property name="sortingEnabled">
189 <property name="sortingEnabled">
190 <bool>true</bool>
190 <bool>true</bool>
191 </property>
191 </property>
192 <attribute name="verticalHeaderVisible">
193 <bool>false</bool>
194 </attribute>
195 <attribute name="verticalHeaderShowSortIndicator" stdset="0">
196 <bool>false</bool>
197 </attribute>
198 <column>
199 <property name="text">
200 <string>Index</string>
201 </property>
202 </column>
192 <column>
203 <column>
193 <property name="text">
204 <property name="text">
194 <string>Value</string>
205 <string>Value</string>
195 </property>
206 </property>
196 </column>
207 </column>
197 <column>
208 <column>
198 <property name="text">
209 <property name="text">
199 <string>Size</string>
210 <string>Size</string>
200 </property>
211 </property>
201 </column>
212 </column>
202 <column>
213 <column>
203 <property name="text">
214 <property name="text">
204 <string>Type</string>
215 <string>Type</string>
205 </property>
216 </property>
206 </column>
217 </column>
207 <column>
218 <column>
208 <property name="text">
219 <property name="text">
209 <string>Link</string>
220 <string>Link</string>
210 </property>
221 </property>
211 </column>
222 </column>
212 <column>
223 <column>
213 <property name="text">
224 <property name="text">
214 <string>Section</string>
225 <string>Section</string>
215 </property>
226 </property>
216 </column>
227 </column>
217 <column>
228 <column>
218 <property name="text">
229 <property name="text">
219 <string>Name</string>
230 <string>Name</string>
220 </property>
231 </property>
221 </column>
232 </column>
222 </widget>
233 </widget>
223 </item>
234 </item>
224 </layout>
235 </layout>
225 </widget>
236 </widget>
226 <widget class="QWidget" name="sectionsTab">
237 <widget class="QWidget" name="sectionsTab">
227 <attribute name="title">
238 <attribute name="title">
228 <string>Sections</string>
239 <string>Sections</string>
229 </attribute>
240 </attribute>
230 <layout class="QGridLayout" name="gridLayout_3">
241 <layout class="QGridLayout" name="gridLayout_3">
231 <item row="0" column="0">
242 <item row="0" column="0">
232 <widget class="QHexEdit" name="sectionsHexView" native="true">
243 <widget class="QHexEdit" name="sectionsHexView" native="true">
233 <property name="minimumSize">
244 <property name="minimumSize">
234 <size>
245 <size>
235 <width>100</width>
246 <width>100</width>
236 <height>0</height>
247 <height>0</height>
237 </size>
248 </size>
238 </property>
249 </property>
239 </widget>
250 </widget>
240 </item>
251 </item>
241 <item row="0" column="1">
252 <item row="0" column="1">
242 <widget class="QTableWidget" name="sectionsList"/>
253 <widget class="QTableWidget" name="sectionsList">
254 <property name="sortingEnabled">
255 <bool>true</bool>
256 </property>
257 <attribute name="verticalHeaderVisible">
258 <bool>false</bool>
259 </attribute>
260 <attribute name="verticalHeaderShowSortIndicator" stdset="0">
261 <bool>false</bool>
262 </attribute>
263 <column>
264 <property name="text">
265 <string>Index</string>
266 </property>
267 </column>
268 <column>
269 <property name="text">
270 <string>Name</string>
271 </property>
272 </column>
273 <column>
274 <property name="text">
275 <string>Address</string>
276 </property>
277 </column>
278 <column>
279 <property name="text">
280 <string>Size</string>
281 </property>
282 </column>
283 </widget>
243 </item>
284 </item>
244 </layout>
285 </layout>
245 </widget>
286 </widget>
246 </widget>
287 </widget>
247 </item>
288 </item>
248 </layout>
289 </layout>
249 </widget>
290 </widget>
250 <customwidgets>
291 <customwidgets>
251 <customwidget>
292 <customwidget>
252 <class>QHexEdit</class>
293 <class>QHexEdit</class>
253 <extends>QWidget</extends>
294 <extends>QWidget</extends>
254 <header location="global">qhexedit.h</header>
295 <header location="global">qhexedit.h</header>
255 <container>1</container>
296 <container>1</container>
256 </customwidget>
297 </customwidget>
257 </customwidgets>
298 </customwidgets>
258 <resources/>
299 <resources/>
259 <connections/>
300 <connections/>
260 </ui>
301 </ui>
Show file before | Show file after | Hide comments
@@ -1,6867 +1,6912
1 #include "PySocExplorer0.h"
1 #include "PySocExplorer0.h"
2 #include <PythonQtConversion.h>
2 #include <PythonQtConversion.h>
3 #include <PythonQtMethodInfo.h>
3 #include <PythonQtMethodInfo.h>
4 #include <PythonQtSignalReceiver.h>
4 #include <PythonQtSignalReceiver.h>
5 #include <QIconEngine>
5 #include <QIconEngine>
6 #include <QObject>
6 #include <QObject>
7 #include <QSpinBox>
7 #include <QSpinBox>
8 #include <QVariant>
8 #include <QVariant>
9 #include <QWidget>
9 #include <QWidget>
10 #include <abstractexecfile.h>
10 #include <abstractexecfile.h>
11 #include <elffile.h>
11 #include <elffile.h>
12 #include <elfparser.h>
12 #include <elfparser.h>
13 #include <qaction.h>
13 #include <qaction.h>
14 #include <qbitmap.h>
14 #include <qbitmap.h>
15 #include <qbytearray.h>
15 #include <qbytearray.h>
16 #include <qcolor.h>
16 #include <qcolor.h>
17 #include <qcoreevent.h>
17 #include <qcoreevent.h>
18 #include <qcursor.h>
18 #include <qcursor.h>
19 #include <qevent.h>
19 #include <qevent.h>
20 #include <qfont.h>
20 #include <qfont.h>
21 #include <qgraphicseffect.h>
21 #include <qgraphicseffect.h>
22 #include <qgraphicsproxywidget.h>
22 #include <qgraphicsproxywidget.h>
23 #include <qkeysequence.h>
23 #include <qkeysequence.h>
24 #include <qlayout.h>
24 #include <qlayout.h>
25 #include <qlineedit.h>
25 #include <qlineedit.h>
26 #include <qlist.h>
26 #include <qlist.h>
27 #include <qlocale.h>
27 #include <qlocale.h>
28 #include <qmargins.h>
28 #include <qmargins.h>
29 #include <qobject.h>
29 #include <qobject.h>
30 #include <qpaintdevice.h>
30 #include <qpaintdevice.h>
31 #include <qpaintengine.h>
31 #include <qpaintengine.h>
32 #include <qpainter.h>
32 #include <qpainter.h>
33 #include <qpalette.h>
33 #include <qpalette.h>
34 #include <qpen.h>
34 #include <qpen.h>
35 #include <qpixmap.h>
35 #include <qpixmap.h>
36 #include <qpoint.h>
36 #include <qpoint.h>
37 #include <qrect.h>
37 #include <qrect.h>
38 #include <qregion.h>
38 #include <qregion.h>
39 #include <qscrollarea.h>
39 #include <qscrollarea.h>
40 #include <qscrollbar.h>
40 #include <qscrollbar.h>
41 #include <qsize.h>
41 #include <qsize.h>
42 #include <qsizepolicy.h>
42 #include <qsizepolicy.h>
43 #include <qspinbox.h>
43 #include <qspinbox.h>
44 #include <qstringlist.h>
44 #include <qstringlist.h>
45 #include <qstyle.h>
45 #include <qstyle.h>
46 #include <qstyleoption.h>
46 #include <qstyleoption.h>
47 #include <qwidget.h>
47 #include <qwidget.h>
48
48
49 PythonQtShell_ElfFile::~PythonQtShell_ElfFile() {
49 PythonQtShell_ElfFile::~PythonQtShell_ElfFile() {
50 PythonQtPrivate* priv = PythonQt::priv();
50 PythonQtPrivate* priv = PythonQt::priv();
51 if (priv) { priv->shellClassDeleted(this); }
51 if (priv) { priv->shellClassDeleted(this); }
52 }
52 }
53 int PythonQtShell_ElfFile::closeFile()
53 int PythonQtShell_ElfFile::closeFile()
54 {
54 {
55 if (_wrapper) {
55 if (_wrapper) {
56 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
56 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
57 PyErr_Clear();
57 PyErr_Clear();
58 if (obj && !PythonQtSlotFunction_Check(obj)) {
58 if (obj && !PythonQtSlotFunction_Check(obj)) {
59 static const char* argumentList[] ={"int"};
59 static const char* argumentList[] ={"int"};
60 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
60 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
61 int returnValue;
61 int returnValue;
62 void* args[1] = {NULL};
62 void* args[1] = {NULL};
63 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
63 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
64 if (result) {
64 if (result) {
65 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
65 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
66 if (args[0]!=&returnValue) {
66 if (args[0]!=&returnValue) {
67 if (args[0]==NULL) {
67 if (args[0]==NULL) {
68 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
68 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
69 } else {
69 } else {
70 returnValue = *((int*)args[0]);
70 returnValue = *((int*)args[0]);
71 }
71 }
72 }
72 }
73 }
73 }
74 if (result) { Py_DECREF(result); }
74 if (result) { Py_DECREF(result); }
75 Py_DECREF(obj);
75 Py_DECREF(obj);
76 return returnValue;
76 return returnValue;
77 }
77 }
78 }
78 }
79 return ElfFile::closeFile();
79 return ElfFile::closeFile();
80 }
80 }
81 QList<codeFragment* > PythonQtShell_ElfFile::getFragments()
81 QList<codeFragment* > PythonQtShell_ElfFile::getFragments()
82 {
82 {
83 if (_wrapper) {
83 if (_wrapper) {
84 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
84 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
85 PyErr_Clear();
85 PyErr_Clear();
86 if (obj && !PythonQtSlotFunction_Check(obj)) {
86 if (obj && !PythonQtSlotFunction_Check(obj)) {
87 static const char* argumentList[] ={"QList<codeFragment* >"};
87 static const char* argumentList[] ={"QList<codeFragment* >"};
88 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
88 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
89 QList<codeFragment* > returnValue;
89 QList<codeFragment* > returnValue;
90 void* args[1] = {NULL};
90 void* args[1] = {NULL};
91 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
91 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
92 if (result) {
92 if (result) {
93 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
93 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
94 if (args[0]!=&returnValue) {
94 if (args[0]!=&returnValue) {
95 if (args[0]==NULL) {
95 if (args[0]==NULL) {
96 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
96 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
97 } else {
97 } else {
98 returnValue = *((QList<codeFragment* >*)args[0]);
98 returnValue = *((QList<codeFragment* >*)args[0]);
99 }
99 }
100 }
100 }
101 }
101 }
102 if (result) { Py_DECREF(result); }
102 if (result) { Py_DECREF(result); }
103 Py_DECREF(obj);
103 Py_DECREF(obj);
104 return returnValue;
104 return returnValue;
105 }
105 }
106 }
106 }
107 return ElfFile::getFragments();
107 return ElfFile::getFragments();
108 }
108 }
109 bool PythonQtShell_ElfFile::isopened()
109 bool PythonQtShell_ElfFile::isopened()
110 {
110 {
111 if (_wrapper) {
111 if (_wrapper) {
112 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
112 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
113 PyErr_Clear();
113 PyErr_Clear();
114 if (obj && !PythonQtSlotFunction_Check(obj)) {
114 if (obj && !PythonQtSlotFunction_Check(obj)) {
115 static const char* argumentList[] ={"bool"};
115 static const char* argumentList[] ={"bool"};
116 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
116 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
117 bool returnValue;
117 bool returnValue;
118 void* args[1] = {NULL};
118 void* args[1] = {NULL};
119 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
119 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
120 if (result) {
120 if (result) {
121 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
121 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
122 if (args[0]!=&returnValue) {
122 if (args[0]!=&returnValue) {
123 if (args[0]==NULL) {
123 if (args[0]==NULL) {
124 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
124 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
125 } else {
125 } else {
126 returnValue = *((bool*)args[0]);
126 returnValue = *((bool*)args[0]);
127 }
127 }
128 }
128 }
129 }
129 }
130 if (result) { Py_DECREF(result); }
130 if (result) { Py_DECREF(result); }
131 Py_DECREF(obj);
131 Py_DECREF(obj);
132 return returnValue;
132 return returnValue;
133 }
133 }
134 }
134 }
135 return ElfFile::isopened();
135 return ElfFile::isopened();
136 }
136 }
137 bool PythonQtShell_ElfFile::openFile(const QString& File)
137 bool PythonQtShell_ElfFile::openFile(const QString& File)
138 {
138 {
139 if (_wrapper) {
139 if (_wrapper) {
140 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
140 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
141 PyErr_Clear();
141 PyErr_Clear();
142 if (obj && !PythonQtSlotFunction_Check(obj)) {
142 if (obj && !PythonQtSlotFunction_Check(obj)) {
143 static const char* argumentList[] ={"bool" , "const QString&"};
143 static const char* argumentList[] ={"bool" , "const QString&"};
144 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
144 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
145 bool returnValue;
145 bool returnValue;
146 void* args[2] = {NULL, (void*)&File};
146 void* args[2] = {NULL, (void*)&File};
147 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
147 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
148 if (result) {
148 if (result) {
149 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
149 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
150 if (args[0]!=&returnValue) {
150 if (args[0]!=&returnValue) {
151 if (args[0]==NULL) {
151 if (args[0]==NULL) {
152 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
152 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
153 } else {
153 } else {
154 returnValue = *((bool*)args[0]);
154 returnValue = *((bool*)args[0]);
155 }
155 }
156 }
156 }
157 }
157 }
158 if (result) { Py_DECREF(result); }
158 if (result) { Py_DECREF(result); }
159 Py_DECREF(obj);
159 Py_DECREF(obj);
160 return returnValue;
160 return returnValue;
161 }
161 }
162 }
162 }
163 return ElfFile::openFile(File);
163 return ElfFile::openFile(File);
164 }
164 }
165 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile()
165 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile()
166 {
166 {
167 return new PythonQtShell_ElfFile(); }
167 return new PythonQtShell_ElfFile(); }
168
168
169 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile(const QString& File)
169 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile(const QString& File)
170 {
170 {
171 return new PythonQtShell_ElfFile(File); }
171 return new PythonQtShell_ElfFile(File); }
172
172
173 int PythonQtWrapper_ElfFile::closeFile(ElfFile* theWrappedObject)
173 int PythonQtWrapper_ElfFile::closeFile(ElfFile* theWrappedObject)
174 {
174 {
175 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_closeFile());
175 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_closeFile());
176 }
176 }
177
177
178 QString PythonQtWrapper_ElfFile::getABI(ElfFile* theWrappedObject)
178 QString PythonQtWrapper_ElfFile::getABI(ElfFile* theWrappedObject)
179 {
179 {
180 return ( theWrappedObject->getABI());
180 return ( theWrappedObject->getABI());
181 }
181 }
182
182
183 QString PythonQtWrapper_ElfFile::getArchitecture(ElfFile* theWrappedObject)
183 QString PythonQtWrapper_ElfFile::getArchitecture(ElfFile* theWrappedObject)
184 {
184 {
185 return ( theWrappedObject->getArchitecture());
185 return ( theWrappedObject->getArchitecture());
186 }
186 }
187
187
188 QString PythonQtWrapper_ElfFile::getClass(ElfFile* theWrappedObject)
188 QString PythonQtWrapper_ElfFile::getClass(ElfFile* theWrappedObject)
189 {
189 {
190 return ( theWrappedObject->getClass());
190 return ( theWrappedObject->getClass());
191 }
191 }
192
192
193 QString PythonQtWrapper_ElfFile::getEndianness(ElfFile* theWrappedObject)
193 QString PythonQtWrapper_ElfFile::getEndianness(ElfFile* theWrappedObject)
194 {
194 {
195 return ( theWrappedObject->getEndianness());
195 return ( theWrappedObject->getEndianness());
196 }
196 }
197
197
198 qint64 PythonQtWrapper_ElfFile::getEntryPointAddress(ElfFile* theWrappedObject)
198 qint64 PythonQtWrapper_ElfFile::getEntryPointAddress(ElfFile* theWrappedObject)
199 {
199 {
200 return ( theWrappedObject->getEntryPointAddress());
200 return ( theWrappedObject->getEntryPointAddress());
201 }
201 }
202
202
203 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject)
203 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject)
204 {
204 {
205 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_getFragments());
205 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_getFragments());
206 }
206 }
207
207
208 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject, QStringList fragmentList)
208 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject, QStringList fragmentList)
209 {
209 {
210 return ( theWrappedObject->getFragments(fragmentList));
210 return ( theWrappedObject->getFragments(fragmentList));
211 }
211 }
212
212
213 int PythonQtWrapper_ElfFile::getSectionCount(ElfFile* theWrappedObject)
214 {
215 return ( theWrappedObject->getSectionCount());
216 }
217
213 bool PythonQtWrapper_ElfFile::getSectionData(ElfFile* theWrappedObject, int index, char** buffer)
218 bool PythonQtWrapper_ElfFile::getSectionData(ElfFile* theWrappedObject, int index, char** buffer)
214 {
219 {
215 return ( theWrappedObject->getSectionData(index, buffer));
220 return ( theWrappedObject->getSectionData(index, buffer));
216 }
221 }
217
222
218 qint64 PythonQtWrapper_ElfFile::getSectionDatasz(ElfFile* theWrappedObject, int index)
223 qint64 PythonQtWrapper_ElfFile::getSectionDatasz(ElfFile* theWrappedObject, int index)
219 {
224 {
220 return ( theWrappedObject->getSectionDatasz(index));
225 return ( theWrappedObject->getSectionDatasz(index));
221 }
226 }
222
227
228 int PythonQtWrapper_ElfFile::getSectionIndex(ElfFile* theWrappedObject, QString name)
229 {
230 return ( theWrappedObject->getSectionIndex(name));
231 }
232
223 qint64 PythonQtWrapper_ElfFile::getSectionMemsz(ElfFile* theWrappedObject, int index)
233 qint64 PythonQtWrapper_ElfFile::getSectionMemsz(ElfFile* theWrappedObject, int index)
224 {
234 {
225 return ( theWrappedObject->getSectionMemsz(index));
235 return ( theWrappedObject->getSectionMemsz(index));
226 }
236 }
227
237
228 QString PythonQtWrapper_ElfFile::getSectionName(ElfFile* theWrappedObject, int index)
238 QString PythonQtWrapper_ElfFile::getSectionName(ElfFile* theWrappedObject, int index)
229 {
239 {
230 return ( theWrappedObject->getSectionName(index));
240 return ( theWrappedObject->getSectionName(index));
231 }
241 }
232
242
233 qint64 PythonQtWrapper_ElfFile::getSectionPaddr(ElfFile* theWrappedObject, int index)
243 qint64 PythonQtWrapper_ElfFile::getSectionPaddr(ElfFile* theWrappedObject, int index)
234 {
244 {
235 return ( theWrappedObject->getSectionPaddr(index));
245 return ( theWrappedObject->getSectionPaddr(index));
236 }
246 }
237
247
238 QString PythonQtWrapper_ElfFile::getSectionType(ElfFile* theWrappedObject, int index)
248 QString PythonQtWrapper_ElfFile::getSectionType(ElfFile* theWrappedObject, int index)
239 {
249 {
240 return ( theWrappedObject->getSectionType(index));
250 return ( theWrappedObject->getSectionType(index));
241 }
251 }
242
252
243 int PythonQtWrapper_ElfFile::getSectioncount(ElfFile* theWrappedObject)
253 int PythonQtWrapper_ElfFile::getSegmentCount(ElfFile* theWrappedObject)
244 {
254 {
245 return ( theWrappedObject->getSectionCount());
255 return ( theWrappedObject->getSegmentCount());
246 }
256 }
247
257
248 qint64 PythonQtWrapper_ElfFile::getSegmentFilesz(ElfFile* theWrappedObject, int index)
258 qint64 PythonQtWrapper_ElfFile::getSegmentFilesz(ElfFile* theWrappedObject, int index)
249 {
259 {
250 return ( theWrappedObject->getSegmentFilesz(index));
260 return ( theWrappedObject->getSegmentFilesz(index));
251 }
261 }
252
262
253 QString PythonQtWrapper_ElfFile::getSegmentFlags(ElfFile* theWrappedObject, int index)
263 QString PythonQtWrapper_ElfFile::getSegmentFlags(ElfFile* theWrappedObject, int index)
254 {
264 {
255 return ( theWrappedObject->getSegmentFlags(index));
265 return ( theWrappedObject->getSegmentFlags(index));
256 }
266 }
257
267
258 qint64 PythonQtWrapper_ElfFile::getSegmentMemsz(ElfFile* theWrappedObject, int index)
268 qint64 PythonQtWrapper_ElfFile::getSegmentMemsz(ElfFile* theWrappedObject, int index)
259 {
269 {
260 return ( theWrappedObject->getSegmentMemsz(index));
270 return ( theWrappedObject->getSegmentMemsz(index));
261 }
271 }
262
272
263 qint64 PythonQtWrapper_ElfFile::getSegmentOffset(ElfFile* theWrappedObject, int index)
273 qint64 PythonQtWrapper_ElfFile::getSegmentOffset(ElfFile* theWrappedObject, int index)
264 {
274 {
265 return ( theWrappedObject->getSegmentOffset(index));
275 return ( theWrappedObject->getSegmentOffset(index));
266 }
276 }
267
277
268 qint64 PythonQtWrapper_ElfFile::getSegmentPaddr(ElfFile* theWrappedObject, int index)
278 qint64 PythonQtWrapper_ElfFile::getSegmentPaddr(ElfFile* theWrappedObject, int index)
269 {
279 {
270 return ( theWrappedObject->getSegmentPaddr(index));
280 return ( theWrappedObject->getSegmentPaddr(index));
271 }
281 }
272
282
273 QString PythonQtWrapper_ElfFile::getSegmentType(ElfFile* theWrappedObject, int index)
283 QString PythonQtWrapper_ElfFile::getSegmentType(ElfFile* theWrappedObject, int index)
274 {
284 {
275 return ( theWrappedObject->getSegmentType(index));
285 return ( theWrappedObject->getSegmentType(index));
276 }
286 }
277
287
278 qint64 PythonQtWrapper_ElfFile::getSegmentVaddr(ElfFile* theWrappedObject, int index)
288 qint64 PythonQtWrapper_ElfFile::getSegmentVaddr(ElfFile* theWrappedObject, int index)
279 {
289 {
280 return ( theWrappedObject->getSegmentVaddr(index));
290 return ( theWrappedObject->getSegmentVaddr(index));
281 }
291 }
282
292
283 int PythonQtWrapper_ElfFile::getSegmentcount(ElfFile* theWrappedObject)
293 quint64 PythonQtWrapper_ElfFile::getSymbolAddress(ElfFile* theWrappedObject, int index)
284 {
294 {
285 return ( theWrappedObject->getSegmentCount());
295 return ( theWrappedObject->getSymbolAddress(index));
296 }
297
298 int PythonQtWrapper_ElfFile::getSymbolCount(ElfFile* theWrappedObject)
299 {
300 return ( theWrappedObject->getSymbolCount());
301 }
302
303 QString PythonQtWrapper_ElfFile::getSymbolLinkType(ElfFile* theWrappedObject, int index)
304 {
305 return ( theWrappedObject->getSymbolLinkType(index));
306 }
307
308 QString PythonQtWrapper_ElfFile::getSymbolName(ElfFile* theWrappedObject, int index)
309 {
310 return ( theWrappedObject->getSymbolName(index));
311 }
312
313 int PythonQtWrapper_ElfFile::getSymbolSectionIndex(ElfFile* theWrappedObject, int index)
314 {
315 return ( theWrappedObject->getSymbolSectionIndex(index));
316 }
317
318 QString PythonQtWrapper_ElfFile::getSymbolSectionName(ElfFile* theWrappedObject, int index)
319 {
320 return ( theWrappedObject->getSymbolSectionName(index));
321 }
322
323 quint64 PythonQtWrapper_ElfFile::getSymbolSize(ElfFile* theWrappedObject, int index)
324 {
325 return ( theWrappedObject->getSymbolSize(index));
326 }
327
328 QString PythonQtWrapper_ElfFile::getSymbolType(ElfFile* theWrappedObject, int index)
329 {
330 return ( theWrappedObject->getSymbolType(index));
286 }
331 }
287
332
288 QString PythonQtWrapper_ElfFile::getType(ElfFile* theWrappedObject)
333 QString PythonQtWrapper_ElfFile::getType(ElfFile* theWrappedObject)
289 {
334 {
290 return ( theWrappedObject->getType());
335 return ( theWrappedObject->getType());
291 }
336 }
292
337
293 qint64 PythonQtWrapper_ElfFile::getVersion(ElfFile* theWrappedObject)
338 qint64 PythonQtWrapper_ElfFile::getVersion(ElfFile* theWrappedObject)
294 {
339 {
295 return ( theWrappedObject->getVersion());
340 return ( theWrappedObject->getVersion());
296 }
341 }
297
342
298 bool PythonQtWrapper_ElfFile::static_ElfFile_isElf(const QString& File)
343 bool PythonQtWrapper_ElfFile::static_ElfFile_isElf(const QString& File)
299 {
344 {
300 return (ElfFile::isElf(File));
345 return (ElfFile::isElf(File));
301 }
346 }
302
347
303 bool PythonQtWrapper_ElfFile::iself(ElfFile* theWrappedObject)
348 bool PythonQtWrapper_ElfFile::iself(ElfFile* theWrappedObject)
304 {
349 {
305 return ( theWrappedObject->iself());
350 return ( theWrappedObject->iself());
306 }
351 }
307
352
308 bool PythonQtWrapper_ElfFile::isopened(ElfFile* theWrappedObject)
353 bool PythonQtWrapper_ElfFile::isopened(ElfFile* theWrappedObject)
309 {
354 {
310 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_isopened());
355 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_isopened());
311 }
356 }
312
357
313 bool PythonQtWrapper_ElfFile::openFile(ElfFile* theWrappedObject, const QString& File)
358 bool PythonQtWrapper_ElfFile::openFile(ElfFile* theWrappedObject, const QString& File)
314 {
359 {
315 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_openFile(File));
360 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_openFile(File));
316 }
361 }
317
362
318
363
319
364
320 PythonQtShell_MemSizeWdgt::~PythonQtShell_MemSizeWdgt() {
365 PythonQtShell_MemSizeWdgt::~PythonQtShell_MemSizeWdgt() {
321 PythonQtPrivate* priv = PythonQt::priv();
366 PythonQtPrivate* priv = PythonQt::priv();
322 if (priv) { priv->shellClassDeleted(this); }
367 if (priv) { priv->shellClassDeleted(this); }
323 }
368 }
324 void PythonQtShell_MemSizeWdgt::actionEvent(QActionEvent* arg__1)
369 void PythonQtShell_MemSizeWdgt::actionEvent(QActionEvent* arg__1)
325 {
370 {
326 if (_wrapper) {
371 if (_wrapper) {
327 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
372 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
328 PyErr_Clear();
373 PyErr_Clear();
329 if (obj && !PythonQtSlotFunction_Check(obj)) {
374 if (obj && !PythonQtSlotFunction_Check(obj)) {
330 static const char* argumentList[] ={"" , "QActionEvent*"};
375 static const char* argumentList[] ={"" , "QActionEvent*"};
331 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
376 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
332 void* args[2] = {NULL, (void*)&arg__1};
377 void* args[2] = {NULL, (void*)&arg__1};
333 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
378 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
334 if (result) { Py_DECREF(result); }
379 if (result) { Py_DECREF(result); }
335 Py_DECREF(obj);
380 Py_DECREF(obj);
336 return;
381 return;
337 }
382 }
338 }
383 }
339 MemSizeWdgt::actionEvent(arg__1);
384 MemSizeWdgt::actionEvent(arg__1);
340 }
385 }
341 void PythonQtShell_MemSizeWdgt::changeEvent(QEvent* arg__1)
386 void PythonQtShell_MemSizeWdgt::changeEvent(QEvent* arg__1)
342 {
387 {
343 if (_wrapper) {
388 if (_wrapper) {
344 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
389 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
345 PyErr_Clear();
390 PyErr_Clear();
346 if (obj && !PythonQtSlotFunction_Check(obj)) {
391 if (obj && !PythonQtSlotFunction_Check(obj)) {
347 static const char* argumentList[] ={"" , "QEvent*"};
392 static const char* argumentList[] ={"" , "QEvent*"};
348 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
393 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
349 void* args[2] = {NULL, (void*)&arg__1};
394 void* args[2] = {NULL, (void*)&arg__1};
350 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
395 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
351 if (result) { Py_DECREF(result); }
396 if (result) { Py_DECREF(result); }
352 Py_DECREF(obj);
397 Py_DECREF(obj);
353 return;
398 return;
354 }
399 }
355 }
400 }
356 MemSizeWdgt::changeEvent(arg__1);
401 MemSizeWdgt::changeEvent(arg__1);
357 }
402 }
358 void PythonQtShell_MemSizeWdgt::childEvent(QChildEvent* arg__1)
403 void PythonQtShell_MemSizeWdgt::childEvent(QChildEvent* arg__1)
359 {
404 {
360 if (_wrapper) {
405 if (_wrapper) {
361 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
406 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
362 PyErr_Clear();
407 PyErr_Clear();
363 if (obj && !PythonQtSlotFunction_Check(obj)) {
408 if (obj && !PythonQtSlotFunction_Check(obj)) {
364 static const char* argumentList[] ={"" , "QChildEvent*"};
409 static const char* argumentList[] ={"" , "QChildEvent*"};
365 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
410 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
366 void* args[2] = {NULL, (void*)&arg__1};
411 void* args[2] = {NULL, (void*)&arg__1};
367 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
412 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
368 if (result) { Py_DECREF(result); }
413 if (result) { Py_DECREF(result); }
369 Py_DECREF(obj);
414 Py_DECREF(obj);
370 return;
415 return;
371 }
416 }
372 }
417 }
373 MemSizeWdgt::childEvent(arg__1);
418 MemSizeWdgt::childEvent(arg__1);
374 }
419 }
375 void PythonQtShell_MemSizeWdgt::closeEvent(QCloseEvent* arg__1)
420 void PythonQtShell_MemSizeWdgt::closeEvent(QCloseEvent* arg__1)
376 {
421 {
377 if (_wrapper) {
422 if (_wrapper) {
378 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
423 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
379 PyErr_Clear();
424 PyErr_Clear();
380 if (obj && !PythonQtSlotFunction_Check(obj)) {
425 if (obj && !PythonQtSlotFunction_Check(obj)) {
381 static const char* argumentList[] ={"" , "QCloseEvent*"};
426 static const char* argumentList[] ={"" , "QCloseEvent*"};
382 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
427 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
383 void* args[2] = {NULL, (void*)&arg__1};
428 void* args[2] = {NULL, (void*)&arg__1};
384 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
429 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
385 if (result) { Py_DECREF(result); }
430 if (result) { Py_DECREF(result); }
386 Py_DECREF(obj);
431 Py_DECREF(obj);
387 return;
432 return;
388 }
433 }
389 }
434 }
390 MemSizeWdgt::closeEvent(arg__1);
435 MemSizeWdgt::closeEvent(arg__1);
391 }
436 }
392 void PythonQtShell_MemSizeWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
437 void PythonQtShell_MemSizeWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
393 {
438 {
394 if (_wrapper) {
439 if (_wrapper) {
395 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
440 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
396 PyErr_Clear();
441 PyErr_Clear();
397 if (obj && !PythonQtSlotFunction_Check(obj)) {
442 if (obj && !PythonQtSlotFunction_Check(obj)) {
398 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
443 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
399 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
444 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
400 void* args[2] = {NULL, (void*)&arg__1};
445 void* args[2] = {NULL, (void*)&arg__1};
401 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
446 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
402 if (result) { Py_DECREF(result); }
447 if (result) { Py_DECREF(result); }
403 Py_DECREF(obj);
448 Py_DECREF(obj);
404 return;
449 return;
405 }
450 }
406 }
451 }
407 MemSizeWdgt::contextMenuEvent(arg__1);
452 MemSizeWdgt::contextMenuEvent(arg__1);
408 }
453 }
409 void PythonQtShell_MemSizeWdgt::customEvent(QEvent* arg__1)
454 void PythonQtShell_MemSizeWdgt::customEvent(QEvent* arg__1)
410 {
455 {
411 if (_wrapper) {
456 if (_wrapper) {
412 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
457 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
413 PyErr_Clear();
458 PyErr_Clear();
414 if (obj && !PythonQtSlotFunction_Check(obj)) {
459 if (obj && !PythonQtSlotFunction_Check(obj)) {
415 static const char* argumentList[] ={"" , "QEvent*"};
460 static const char* argumentList[] ={"" , "QEvent*"};
416 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
461 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
417 void* args[2] = {NULL, (void*)&arg__1};
462 void* args[2] = {NULL, (void*)&arg__1};
418 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
463 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
419 if (result) { Py_DECREF(result); }
464 if (result) { Py_DECREF(result); }
420 Py_DECREF(obj);
465 Py_DECREF(obj);
421 return;
466 return;
422 }
467 }
423 }
468 }
424 MemSizeWdgt::customEvent(arg__1);
469 MemSizeWdgt::customEvent(arg__1);
425 }
470 }
426 int PythonQtShell_MemSizeWdgt::devType() const
471 int PythonQtShell_MemSizeWdgt::devType() const
427 {
472 {
428 if (_wrapper) {
473 if (_wrapper) {
429 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
474 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
430 PyErr_Clear();
475 PyErr_Clear();
431 if (obj && !PythonQtSlotFunction_Check(obj)) {
476 if (obj && !PythonQtSlotFunction_Check(obj)) {
432 static const char* argumentList[] ={"int"};
477 static const char* argumentList[] ={"int"};
433 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
478 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
434 int returnValue;
479 int returnValue;
435 void* args[1] = {NULL};
480 void* args[1] = {NULL};
436 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
481 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
437 if (result) {
482 if (result) {
438 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
483 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
439 if (args[0]!=&returnValue) {
484 if (args[0]!=&returnValue) {
440 if (args[0]==NULL) {
485 if (args[0]==NULL) {
441 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
486 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
442 } else {
487 } else {
443 returnValue = *((int*)args[0]);
488 returnValue = *((int*)args[0]);
444 }
489 }
445 }
490 }
446 }
491 }
447 if (result) { Py_DECREF(result); }
492 if (result) { Py_DECREF(result); }
448 Py_DECREF(obj);
493 Py_DECREF(obj);
449 return returnValue;
494 return returnValue;
450 }
495 }
451 }
496 }
452 return MemSizeWdgt::devType();
497 return MemSizeWdgt::devType();
453 }
498 }
454 void PythonQtShell_MemSizeWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
499 void PythonQtShell_MemSizeWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
455 {
500 {
456 if (_wrapper) {
501 if (_wrapper) {
457 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
502 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
458 PyErr_Clear();
503 PyErr_Clear();
459 if (obj && !PythonQtSlotFunction_Check(obj)) {
504 if (obj && !PythonQtSlotFunction_Check(obj)) {
460 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
505 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
461 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
506 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
462 void* args[2] = {NULL, (void*)&arg__1};
507 void* args[2] = {NULL, (void*)&arg__1};
463 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
508 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
464 if (result) { Py_DECREF(result); }
509 if (result) { Py_DECREF(result); }
465 Py_DECREF(obj);
510 Py_DECREF(obj);
466 return;
511 return;
467 }
512 }
468 }
513 }
469 MemSizeWdgt::dragEnterEvent(arg__1);
514 MemSizeWdgt::dragEnterEvent(arg__1);
470 }
515 }
471 void PythonQtShell_MemSizeWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
516 void PythonQtShell_MemSizeWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
472 {
517 {
473 if (_wrapper) {
518 if (_wrapper) {
474 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
519 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
475 PyErr_Clear();
520 PyErr_Clear();
476 if (obj && !PythonQtSlotFunction_Check(obj)) {
521 if (obj && !PythonQtSlotFunction_Check(obj)) {
477 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
522 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
478 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
523 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
479 void* args[2] = {NULL, (void*)&arg__1};
524 void* args[2] = {NULL, (void*)&arg__1};
480 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
525 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
481 if (result) { Py_DECREF(result); }
526 if (result) { Py_DECREF(result); }
482 Py_DECREF(obj);
527 Py_DECREF(obj);
483 return;
528 return;
484 }
529 }
485 }
530 }
486 MemSizeWdgt::dragLeaveEvent(arg__1);
531 MemSizeWdgt::dragLeaveEvent(arg__1);
487 }
532 }
488 void PythonQtShell_MemSizeWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
533 void PythonQtShell_MemSizeWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
489 {
534 {
490 if (_wrapper) {
535 if (_wrapper) {
491 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
536 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
492 PyErr_Clear();
537 PyErr_Clear();
493 if (obj && !PythonQtSlotFunction_Check(obj)) {
538 if (obj && !PythonQtSlotFunction_Check(obj)) {
494 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
539 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
495 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
540 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
496 void* args[2] = {NULL, (void*)&arg__1};
541 void* args[2] = {NULL, (void*)&arg__1};
497 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
542 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
498 if (result) { Py_DECREF(result); }
543 if (result) { Py_DECREF(result); }
499 Py_DECREF(obj);
544 Py_DECREF(obj);
500 return;
545 return;
501 }
546 }
502 }
547 }
503 MemSizeWdgt::dragMoveEvent(arg__1);
548 MemSizeWdgt::dragMoveEvent(arg__1);
504 }
549 }
505 void PythonQtShell_MemSizeWdgt::dropEvent(QDropEvent* arg__1)
550 void PythonQtShell_MemSizeWdgt::dropEvent(QDropEvent* arg__1)
506 {
551 {
507 if (_wrapper) {
552 if (_wrapper) {
508 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
553 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
509 PyErr_Clear();
554 PyErr_Clear();
510 if (obj && !PythonQtSlotFunction_Check(obj)) {
555 if (obj && !PythonQtSlotFunction_Check(obj)) {
511 static const char* argumentList[] ={"" , "QDropEvent*"};
556 static const char* argumentList[] ={"" , "QDropEvent*"};
512 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
557 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
513 void* args[2] = {NULL, (void*)&arg__1};
558 void* args[2] = {NULL, (void*)&arg__1};
514 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
559 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
515 if (result) { Py_DECREF(result); }
560 if (result) { Py_DECREF(result); }
516 Py_DECREF(obj);
561 Py_DECREF(obj);
517 return;
562 return;
518 }
563 }
519 }
564 }
520 MemSizeWdgt::dropEvent(arg__1);
565 MemSizeWdgt::dropEvent(arg__1);
521 }
566 }
522 void PythonQtShell_MemSizeWdgt::enterEvent(QEvent* arg__1)
567 void PythonQtShell_MemSizeWdgt::enterEvent(QEvent* arg__1)
523 {
568 {
524 if (_wrapper) {
569 if (_wrapper) {
525 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
570 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
526 PyErr_Clear();
571 PyErr_Clear();
527 if (obj && !PythonQtSlotFunction_Check(obj)) {
572 if (obj && !PythonQtSlotFunction_Check(obj)) {
528 static const char* argumentList[] ={"" , "QEvent*"};
573 static const char* argumentList[] ={"" , "QEvent*"};
529 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
574 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
530 void* args[2] = {NULL, (void*)&arg__1};
575 void* args[2] = {NULL, (void*)&arg__1};
531 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
576 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
532 if (result) { Py_DECREF(result); }
577 if (result) { Py_DECREF(result); }
533 Py_DECREF(obj);
578 Py_DECREF(obj);
534 return;
579 return;
535 }
580 }
536 }
581 }
537 MemSizeWdgt::enterEvent(arg__1);
582 MemSizeWdgt::enterEvent(arg__1);
538 }
583 }
539 bool PythonQtShell_MemSizeWdgt::event(QEvent* arg__1)
584 bool PythonQtShell_MemSizeWdgt::event(QEvent* arg__1)
540 {
585 {
541 if (_wrapper) {
586 if (_wrapper) {
542 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
587 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
543 PyErr_Clear();
588 PyErr_Clear();
544 if (obj && !PythonQtSlotFunction_Check(obj)) {
589 if (obj && !PythonQtSlotFunction_Check(obj)) {
545 static const char* argumentList[] ={"bool" , "QEvent*"};
590 static const char* argumentList[] ={"bool" , "QEvent*"};
546 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
591 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
547 bool returnValue;
592 bool returnValue;
548 void* args[2] = {NULL, (void*)&arg__1};
593 void* args[2] = {NULL, (void*)&arg__1};
549 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
594 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
550 if (result) {
595 if (result) {
551 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
596 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
552 if (args[0]!=&returnValue) {
597 if (args[0]!=&returnValue) {
553 if (args[0]==NULL) {
598 if (args[0]==NULL) {
554 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
599 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
555 } else {
600 } else {
556 returnValue = *((bool*)args[0]);
601 returnValue = *((bool*)args[0]);
557 }
602 }
558 }
603 }
559 }
604 }
560 if (result) { Py_DECREF(result); }
605 if (result) { Py_DECREF(result); }
561 Py_DECREF(obj);
606 Py_DECREF(obj);
562 return returnValue;
607 return returnValue;
563 }
608 }
564 }
609 }
565 return MemSizeWdgt::event(arg__1);
610 return MemSizeWdgt::event(arg__1);
566 }
611 }
567 bool PythonQtShell_MemSizeWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
612 bool PythonQtShell_MemSizeWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
568 {
613 {
569 if (_wrapper) {
614 if (_wrapper) {
570 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
615 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
571 PyErr_Clear();
616 PyErr_Clear();
572 if (obj && !PythonQtSlotFunction_Check(obj)) {
617 if (obj && !PythonQtSlotFunction_Check(obj)) {
573 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
618 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
574 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
619 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
575 bool returnValue;
620 bool returnValue;
576 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
621 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
577 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
622 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
578 if (result) {
623 if (result) {
579 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
624 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
580 if (args[0]!=&returnValue) {
625 if (args[0]!=&returnValue) {
581 if (args[0]==NULL) {
626 if (args[0]==NULL) {
582 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
627 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
583 } else {
628 } else {
584 returnValue = *((bool*)args[0]);
629 returnValue = *((bool*)args[0]);
585 }
630 }
586 }
631 }
587 }
632 }
588 if (result) { Py_DECREF(result); }
633 if (result) { Py_DECREF(result); }
589 Py_DECREF(obj);
634 Py_DECREF(obj);
590 return returnValue;
635 return returnValue;
591 }
636 }
592 }
637 }
593 return MemSizeWdgt::eventFilter(arg__1, arg__2);
638 return MemSizeWdgt::eventFilter(arg__1, arg__2);
594 }
639 }
595 void PythonQtShell_MemSizeWdgt::focusInEvent(QFocusEvent* arg__1)
640 void PythonQtShell_MemSizeWdgt::focusInEvent(QFocusEvent* arg__1)
596 {
641 {
597 if (_wrapper) {
642 if (_wrapper) {
598 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
643 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
599 PyErr_Clear();
644 PyErr_Clear();
600 if (obj && !PythonQtSlotFunction_Check(obj)) {
645 if (obj && !PythonQtSlotFunction_Check(obj)) {
601 static const char* argumentList[] ={"" , "QFocusEvent*"};
646 static const char* argumentList[] ={"" , "QFocusEvent*"};
602 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
647 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
603 void* args[2] = {NULL, (void*)&arg__1};
648 void* args[2] = {NULL, (void*)&arg__1};
604 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
649 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
605 if (result) { Py_DECREF(result); }
650 if (result) { Py_DECREF(result); }
606 Py_DECREF(obj);
651 Py_DECREF(obj);
607 return;
652 return;
608 }
653 }
609 }
654 }
610 MemSizeWdgt::focusInEvent(arg__1);
655 MemSizeWdgt::focusInEvent(arg__1);
611 }
656 }
612 bool PythonQtShell_MemSizeWdgt::focusNextPrevChild(bool next)
657 bool PythonQtShell_MemSizeWdgt::focusNextPrevChild(bool next)
613 {
658 {
614 if (_wrapper) {
659 if (_wrapper) {
615 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
660 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
616 PyErr_Clear();
661 PyErr_Clear();
617 if (obj && !PythonQtSlotFunction_Check(obj)) {
662 if (obj && !PythonQtSlotFunction_Check(obj)) {
618 static const char* argumentList[] ={"bool" , "bool"};
663 static const char* argumentList[] ={"bool" , "bool"};
619 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
664 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
620 bool returnValue;
665 bool returnValue;
621 void* args[2] = {NULL, (void*)&next};
666 void* args[2] = {NULL, (void*)&next};
622 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
667 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
623 if (result) {
668 if (result) {
624 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
669 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
625 if (args[0]!=&returnValue) {
670 if (args[0]!=&returnValue) {
626 if (args[0]==NULL) {
671 if (args[0]==NULL) {
627 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
672 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
628 } else {
673 } else {
629 returnValue = *((bool*)args[0]);
674 returnValue = *((bool*)args[0]);
630 }
675 }
631 }
676 }
632 }
677 }
633 if (result) { Py_DECREF(result); }
678 if (result) { Py_DECREF(result); }
634 Py_DECREF(obj);
679 Py_DECREF(obj);
635 return returnValue;
680 return returnValue;
636 }
681 }
637 }
682 }
638 return MemSizeWdgt::focusNextPrevChild(next);
683 return MemSizeWdgt::focusNextPrevChild(next);
639 }
684 }
640 void PythonQtShell_MemSizeWdgt::focusOutEvent(QFocusEvent* arg__1)
685 void PythonQtShell_MemSizeWdgt::focusOutEvent(QFocusEvent* arg__1)
641 {
686 {
642 if (_wrapper) {
687 if (_wrapper) {
643 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
688 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
644 PyErr_Clear();
689 PyErr_Clear();
645 if (obj && !PythonQtSlotFunction_Check(obj)) {
690 if (obj && !PythonQtSlotFunction_Check(obj)) {
646 static const char* argumentList[] ={"" , "QFocusEvent*"};
691 static const char* argumentList[] ={"" , "QFocusEvent*"};
647 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
692 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
648 void* args[2] = {NULL, (void*)&arg__1};
693 void* args[2] = {NULL, (void*)&arg__1};
649 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
694 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
650 if (result) { Py_DECREF(result); }
695 if (result) { Py_DECREF(result); }
651 Py_DECREF(obj);
696 Py_DECREF(obj);
652 return;
697 return;
653 }
698 }
654 }
699 }
655 MemSizeWdgt::focusOutEvent(arg__1);
700 MemSizeWdgt::focusOutEvent(arg__1);
656 }
701 }
657 bool PythonQtShell_MemSizeWdgt::hasHeightForWidth() const
702 bool PythonQtShell_MemSizeWdgt::hasHeightForWidth() const
658 {
703 {
659 if (_wrapper) {
704 if (_wrapper) {
660 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
705 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
661 PyErr_Clear();
706 PyErr_Clear();
662 if (obj && !PythonQtSlotFunction_Check(obj)) {
707 if (obj && !PythonQtSlotFunction_Check(obj)) {
663 static const char* argumentList[] ={"bool"};
708 static const char* argumentList[] ={"bool"};
664 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
709 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
665 bool returnValue;
710 bool returnValue;
666 void* args[1] = {NULL};
711 void* args[1] = {NULL};
667 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
712 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
668 if (result) {
713 if (result) {
669 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
714 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
670 if (args[0]!=&returnValue) {
715 if (args[0]!=&returnValue) {
671 if (args[0]==NULL) {
716 if (args[0]==NULL) {
672 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
717 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
673 } else {
718 } else {
674 returnValue = *((bool*)args[0]);
719 returnValue = *((bool*)args[0]);
675 }
720 }
676 }
721 }
677 }
722 }
678 if (result) { Py_DECREF(result); }
723 if (result) { Py_DECREF(result); }
679 Py_DECREF(obj);
724 Py_DECREF(obj);
680 return returnValue;
725 return returnValue;
681 }
726 }
682 }
727 }
683 return MemSizeWdgt::hasHeightForWidth();
728 return MemSizeWdgt::hasHeightForWidth();
684 }
729 }
685 int PythonQtShell_MemSizeWdgt::heightForWidth(int arg__1) const
730 int PythonQtShell_MemSizeWdgt::heightForWidth(int arg__1) const
686 {
731 {
687 if (_wrapper) {
732 if (_wrapper) {
688 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
733 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
689 PyErr_Clear();
734 PyErr_Clear();
690 if (obj && !PythonQtSlotFunction_Check(obj)) {
735 if (obj && !PythonQtSlotFunction_Check(obj)) {
691 static const char* argumentList[] ={"int" , "int"};
736 static const char* argumentList[] ={"int" , "int"};
692 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
737 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
693 int returnValue;
738 int returnValue;
694 void* args[2] = {NULL, (void*)&arg__1};
739 void* args[2] = {NULL, (void*)&arg__1};
695 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
740 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
696 if (result) {
741 if (result) {
697 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
742 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
698 if (args[0]!=&returnValue) {
743 if (args[0]!=&returnValue) {
699 if (args[0]==NULL) {
744 if (args[0]==NULL) {
700 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
745 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
701 } else {
746 } else {
702 returnValue = *((int*)args[0]);
747 returnValue = *((int*)args[0]);
703 }
748 }
704 }
749 }
705 }
750 }
706 if (result) { Py_DECREF(result); }
751 if (result) { Py_DECREF(result); }
707 Py_DECREF(obj);
752 Py_DECREF(obj);
708 return returnValue;
753 return returnValue;
709 }
754 }
710 }
755 }
711 return MemSizeWdgt::heightForWidth(arg__1);
756 return MemSizeWdgt::heightForWidth(arg__1);
712 }
757 }
713 void PythonQtShell_MemSizeWdgt::hideEvent(QHideEvent* arg__1)
758 void PythonQtShell_MemSizeWdgt::hideEvent(QHideEvent* arg__1)
714 {
759 {
715 if (_wrapper) {
760 if (_wrapper) {
716 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
761 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
717 PyErr_Clear();
762 PyErr_Clear();
718 if (obj && !PythonQtSlotFunction_Check(obj)) {
763 if (obj && !PythonQtSlotFunction_Check(obj)) {
719 static const char* argumentList[] ={"" , "QHideEvent*"};
764 static const char* argumentList[] ={"" , "QHideEvent*"};
720 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
765 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
721 void* args[2] = {NULL, (void*)&arg__1};
766 void* args[2] = {NULL, (void*)&arg__1};
722 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
767 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
723 if (result) { Py_DECREF(result); }
768 if (result) { Py_DECREF(result); }
724 Py_DECREF(obj);
769 Py_DECREF(obj);
725 return;
770 return;
726 }
771 }
727 }
772 }
728 MemSizeWdgt::hideEvent(arg__1);
773 MemSizeWdgt::hideEvent(arg__1);
729 }
774 }
730 void PythonQtShell_MemSizeWdgt::initPainter(QPainter* painter) const
775 void PythonQtShell_MemSizeWdgt::initPainter(QPainter* painter) const
731 {
776 {
732 if (_wrapper) {
777 if (_wrapper) {
733 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
778 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
734 PyErr_Clear();
779 PyErr_Clear();
735 if (obj && !PythonQtSlotFunction_Check(obj)) {
780 if (obj && !PythonQtSlotFunction_Check(obj)) {
736 static const char* argumentList[] ={"" , "QPainter*"};
781 static const char* argumentList[] ={"" , "QPainter*"};
737 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
782 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
738 void* args[2] = {NULL, (void*)&painter};
783 void* args[2] = {NULL, (void*)&painter};
739 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
784 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
740 if (result) { Py_DECREF(result); }
785 if (result) { Py_DECREF(result); }
741 Py_DECREF(obj);
786 Py_DECREF(obj);
742 return;
787 return;
743 }
788 }
744 }
789 }
745 MemSizeWdgt::initPainter(painter);
790 MemSizeWdgt::initPainter(painter);
746 }
791 }
747 void PythonQtShell_MemSizeWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
792 void PythonQtShell_MemSizeWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
748 {
793 {
749 if (_wrapper) {
794 if (_wrapper) {
750 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
795 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
751 PyErr_Clear();
796 PyErr_Clear();
752 if (obj && !PythonQtSlotFunction_Check(obj)) {
797 if (obj && !PythonQtSlotFunction_Check(obj)) {
753 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
798 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
754 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
799 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
755 void* args[2] = {NULL, (void*)&arg__1};
800 void* args[2] = {NULL, (void*)&arg__1};
756 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
801 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
757 if (result) { Py_DECREF(result); }
802 if (result) { Py_DECREF(result); }
758 Py_DECREF(obj);
803 Py_DECREF(obj);
759 return;
804 return;
760 }
805 }
761 }
806 }
762 MemSizeWdgt::inputMethodEvent(arg__1);
807 MemSizeWdgt::inputMethodEvent(arg__1);
763 }
808 }
764 QVariant PythonQtShell_MemSizeWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
809 QVariant PythonQtShell_MemSizeWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
765 {
810 {
766 if (_wrapper) {
811 if (_wrapper) {
767 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
812 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
768 PyErr_Clear();
813 PyErr_Clear();
769 if (obj && !PythonQtSlotFunction_Check(obj)) {
814 if (obj && !PythonQtSlotFunction_Check(obj)) {
770 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
815 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
771 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
816 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
772 QVariant returnValue;
817 QVariant returnValue;
773 void* args[2] = {NULL, (void*)&arg__1};
818 void* args[2] = {NULL, (void*)&arg__1};
774 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
819 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
775 if (result) {
820 if (result) {
776 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
821 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
777 if (args[0]!=&returnValue) {
822 if (args[0]!=&returnValue) {
778 if (args[0]==NULL) {
823 if (args[0]==NULL) {
779 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
824 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
780 } else {
825 } else {
781 returnValue = *((QVariant*)args[0]);
826 returnValue = *((QVariant*)args[0]);
782 }
827 }
783 }
828 }
784 }
829 }
785 if (result) { Py_DECREF(result); }
830 if (result) { Py_DECREF(result); }
786 Py_DECREF(obj);
831 Py_DECREF(obj);
787 return returnValue;
832 return returnValue;
788 }
833 }
789 }
834 }
790 return MemSizeWdgt::inputMethodQuery(arg__1);
835 return MemSizeWdgt::inputMethodQuery(arg__1);
791 }
836 }
792 void PythonQtShell_MemSizeWdgt::keyPressEvent(QKeyEvent* arg__1)
837 void PythonQtShell_MemSizeWdgt::keyPressEvent(QKeyEvent* arg__1)
793 {
838 {
794 if (_wrapper) {
839 if (_wrapper) {
795 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
840 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
796 PyErr_Clear();
841 PyErr_Clear();
797 if (obj && !PythonQtSlotFunction_Check(obj)) {
842 if (obj && !PythonQtSlotFunction_Check(obj)) {
798 static const char* argumentList[] ={"" , "QKeyEvent*"};
843 static const char* argumentList[] ={"" , "QKeyEvent*"};
799 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
844 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
800 void* args[2] = {NULL, (void*)&arg__1};
845 void* args[2] = {NULL, (void*)&arg__1};
801 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
846 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
802 if (result) { Py_DECREF(result); }
847 if (result) { Py_DECREF(result); }
803 Py_DECREF(obj);
848 Py_DECREF(obj);
804 return;
849 return;
805 }
850 }
806 }
851 }
807 MemSizeWdgt::keyPressEvent(arg__1);
852 MemSizeWdgt::keyPressEvent(arg__1);
808 }
853 }
809 void PythonQtShell_MemSizeWdgt::keyReleaseEvent(QKeyEvent* arg__1)
854 void PythonQtShell_MemSizeWdgt::keyReleaseEvent(QKeyEvent* arg__1)
810 {
855 {
811 if (_wrapper) {
856 if (_wrapper) {
812 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
857 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
813 PyErr_Clear();
858 PyErr_Clear();
814 if (obj && !PythonQtSlotFunction_Check(obj)) {
859 if (obj && !PythonQtSlotFunction_Check(obj)) {
815 static const char* argumentList[] ={"" , "QKeyEvent*"};
860 static const char* argumentList[] ={"" , "QKeyEvent*"};
816 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
861 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
817 void* args[2] = {NULL, (void*)&arg__1};
862 void* args[2] = {NULL, (void*)&arg__1};
818 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
863 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
819 if (result) { Py_DECREF(result); }
864 if (result) { Py_DECREF(result); }
820 Py_DECREF(obj);
865 Py_DECREF(obj);
821 return;
866 return;
822 }
867 }
823 }
868 }
824 MemSizeWdgt::keyReleaseEvent(arg__1);
869 MemSizeWdgt::keyReleaseEvent(arg__1);
825 }
870 }
826 void PythonQtShell_MemSizeWdgt::leaveEvent(QEvent* arg__1)
871 void PythonQtShell_MemSizeWdgt::leaveEvent(QEvent* arg__1)
827 {
872 {
828 if (_wrapper) {
873 if (_wrapper) {
829 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
874 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
830 PyErr_Clear();
875 PyErr_Clear();
831 if (obj && !PythonQtSlotFunction_Check(obj)) {
876 if (obj && !PythonQtSlotFunction_Check(obj)) {
832 static const char* argumentList[] ={"" , "QEvent*"};
877 static const char* argumentList[] ={"" , "QEvent*"};
833 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
878 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
834 void* args[2] = {NULL, (void*)&arg__1};
879 void* args[2] = {NULL, (void*)&arg__1};
835 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
880 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
836 if (result) { Py_DECREF(result); }
881 if (result) { Py_DECREF(result); }
837 Py_DECREF(obj);
882 Py_DECREF(obj);
838 return;
883 return;
839 }
884 }
840 }
885 }
841 MemSizeWdgt::leaveEvent(arg__1);
886 MemSizeWdgt::leaveEvent(arg__1);
842 }
887 }
843 int PythonQtShell_MemSizeWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
888 int PythonQtShell_MemSizeWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
844 {
889 {
845 if (_wrapper) {
890 if (_wrapper) {
846 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
891 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
847 PyErr_Clear();
892 PyErr_Clear();
848 if (obj && !PythonQtSlotFunction_Check(obj)) {
893 if (obj && !PythonQtSlotFunction_Check(obj)) {
849 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
894 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
850 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
895 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
851 int returnValue;
896 int returnValue;
852 void* args[2] = {NULL, (void*)&arg__1};
897 void* args[2] = {NULL, (void*)&arg__1};
853 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
898 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
854 if (result) {
899 if (result) {
855 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
900 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
856 if (args[0]!=&returnValue) {
901 if (args[0]!=&returnValue) {
857 if (args[0]==NULL) {
902 if (args[0]==NULL) {
858 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
903 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
859 } else {
904 } else {
860 returnValue = *((int*)args[0]);
905 returnValue = *((int*)args[0]);
861 }
906 }
862 }
907 }
863 }
908 }
864 if (result) { Py_DECREF(result); }
909 if (result) { Py_DECREF(result); }
865 Py_DECREF(obj);
910 Py_DECREF(obj);
866 return returnValue;
911 return returnValue;
867 }
912 }
868 }
913 }
869 return MemSizeWdgt::metric(arg__1);
914 return MemSizeWdgt::metric(arg__1);
870 }
915 }
871 QSize PythonQtShell_MemSizeWdgt::minimumSizeHint() const
916 QSize PythonQtShell_MemSizeWdgt::minimumSizeHint() const
872 {
917 {
873 if (_wrapper) {
918 if (_wrapper) {
874 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
919 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
875 PyErr_Clear();
920 PyErr_Clear();
876 if (obj && !PythonQtSlotFunction_Check(obj)) {
921 if (obj && !PythonQtSlotFunction_Check(obj)) {
877 static const char* argumentList[] ={"QSize"};
922 static const char* argumentList[] ={"QSize"};
878 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
923 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
879 QSize returnValue;
924 QSize returnValue;
880 void* args[1] = {NULL};
925 void* args[1] = {NULL};
881 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
926 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
882 if (result) {
927 if (result) {
883 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
928 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
884 if (args[0]!=&returnValue) {
929 if (args[0]!=&returnValue) {
885 if (args[0]==NULL) {
930 if (args[0]==NULL) {
886 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
931 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
887 } else {
932 } else {
888 returnValue = *((QSize*)args[0]);
933 returnValue = *((QSize*)args[0]);
889 }
934 }
890 }
935 }
891 }
936 }
892 if (result) { Py_DECREF(result); }
937 if (result) { Py_DECREF(result); }
893 Py_DECREF(obj);
938 Py_DECREF(obj);
894 return returnValue;
939 return returnValue;
895 }
940 }
896 }
941 }
897 return MemSizeWdgt::minimumSizeHint();
942 return MemSizeWdgt::minimumSizeHint();
898 }
943 }
899 void PythonQtShell_MemSizeWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
944 void PythonQtShell_MemSizeWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
900 {
945 {
901 if (_wrapper) {
946 if (_wrapper) {
902 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
947 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
903 PyErr_Clear();
948 PyErr_Clear();
904 if (obj && !PythonQtSlotFunction_Check(obj)) {
949 if (obj && !PythonQtSlotFunction_Check(obj)) {
905 static const char* argumentList[] ={"" , "QMouseEvent*"};
950 static const char* argumentList[] ={"" , "QMouseEvent*"};
906 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
951 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
907 void* args[2] = {NULL, (void*)&arg__1};
952 void* args[2] = {NULL, (void*)&arg__1};
908 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
953 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
909 if (result) { Py_DECREF(result); }
954 if (result) { Py_DECREF(result); }
910 Py_DECREF(obj);
955 Py_DECREF(obj);
911 return;
956 return;
912 }
957 }
913 }
958 }
914 MemSizeWdgt::mouseDoubleClickEvent(arg__1);
959 MemSizeWdgt::mouseDoubleClickEvent(arg__1);
915 }
960 }
916 void PythonQtShell_MemSizeWdgt::mouseMoveEvent(QMouseEvent* arg__1)
961 void PythonQtShell_MemSizeWdgt::mouseMoveEvent(QMouseEvent* arg__1)
917 {
962 {
918 if (_wrapper) {
963 if (_wrapper) {
919 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
964 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
920 PyErr_Clear();
965 PyErr_Clear();
921 if (obj && !PythonQtSlotFunction_Check(obj)) {
966 if (obj && !PythonQtSlotFunction_Check(obj)) {
922 static const char* argumentList[] ={"" , "QMouseEvent*"};
967 static const char* argumentList[] ={"" , "QMouseEvent*"};
923 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
968 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
924 void* args[2] = {NULL, (void*)&arg__1};
969 void* args[2] = {NULL, (void*)&arg__1};
925 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
970 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
926 if (result) { Py_DECREF(result); }
971 if (result) { Py_DECREF(result); }
927 Py_DECREF(obj);
972 Py_DECREF(obj);
928 return;
973 return;
929 }
974 }
930 }
975 }
931 MemSizeWdgt::mouseMoveEvent(arg__1);
976 MemSizeWdgt::mouseMoveEvent(arg__1);
932 }
977 }
933 void PythonQtShell_MemSizeWdgt::mousePressEvent(QMouseEvent* arg__1)
978 void PythonQtShell_MemSizeWdgt::mousePressEvent(QMouseEvent* arg__1)
934 {
979 {
935 if (_wrapper) {
980 if (_wrapper) {
936 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
981 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
937 PyErr_Clear();
982 PyErr_Clear();
938 if (obj && !PythonQtSlotFunction_Check(obj)) {
983 if (obj && !PythonQtSlotFunction_Check(obj)) {
939 static const char* argumentList[] ={"" , "QMouseEvent*"};
984 static const char* argumentList[] ={"" , "QMouseEvent*"};
940 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
985 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
941 void* args[2] = {NULL, (void*)&arg__1};
986 void* args[2] = {NULL, (void*)&arg__1};
942 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
987 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
943 if (result) { Py_DECREF(result); }
988 if (result) { Py_DECREF(result); }
944 Py_DECREF(obj);
989 Py_DECREF(obj);
945 return;
990 return;
946 }
991 }
947 }
992 }
948 MemSizeWdgt::mousePressEvent(arg__1);
993 MemSizeWdgt::mousePressEvent(arg__1);
949 }
994 }
950 void PythonQtShell_MemSizeWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
995 void PythonQtShell_MemSizeWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
951 {
996 {
952 if (_wrapper) {
997 if (_wrapper) {
953 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
998 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
954 PyErr_Clear();
999 PyErr_Clear();
955 if (obj && !PythonQtSlotFunction_Check(obj)) {
1000 if (obj && !PythonQtSlotFunction_Check(obj)) {
956 static const char* argumentList[] ={"" , "QMouseEvent*"};
1001 static const char* argumentList[] ={"" , "QMouseEvent*"};
957 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1002 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
958 void* args[2] = {NULL, (void*)&arg__1};
1003 void* args[2] = {NULL, (void*)&arg__1};
959 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1004 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
960 if (result) { Py_DECREF(result); }
1005 if (result) { Py_DECREF(result); }
961 Py_DECREF(obj);
1006 Py_DECREF(obj);
962 return;
1007 return;
963 }
1008 }
964 }
1009 }
965 MemSizeWdgt::mouseReleaseEvent(arg__1);
1010 MemSizeWdgt::mouseReleaseEvent(arg__1);
966 }
1011 }
967 void PythonQtShell_MemSizeWdgt::moveEvent(QMoveEvent* arg__1)
1012 void PythonQtShell_MemSizeWdgt::moveEvent(QMoveEvent* arg__1)
968 {
1013 {
969 if (_wrapper) {
1014 if (_wrapper) {
970 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
1015 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
971 PyErr_Clear();
1016 PyErr_Clear();
972 if (obj && !PythonQtSlotFunction_Check(obj)) {
1017 if (obj && !PythonQtSlotFunction_Check(obj)) {
973 static const char* argumentList[] ={"" , "QMoveEvent*"};
1018 static const char* argumentList[] ={"" , "QMoveEvent*"};
974 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1019 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
975 void* args[2] = {NULL, (void*)&arg__1};
1020 void* args[2] = {NULL, (void*)&arg__1};
976 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1021 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
977 if (result) { Py_DECREF(result); }
1022 if (result) { Py_DECREF(result); }
978 Py_DECREF(obj);
1023 Py_DECREF(obj);
979 return;
1024 return;
980 }
1025 }
981 }
1026 }
982 MemSizeWdgt::moveEvent(arg__1);
1027 MemSizeWdgt::moveEvent(arg__1);
983 }
1028 }
984 bool PythonQtShell_MemSizeWdgt::nativeEvent(const QByteArray& eventType, void* message, long* result)
1029 bool PythonQtShell_MemSizeWdgt::nativeEvent(const QByteArray& eventType, void* message, long* result)
985 {
1030 {
986 if (_wrapper) {
1031 if (_wrapper) {
987 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
1032 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
988 PyErr_Clear();
1033 PyErr_Clear();
989 if (obj && !PythonQtSlotFunction_Check(obj)) {
1034 if (obj && !PythonQtSlotFunction_Check(obj)) {
990 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
1035 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
991 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
1036 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
992 bool returnValue;
1037 bool returnValue;
993 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
1038 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
994 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1039 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
995 if (result) {
1040 if (result) {
996 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1041 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
997 if (args[0]!=&returnValue) {
1042 if (args[0]!=&returnValue) {
998 if (args[0]==NULL) {
1043 if (args[0]==NULL) {
999 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
1044 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
1000 } else {
1045 } else {
1001 returnValue = *((bool*)args[0]);
1046 returnValue = *((bool*)args[0]);
1002 }
1047 }
1003 }
1048 }
1004 }
1049 }
1005 if (result) { Py_DECREF(result); }
1050 if (result) { Py_DECREF(result); }
1006 Py_DECREF(obj);
1051 Py_DECREF(obj);
1007 return returnValue;
1052 return returnValue;
1008 }
1053 }
1009 }
1054 }
1010 return MemSizeWdgt::nativeEvent(eventType, message, result);
1055 return MemSizeWdgt::nativeEvent(eventType, message, result);
1011 }
1056 }
1012 QPaintEngine* PythonQtShell_MemSizeWdgt::paintEngine() const
1057 QPaintEngine* PythonQtShell_MemSizeWdgt::paintEngine() const
1013 {
1058 {
1014 if (_wrapper) {
1059 if (_wrapper) {
1015 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
1060 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
1016 PyErr_Clear();
1061 PyErr_Clear();
1017 if (obj && !PythonQtSlotFunction_Check(obj)) {
1062 if (obj && !PythonQtSlotFunction_Check(obj)) {
1018 static const char* argumentList[] ={"QPaintEngine*"};
1063 static const char* argumentList[] ={"QPaintEngine*"};
1019 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1064 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1020 QPaintEngine* returnValue;
1065 QPaintEngine* returnValue;
1021 void* args[1] = {NULL};
1066 void* args[1] = {NULL};
1022 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1067 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1023 if (result) {
1068 if (result) {
1024 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1069 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1025 if (args[0]!=&returnValue) {
1070 if (args[0]!=&returnValue) {
1026 if (args[0]==NULL) {
1071 if (args[0]==NULL) {
1027 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
1072 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
1028 } else {
1073 } else {
1029 returnValue = *((QPaintEngine**)args[0]);
1074 returnValue = *((QPaintEngine**)args[0]);
1030 }
1075 }
1031 }
1076 }
1032 }
1077 }
1033 if (result) { Py_DECREF(result); }
1078 if (result) { Py_DECREF(result); }
1034 Py_DECREF(obj);
1079 Py_DECREF(obj);
1035 return returnValue;
1080 return returnValue;
1036 }
1081 }
1037 }
1082 }
1038 return MemSizeWdgt::paintEngine();
1083 return MemSizeWdgt::paintEngine();
1039 }
1084 }
1040 void PythonQtShell_MemSizeWdgt::paintEvent(QPaintEvent* arg__1)
1085 void PythonQtShell_MemSizeWdgt::paintEvent(QPaintEvent* arg__1)
1041 {
1086 {
1042 if (_wrapper) {
1087 if (_wrapper) {
1043 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
1088 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
1044 PyErr_Clear();
1089 PyErr_Clear();
1045 if (obj && !PythonQtSlotFunction_Check(obj)) {
1090 if (obj && !PythonQtSlotFunction_Check(obj)) {
1046 static const char* argumentList[] ={"" , "QPaintEvent*"};
1091 static const char* argumentList[] ={"" , "QPaintEvent*"};
1047 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1092 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1048 void* args[2] = {NULL, (void*)&arg__1};
1093 void* args[2] = {NULL, (void*)&arg__1};
1049 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1094 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1050 if (result) { Py_DECREF(result); }
1095 if (result) { Py_DECREF(result); }
1051 Py_DECREF(obj);
1096 Py_DECREF(obj);
1052 return;
1097 return;
1053 }
1098 }
1054 }
1099 }
1055 MemSizeWdgt::paintEvent(arg__1);
1100 MemSizeWdgt::paintEvent(arg__1);
1056 }
1101 }
1057 QPaintDevice* PythonQtShell_MemSizeWdgt::redirected(QPoint* offset) const
1102 QPaintDevice* PythonQtShell_MemSizeWdgt::redirected(QPoint* offset) const
1058 {
1103 {
1059 if (_wrapper) {
1104 if (_wrapper) {
1060 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
1105 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
1061 PyErr_Clear();
1106 PyErr_Clear();
1062 if (obj && !PythonQtSlotFunction_Check(obj)) {
1107 if (obj && !PythonQtSlotFunction_Check(obj)) {
1063 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
1108 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
1064 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1109 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1065 QPaintDevice* returnValue;
1110 QPaintDevice* returnValue;
1066 void* args[2] = {NULL, (void*)&offset};
1111 void* args[2] = {NULL, (void*)&offset};
1067 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1112 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1068 if (result) {
1113 if (result) {
1069 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1114 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1070 if (args[0]!=&returnValue) {
1115 if (args[0]!=&returnValue) {
1071 if (args[0]==NULL) {
1116 if (args[0]==NULL) {
1072 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
1117 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
1073 } else {
1118 } else {
1074 returnValue = *((QPaintDevice**)args[0]);
1119 returnValue = *((QPaintDevice**)args[0]);
1075 }
1120 }
1076 }
1121 }
1077 }
1122 }
1078 if (result) { Py_DECREF(result); }
1123 if (result) { Py_DECREF(result); }
1079 Py_DECREF(obj);
1124 Py_DECREF(obj);
1080 return returnValue;
1125 return returnValue;
1081 }
1126 }
1082 }
1127 }
1083 return MemSizeWdgt::redirected(offset);
1128 return MemSizeWdgt::redirected(offset);
1084 }
1129 }
1085 void PythonQtShell_MemSizeWdgt::resizeEvent(QResizeEvent* arg__1)
1130 void PythonQtShell_MemSizeWdgt::resizeEvent(QResizeEvent* arg__1)
1086 {
1131 {
1087 if (_wrapper) {
1132 if (_wrapper) {
1088 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
1133 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
1089 PyErr_Clear();
1134 PyErr_Clear();
1090 if (obj && !PythonQtSlotFunction_Check(obj)) {
1135 if (obj && !PythonQtSlotFunction_Check(obj)) {
1091 static const char* argumentList[] ={"" , "QResizeEvent*"};
1136 static const char* argumentList[] ={"" , "QResizeEvent*"};
1092 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1137 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1093 void* args[2] = {NULL, (void*)&arg__1};
1138 void* args[2] = {NULL, (void*)&arg__1};
1094 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1139 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1095 if (result) { Py_DECREF(result); }
1140 if (result) { Py_DECREF(result); }
1096 Py_DECREF(obj);
1141 Py_DECREF(obj);
1097 return;
1142 return;
1098 }
1143 }
1099 }
1144 }
1100 MemSizeWdgt::resizeEvent(arg__1);
1145 MemSizeWdgt::resizeEvent(arg__1);
1101 }
1146 }
1102 QPainter* PythonQtShell_MemSizeWdgt::sharedPainter() const
1147 QPainter* PythonQtShell_MemSizeWdgt::sharedPainter() const
1103 {
1148 {
1104 if (_wrapper) {
1149 if (_wrapper) {
1105 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
1150 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
1106 PyErr_Clear();
1151 PyErr_Clear();
1107 if (obj && !PythonQtSlotFunction_Check(obj)) {
1152 if (obj && !PythonQtSlotFunction_Check(obj)) {
1108 static const char* argumentList[] ={"QPainter*"};
1153 static const char* argumentList[] ={"QPainter*"};
1109 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1154 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1110 QPainter* returnValue;
1155 QPainter* returnValue;
1111 void* args[1] = {NULL};
1156 void* args[1] = {NULL};
1112 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1157 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1113 if (result) {
1158 if (result) {
1114 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1159 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1115 if (args[0]!=&returnValue) {
1160 if (args[0]!=&returnValue) {
1116 if (args[0]==NULL) {
1161 if (args[0]==NULL) {
1117 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
1162 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
1118 } else {
1163 } else {
1119 returnValue = *((QPainter**)args[0]);
1164 returnValue = *((QPainter**)args[0]);
1120 }
1165 }
1121 }
1166 }
1122 }
1167 }
1123 if (result) { Py_DECREF(result); }
1168 if (result) { Py_DECREF(result); }
1124 Py_DECREF(obj);
1169 Py_DECREF(obj);
1125 return returnValue;
1170 return returnValue;
1126 }
1171 }
1127 }
1172 }
1128 return MemSizeWdgt::sharedPainter();
1173 return MemSizeWdgt::sharedPainter();
1129 }
1174 }
1130 void PythonQtShell_MemSizeWdgt::showEvent(QShowEvent* arg__1)
1175 void PythonQtShell_MemSizeWdgt::showEvent(QShowEvent* arg__1)
1131 {
1176 {
1132 if (_wrapper) {
1177 if (_wrapper) {
1133 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
1178 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
1134 PyErr_Clear();
1179 PyErr_Clear();
1135 if (obj && !PythonQtSlotFunction_Check(obj)) {
1180 if (obj && !PythonQtSlotFunction_Check(obj)) {
1136 static const char* argumentList[] ={"" , "QShowEvent*"};
1181 static const char* argumentList[] ={"" , "QShowEvent*"};
1137 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1182 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1138 void* args[2] = {NULL, (void*)&arg__1};
1183 void* args[2] = {NULL, (void*)&arg__1};
1139 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1184 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1140 if (result) { Py_DECREF(result); }
1185 if (result) { Py_DECREF(result); }
1141 Py_DECREF(obj);
1186 Py_DECREF(obj);
1142 return;
1187 return;
1143 }
1188 }
1144 }
1189 }
1145 MemSizeWdgt::showEvent(arg__1);
1190 MemSizeWdgt::showEvent(arg__1);
1146 }
1191 }
1147 QSize PythonQtShell_MemSizeWdgt::sizeHint() const
1192 QSize PythonQtShell_MemSizeWdgt::sizeHint() const
1148 {
1193 {
1149 if (_wrapper) {
1194 if (_wrapper) {
1150 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
1195 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
1151 PyErr_Clear();
1196 PyErr_Clear();
1152 if (obj && !PythonQtSlotFunction_Check(obj)) {
1197 if (obj && !PythonQtSlotFunction_Check(obj)) {
1153 static const char* argumentList[] ={"QSize"};
1198 static const char* argumentList[] ={"QSize"};
1154 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1199 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1155 QSize returnValue;
1200 QSize returnValue;
1156 void* args[1] = {NULL};
1201 void* args[1] = {NULL};
1157 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1202 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1158 if (result) {
1203 if (result) {
1159 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1204 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1160 if (args[0]!=&returnValue) {
1205 if (args[0]!=&returnValue) {
1161 if (args[0]==NULL) {
1206 if (args[0]==NULL) {
1162 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
1207 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
1163 } else {
1208 } else {
1164 returnValue = *((QSize*)args[0]);
1209 returnValue = *((QSize*)args[0]);
1165 }
1210 }
1166 }
1211 }
1167 }
1212 }
1168 if (result) { Py_DECREF(result); }
1213 if (result) { Py_DECREF(result); }
1169 Py_DECREF(obj);
1214 Py_DECREF(obj);
1170 return returnValue;
1215 return returnValue;
1171 }
1216 }
1172 }
1217 }
1173 return MemSizeWdgt::sizeHint();
1218 return MemSizeWdgt::sizeHint();
1174 }
1219 }
1175 void PythonQtShell_MemSizeWdgt::tabletEvent(QTabletEvent* arg__1)
1220 void PythonQtShell_MemSizeWdgt::tabletEvent(QTabletEvent* arg__1)
1176 {
1221 {
1177 if (_wrapper) {
1222 if (_wrapper) {
1178 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
1223 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
1179 PyErr_Clear();
1224 PyErr_Clear();
1180 if (obj && !PythonQtSlotFunction_Check(obj)) {
1225 if (obj && !PythonQtSlotFunction_Check(obj)) {
1181 static const char* argumentList[] ={"" , "QTabletEvent*"};
1226 static const char* argumentList[] ={"" , "QTabletEvent*"};
1182 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1227 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1183 void* args[2] = {NULL, (void*)&arg__1};
1228 void* args[2] = {NULL, (void*)&arg__1};
1184 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1229 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1185 if (result) { Py_DECREF(result); }
1230 if (result) { Py_DECREF(result); }
1186 Py_DECREF(obj);
1231 Py_DECREF(obj);
1187 return;
1232 return;
1188 }
1233 }
1189 }
1234 }
1190 MemSizeWdgt::tabletEvent(arg__1);
1235 MemSizeWdgt::tabletEvent(arg__1);
1191 }
1236 }
1192 void PythonQtShell_MemSizeWdgt::timerEvent(QTimerEvent* arg__1)
1237 void PythonQtShell_MemSizeWdgt::timerEvent(QTimerEvent* arg__1)
1193 {
1238 {
1194 if (_wrapper) {
1239 if (_wrapper) {
1195 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
1240 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
1196 PyErr_Clear();
1241 PyErr_Clear();
1197 if (obj && !PythonQtSlotFunction_Check(obj)) {
1242 if (obj && !PythonQtSlotFunction_Check(obj)) {
1198 static const char* argumentList[] ={"" , "QTimerEvent*"};
1243 static const char* argumentList[] ={"" , "QTimerEvent*"};
1199 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1244 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1200 void* args[2] = {NULL, (void*)&arg__1};
1245 void* args[2] = {NULL, (void*)&arg__1};
1201 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1246 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1202 if (result) { Py_DECREF(result); }
1247 if (result) { Py_DECREF(result); }
1203 Py_DECREF(obj);
1248 Py_DECREF(obj);
1204 return;
1249 return;
1205 }
1250 }
1206 }
1251 }
1207 MemSizeWdgt::timerEvent(arg__1);
1252 MemSizeWdgt::timerEvent(arg__1);
1208 }
1253 }
1209 void PythonQtShell_MemSizeWdgt::wheelEvent(QWheelEvent* arg__1)
1254 void PythonQtShell_MemSizeWdgt::wheelEvent(QWheelEvent* arg__1)
1210 {
1255 {
1211 if (_wrapper) {
1256 if (_wrapper) {
1212 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
1257 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
1213 PyErr_Clear();
1258 PyErr_Clear();
1214 if (obj && !PythonQtSlotFunction_Check(obj)) {
1259 if (obj && !PythonQtSlotFunction_Check(obj)) {
1215 static const char* argumentList[] ={"" , "QWheelEvent*"};
1260 static const char* argumentList[] ={"" , "QWheelEvent*"};
1216 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1261 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1217 void* args[2] = {NULL, (void*)&arg__1};
1262 void* args[2] = {NULL, (void*)&arg__1};
1218 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1263 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1219 if (result) { Py_DECREF(result); }
1264 if (result) { Py_DECREF(result); }
1220 Py_DECREF(obj);
1265 Py_DECREF(obj);
1221 return;
1266 return;
1222 }
1267 }
1223 }
1268 }
1224 MemSizeWdgt::wheelEvent(arg__1);
1269 MemSizeWdgt::wheelEvent(arg__1);
1225 }
1270 }
1226 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(QWidget* parent)
1271 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(QWidget* parent)
1227 {
1272 {
1228 return new PythonQtShell_MemSizeWdgt(parent); }
1273 return new PythonQtShell_MemSizeWdgt(parent); }
1229
1274
1230 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(int defaultSize, QWidget* parent)
1275 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(int defaultSize, QWidget* parent)
1231 {
1276 {
1232 return new PythonQtShell_MemSizeWdgt(defaultSize, parent); }
1277 return new PythonQtShell_MemSizeWdgt(defaultSize, parent); }
1233
1278
1234 int PythonQtWrapper_MemSizeWdgt::getsize(MemSizeWdgt* theWrappedObject)
1279 int PythonQtWrapper_MemSizeWdgt::getsize(MemSizeWdgt* theWrappedObject)
1235 {
1280 {
1236 return ( theWrappedObject->getsize());
1281 return ( theWrappedObject->getsize());
1237 }
1282 }
1238
1283
1239 void PythonQtWrapper_MemSizeWdgt::setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max)
1284 void PythonQtWrapper_MemSizeWdgt::setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max)
1240 {
1285 {
1241 ( theWrappedObject->setMaximum(max));
1286 ( theWrappedObject->setMaximum(max));
1242 }
1287 }
1243
1288
1244 void PythonQtWrapper_MemSizeWdgt::show(MemSizeWdgt* theWrappedObject)
1289 void PythonQtWrapper_MemSizeWdgt::show(MemSizeWdgt* theWrappedObject)
1245 {
1290 {
1246 ( theWrappedObject->show());
1291 ( theWrappedObject->show());
1247 }
1292 }
1248
1293
1249 void PythonQtWrapper_MemSizeWdgt::updateSizeValue(MemSizeWdgt* theWrappedObject)
1294 void PythonQtWrapper_MemSizeWdgt::updateSizeValue(MemSizeWdgt* theWrappedObject)
1250 {
1295 {
1251 ( theWrappedObject->updateSizeValue());
1296 ( theWrappedObject->updateSizeValue());
1252 }
1297 }
1253
1298
1254
1299
1255
1300
1256 PythonQtShell_QHexEdit::~PythonQtShell_QHexEdit() {
1301 PythonQtShell_QHexEdit::~PythonQtShell_QHexEdit() {
1257 PythonQtPrivate* priv = PythonQt::priv();
1302 PythonQtPrivate* priv = PythonQt::priv();
1258 if (priv) { priv->shellClassDeleted(this); }
1303 if (priv) { priv->shellClassDeleted(this); }
1259 }
1304 }
1260 void PythonQtShell_QHexEdit::actionEvent(QActionEvent* arg__1)
1305 void PythonQtShell_QHexEdit::actionEvent(QActionEvent* arg__1)
1261 {
1306 {
1262 if (_wrapper) {
1307 if (_wrapper) {
1263 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
1308 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
1264 PyErr_Clear();
1309 PyErr_Clear();
1265 if (obj && !PythonQtSlotFunction_Check(obj)) {
1310 if (obj && !PythonQtSlotFunction_Check(obj)) {
1266 static const char* argumentList[] ={"" , "QActionEvent*"};
1311 static const char* argumentList[] ={"" , "QActionEvent*"};
1267 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1312 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1268 void* args[2] = {NULL, (void*)&arg__1};
1313 void* args[2] = {NULL, (void*)&arg__1};
1269 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1314 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1270 if (result) { Py_DECREF(result); }
1315 if (result) { Py_DECREF(result); }
1271 Py_DECREF(obj);
1316 Py_DECREF(obj);
1272 return;
1317 return;
1273 }
1318 }
1274 }
1319 }
1275 QHexEdit::actionEvent(arg__1);
1320 QHexEdit::actionEvent(arg__1);
1276 }
1321 }
1277 void PythonQtShell_QHexEdit::changeEvent(QEvent* arg__1)
1322 void PythonQtShell_QHexEdit::changeEvent(QEvent* arg__1)
1278 {
1323 {
1279 if (_wrapper) {
1324 if (_wrapper) {
1280 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
1325 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
1281 PyErr_Clear();
1326 PyErr_Clear();
1282 if (obj && !PythonQtSlotFunction_Check(obj)) {
1327 if (obj && !PythonQtSlotFunction_Check(obj)) {
1283 static const char* argumentList[] ={"" , "QEvent*"};
1328 static const char* argumentList[] ={"" , "QEvent*"};
1284 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1329 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1285 void* args[2] = {NULL, (void*)&arg__1};
1330 void* args[2] = {NULL, (void*)&arg__1};
1286 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1331 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1287 if (result) { Py_DECREF(result); }
1332 if (result) { Py_DECREF(result); }
1288 Py_DECREF(obj);
1333 Py_DECREF(obj);
1289 return;
1334 return;
1290 }
1335 }
1291 }
1336 }
1292 QHexEdit::changeEvent(arg__1);
1337 QHexEdit::changeEvent(arg__1);
1293 }
1338 }
1294 void PythonQtShell_QHexEdit::childEvent(QChildEvent* arg__1)
1339 void PythonQtShell_QHexEdit::childEvent(QChildEvent* arg__1)
1295 {
1340 {
1296 if (_wrapper) {
1341 if (_wrapper) {
1297 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
1342 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
1298 PyErr_Clear();
1343 PyErr_Clear();
1299 if (obj && !PythonQtSlotFunction_Check(obj)) {
1344 if (obj && !PythonQtSlotFunction_Check(obj)) {
1300 static const char* argumentList[] ={"" , "QChildEvent*"};
1345 static const char* argumentList[] ={"" , "QChildEvent*"};
1301 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1346 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1302 void* args[2] = {NULL, (void*)&arg__1};
1347 void* args[2] = {NULL, (void*)&arg__1};
1303 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1348 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1304 if (result) { Py_DECREF(result); }
1349 if (result) { Py_DECREF(result); }
1305 Py_DECREF(obj);
1350 Py_DECREF(obj);
1306 return;
1351 return;
1307 }
1352 }
1308 }
1353 }
1309 QHexEdit::childEvent(arg__1);
1354 QHexEdit::childEvent(arg__1);
1310 }
1355 }
1311 void PythonQtShell_QHexEdit::closeEvent(QCloseEvent* arg__1)
1356 void PythonQtShell_QHexEdit::closeEvent(QCloseEvent* arg__1)
1312 {
1357 {
1313 if (_wrapper) {
1358 if (_wrapper) {
1314 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
1359 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
1315 PyErr_Clear();
1360 PyErr_Clear();
1316 if (obj && !PythonQtSlotFunction_Check(obj)) {
1361 if (obj && !PythonQtSlotFunction_Check(obj)) {
1317 static const char* argumentList[] ={"" , "QCloseEvent*"};
1362 static const char* argumentList[] ={"" , "QCloseEvent*"};
1318 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1363 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1319 void* args[2] = {NULL, (void*)&arg__1};
1364 void* args[2] = {NULL, (void*)&arg__1};
1320 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1365 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1321 if (result) { Py_DECREF(result); }
1366 if (result) { Py_DECREF(result); }
1322 Py_DECREF(obj);
1367 Py_DECREF(obj);
1323 return;
1368 return;
1324 }
1369 }
1325 }
1370 }
1326 QHexEdit::closeEvent(arg__1);
1371 QHexEdit::closeEvent(arg__1);
1327 }
1372 }
1328 void PythonQtShell_QHexEdit::contextMenuEvent(QContextMenuEvent* arg__1)
1373 void PythonQtShell_QHexEdit::contextMenuEvent(QContextMenuEvent* arg__1)
1329 {
1374 {
1330 if (_wrapper) {
1375 if (_wrapper) {
1331 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
1376 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
1332 PyErr_Clear();
1377 PyErr_Clear();
1333 if (obj && !PythonQtSlotFunction_Check(obj)) {
1378 if (obj && !PythonQtSlotFunction_Check(obj)) {
1334 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
1379 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
1335 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1380 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1336 void* args[2] = {NULL, (void*)&arg__1};
1381 void* args[2] = {NULL, (void*)&arg__1};
1337 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1382 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1338 if (result) { Py_DECREF(result); }
1383 if (result) { Py_DECREF(result); }
1339 Py_DECREF(obj);
1384 Py_DECREF(obj);
1340 return;
1385 return;
1341 }
1386 }
1342 }
1387 }
1343 QHexEdit::contextMenuEvent(arg__1);
1388 QHexEdit::contextMenuEvent(arg__1);
1344 }
1389 }
1345 void PythonQtShell_QHexEdit::customEvent(QEvent* arg__1)
1390 void PythonQtShell_QHexEdit::customEvent(QEvent* arg__1)
1346 {
1391 {
1347 if (_wrapper) {
1392 if (_wrapper) {
1348 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
1393 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
1349 PyErr_Clear();
1394 PyErr_Clear();
1350 if (obj && !PythonQtSlotFunction_Check(obj)) {
1395 if (obj && !PythonQtSlotFunction_Check(obj)) {
1351 static const char* argumentList[] ={"" , "QEvent*"};
1396 static const char* argumentList[] ={"" , "QEvent*"};
1352 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1397 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1353 void* args[2] = {NULL, (void*)&arg__1};
1398 void* args[2] = {NULL, (void*)&arg__1};
1354 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1399 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1355 if (result) { Py_DECREF(result); }
1400 if (result) { Py_DECREF(result); }
1356 Py_DECREF(obj);
1401 Py_DECREF(obj);
1357 return;
1402 return;
1358 }
1403 }
1359 }
1404 }
1360 QHexEdit::customEvent(arg__1);
1405 QHexEdit::customEvent(arg__1);
1361 }
1406 }
1362 int PythonQtShell_QHexEdit::devType() const
1407 int PythonQtShell_QHexEdit::devType() const
1363 {
1408 {
1364 if (_wrapper) {
1409 if (_wrapper) {
1365 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
1410 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
1366 PyErr_Clear();
1411 PyErr_Clear();
1367 if (obj && !PythonQtSlotFunction_Check(obj)) {
1412 if (obj && !PythonQtSlotFunction_Check(obj)) {
1368 static const char* argumentList[] ={"int"};
1413 static const char* argumentList[] ={"int"};
1369 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1414 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1370 int returnValue;
1415 int returnValue;
1371 void* args[1] = {NULL};
1416 void* args[1] = {NULL};
1372 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1417 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1373 if (result) {
1418 if (result) {
1374 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1419 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1375 if (args[0]!=&returnValue) {
1420 if (args[0]!=&returnValue) {
1376 if (args[0]==NULL) {
1421 if (args[0]==NULL) {
1377 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
1422 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
1378 } else {
1423 } else {
1379 returnValue = *((int*)args[0]);
1424 returnValue = *((int*)args[0]);
1380 }
1425 }
1381 }
1426 }
1382 }
1427 }
1383 if (result) { Py_DECREF(result); }
1428 if (result) { Py_DECREF(result); }
1384 Py_DECREF(obj);
1429 Py_DECREF(obj);
1385 return returnValue;
1430 return returnValue;
1386 }
1431 }
1387 }
1432 }
1388 return QHexEdit::devType();
1433 return QHexEdit::devType();
1389 }
1434 }
1390 void PythonQtShell_QHexEdit::dragEnterEvent(QDragEnterEvent* arg__1)
1435 void PythonQtShell_QHexEdit::dragEnterEvent(QDragEnterEvent* arg__1)
1391 {
1436 {
1392 if (_wrapper) {
1437 if (_wrapper) {
1393 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
1438 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
1394 PyErr_Clear();
1439 PyErr_Clear();
1395 if (obj && !PythonQtSlotFunction_Check(obj)) {
1440 if (obj && !PythonQtSlotFunction_Check(obj)) {
1396 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
1441 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
1397 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1442 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1398 void* args[2] = {NULL, (void*)&arg__1};
1443 void* args[2] = {NULL, (void*)&arg__1};
1399 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1444 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1400 if (result) { Py_DECREF(result); }
1445 if (result) { Py_DECREF(result); }
1401 Py_DECREF(obj);
1446 Py_DECREF(obj);
1402 return;
1447 return;
1403 }
1448 }
1404 }
1449 }
1405 QHexEdit::dragEnterEvent(arg__1);
1450 QHexEdit::dragEnterEvent(arg__1);
1406 }
1451 }
1407 void PythonQtShell_QHexEdit::dragLeaveEvent(QDragLeaveEvent* arg__1)
1452 void PythonQtShell_QHexEdit::dragLeaveEvent(QDragLeaveEvent* arg__1)
1408 {
1453 {
1409 if (_wrapper) {
1454 if (_wrapper) {
1410 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
1455 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
1411 PyErr_Clear();
1456 PyErr_Clear();
1412 if (obj && !PythonQtSlotFunction_Check(obj)) {
1457 if (obj && !PythonQtSlotFunction_Check(obj)) {
1413 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
1458 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
1414 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1459 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1415 void* args[2] = {NULL, (void*)&arg__1};
1460 void* args[2] = {NULL, (void*)&arg__1};
1416 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1461 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1417 if (result) { Py_DECREF(result); }
1462 if (result) { Py_DECREF(result); }
1418 Py_DECREF(obj);
1463 Py_DECREF(obj);
1419 return;
1464 return;
1420 }
1465 }
1421 }
1466 }
1422 QHexEdit::dragLeaveEvent(arg__1);
1467 QHexEdit::dragLeaveEvent(arg__1);
1423 }
1468 }
1424 void PythonQtShell_QHexEdit::dragMoveEvent(QDragMoveEvent* arg__1)
1469 void PythonQtShell_QHexEdit::dragMoveEvent(QDragMoveEvent* arg__1)
1425 {
1470 {
1426 if (_wrapper) {
1471 if (_wrapper) {
1427 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
1472 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
1428 PyErr_Clear();
1473 PyErr_Clear();
1429 if (obj && !PythonQtSlotFunction_Check(obj)) {
1474 if (obj && !PythonQtSlotFunction_Check(obj)) {
1430 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
1475 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
1431 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1476 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1432 void* args[2] = {NULL, (void*)&arg__1};
1477 void* args[2] = {NULL, (void*)&arg__1};
1433 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1478 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1434 if (result) { Py_DECREF(result); }
1479 if (result) { Py_DECREF(result); }
1435 Py_DECREF(obj);
1480 Py_DECREF(obj);
1436 return;
1481 return;
1437 }
1482 }
1438 }
1483 }
1439 QHexEdit::dragMoveEvent(arg__1);
1484 QHexEdit::dragMoveEvent(arg__1);
1440 }
1485 }
1441 void PythonQtShell_QHexEdit::dropEvent(QDropEvent* arg__1)
1486 void PythonQtShell_QHexEdit::dropEvent(QDropEvent* arg__1)
1442 {
1487 {
1443 if (_wrapper) {
1488 if (_wrapper) {
1444 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
1489 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
1445 PyErr_Clear();
1490 PyErr_Clear();
1446 if (obj && !PythonQtSlotFunction_Check(obj)) {
1491 if (obj && !PythonQtSlotFunction_Check(obj)) {
1447 static const char* argumentList[] ={"" , "QDropEvent*"};
1492 static const char* argumentList[] ={"" , "QDropEvent*"};
1448 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1493 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1449 void* args[2] = {NULL, (void*)&arg__1};
1494 void* args[2] = {NULL, (void*)&arg__1};
1450 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1495 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1451 if (result) { Py_DECREF(result); }
1496 if (result) { Py_DECREF(result); }
1452 Py_DECREF(obj);
1497 Py_DECREF(obj);
1453 return;
1498 return;
1454 }
1499 }
1455 }
1500 }
1456 QHexEdit::dropEvent(arg__1);
1501 QHexEdit::dropEvent(arg__1);
1457 }
1502 }
1458 void PythonQtShell_QHexEdit::enterEvent(QEvent* arg__1)
1503 void PythonQtShell_QHexEdit::enterEvent(QEvent* arg__1)
1459 {
1504 {
1460 if (_wrapper) {
1505 if (_wrapper) {
1461 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
1506 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
1462 PyErr_Clear();
1507 PyErr_Clear();
1463 if (obj && !PythonQtSlotFunction_Check(obj)) {
1508 if (obj && !PythonQtSlotFunction_Check(obj)) {
1464 static const char* argumentList[] ={"" , "QEvent*"};
1509 static const char* argumentList[] ={"" , "QEvent*"};
1465 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1510 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1466 void* args[2] = {NULL, (void*)&arg__1};
1511 void* args[2] = {NULL, (void*)&arg__1};
1467 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1512 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1468 if (result) { Py_DECREF(result); }
1513 if (result) { Py_DECREF(result); }
1469 Py_DECREF(obj);
1514 Py_DECREF(obj);
1470 return;
1515 return;
1471 }
1516 }
1472 }
1517 }
1473 QHexEdit::enterEvent(arg__1);
1518 QHexEdit::enterEvent(arg__1);
1474 }
1519 }
1475 bool PythonQtShell_QHexEdit::event(QEvent* arg__1)
1520 bool PythonQtShell_QHexEdit::event(QEvent* arg__1)
1476 {
1521 {
1477 if (_wrapper) {
1522 if (_wrapper) {
1478 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
1523 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
1479 PyErr_Clear();
1524 PyErr_Clear();
1480 if (obj && !PythonQtSlotFunction_Check(obj)) {
1525 if (obj && !PythonQtSlotFunction_Check(obj)) {
1481 static const char* argumentList[] ={"bool" , "QEvent*"};
1526 static const char* argumentList[] ={"bool" , "QEvent*"};
1482 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1527 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1483 bool returnValue;
1528 bool returnValue;
1484 void* args[2] = {NULL, (void*)&arg__1};
1529 void* args[2] = {NULL, (void*)&arg__1};
1485 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1530 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1486 if (result) {
1531 if (result) {
1487 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1532 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1488 if (args[0]!=&returnValue) {
1533 if (args[0]!=&returnValue) {
1489 if (args[0]==NULL) {
1534 if (args[0]==NULL) {
1490 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
1535 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
1491 } else {
1536 } else {
1492 returnValue = *((bool*)args[0]);
1537 returnValue = *((bool*)args[0]);
1493 }
1538 }
1494 }
1539 }
1495 }
1540 }
1496 if (result) { Py_DECREF(result); }
1541 if (result) { Py_DECREF(result); }
1497 Py_DECREF(obj);
1542 Py_DECREF(obj);
1498 return returnValue;
1543 return returnValue;
1499 }
1544 }
1500 }
1545 }
1501 return QHexEdit::event(arg__1);
1546 return QHexEdit::event(arg__1);
1502 }
1547 }
1503 bool PythonQtShell_QHexEdit::eventFilter(QObject* arg__1, QEvent* arg__2)
1548 bool PythonQtShell_QHexEdit::eventFilter(QObject* arg__1, QEvent* arg__2)
1504 {
1549 {
1505 if (_wrapper) {
1550 if (_wrapper) {
1506 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
1551 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
1507 PyErr_Clear();
1552 PyErr_Clear();
1508 if (obj && !PythonQtSlotFunction_Check(obj)) {
1553 if (obj && !PythonQtSlotFunction_Check(obj)) {
1509 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
1554 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
1510 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
1555 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
1511 bool returnValue;
1556 bool returnValue;
1512 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
1557 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
1513 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1558 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1514 if (result) {
1559 if (result) {
1515 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1560 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1516 if (args[0]!=&returnValue) {
1561 if (args[0]!=&returnValue) {
1517 if (args[0]==NULL) {
1562 if (args[0]==NULL) {
1518 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
1563 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
1519 } else {
1564 } else {
1520 returnValue = *((bool*)args[0]);
1565 returnValue = *((bool*)args[0]);
1521 }
1566 }
1522 }
1567 }
1523 }
1568 }
1524 if (result) { Py_DECREF(result); }
1569 if (result) { Py_DECREF(result); }
1525 Py_DECREF(obj);
1570 Py_DECREF(obj);
1526 return returnValue;
1571 return returnValue;
1527 }
1572 }
1528 }
1573 }
1529 return QHexEdit::eventFilter(arg__1, arg__2);
1574 return QHexEdit::eventFilter(arg__1, arg__2);
1530 }
1575 }
1531 void PythonQtShell_QHexEdit::focusInEvent(QFocusEvent* arg__1)
1576 void PythonQtShell_QHexEdit::focusInEvent(QFocusEvent* arg__1)
1532 {
1577 {
1533 if (_wrapper) {
1578 if (_wrapper) {
1534 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
1579 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
1535 PyErr_Clear();
1580 PyErr_Clear();
1536 if (obj && !PythonQtSlotFunction_Check(obj)) {
1581 if (obj && !PythonQtSlotFunction_Check(obj)) {
1537 static const char* argumentList[] ={"" , "QFocusEvent*"};
1582 static const char* argumentList[] ={"" , "QFocusEvent*"};
1538 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1583 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1539 void* args[2] = {NULL, (void*)&arg__1};
1584 void* args[2] = {NULL, (void*)&arg__1};
1540 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1585 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1541 if (result) { Py_DECREF(result); }
1586 if (result) { Py_DECREF(result); }
1542 Py_DECREF(obj);
1587 Py_DECREF(obj);
1543 return;
1588 return;
1544 }
1589 }
1545 }
1590 }
1546 QHexEdit::focusInEvent(arg__1);
1591 QHexEdit::focusInEvent(arg__1);
1547 }
1592 }
1548 bool PythonQtShell_QHexEdit::focusNextPrevChild(bool next)
1593 bool PythonQtShell_QHexEdit::focusNextPrevChild(bool next)
1549 {
1594 {
1550 if (_wrapper) {
1595 if (_wrapper) {
1551 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
1596 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
1552 PyErr_Clear();
1597 PyErr_Clear();
1553 if (obj && !PythonQtSlotFunction_Check(obj)) {
1598 if (obj && !PythonQtSlotFunction_Check(obj)) {
1554 static const char* argumentList[] ={"bool" , "bool"};
1599 static const char* argumentList[] ={"bool" , "bool"};
1555 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1600 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1556 bool returnValue;
1601 bool returnValue;
1557 void* args[2] = {NULL, (void*)&next};
1602 void* args[2] = {NULL, (void*)&next};
1558 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1603 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1559 if (result) {
1604 if (result) {
1560 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1605 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1561 if (args[0]!=&returnValue) {
1606 if (args[0]!=&returnValue) {
1562 if (args[0]==NULL) {
1607 if (args[0]==NULL) {
1563 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
1608 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
1564 } else {
1609 } else {
1565 returnValue = *((bool*)args[0]);
1610 returnValue = *((bool*)args[0]);
1566 }
1611 }
1567 }
1612 }
1568 }
1613 }
1569 if (result) { Py_DECREF(result); }
1614 if (result) { Py_DECREF(result); }
1570 Py_DECREF(obj);
1615 Py_DECREF(obj);
1571 return returnValue;
1616 return returnValue;
1572 }
1617 }
1573 }
1618 }
1574 return QHexEdit::focusNextPrevChild(next);
1619 return QHexEdit::focusNextPrevChild(next);
1575 }
1620 }
1576 void PythonQtShell_QHexEdit::focusOutEvent(QFocusEvent* arg__1)
1621 void PythonQtShell_QHexEdit::focusOutEvent(QFocusEvent* arg__1)
1577 {
1622 {
1578 if (_wrapper) {
1623 if (_wrapper) {
1579 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
1624 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
1580 PyErr_Clear();
1625 PyErr_Clear();
1581 if (obj && !PythonQtSlotFunction_Check(obj)) {
1626 if (obj && !PythonQtSlotFunction_Check(obj)) {
1582 static const char* argumentList[] ={"" , "QFocusEvent*"};
1627 static const char* argumentList[] ={"" , "QFocusEvent*"};
1583 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1628 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1584 void* args[2] = {NULL, (void*)&arg__1};
1629 void* args[2] = {NULL, (void*)&arg__1};
1585 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1630 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1586 if (result) { Py_DECREF(result); }
1631 if (result) { Py_DECREF(result); }
1587 Py_DECREF(obj);
1632 Py_DECREF(obj);
1588 return;
1633 return;
1589 }
1634 }
1590 }
1635 }
1591 QHexEdit::focusOutEvent(arg__1);
1636 QHexEdit::focusOutEvent(arg__1);
1592 }
1637 }
1593 bool PythonQtShell_QHexEdit::hasHeightForWidth() const
1638 bool PythonQtShell_QHexEdit::hasHeightForWidth() const
1594 {
1639 {
1595 if (_wrapper) {
1640 if (_wrapper) {
1596 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
1641 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
1597 PyErr_Clear();
1642 PyErr_Clear();
1598 if (obj && !PythonQtSlotFunction_Check(obj)) {
1643 if (obj && !PythonQtSlotFunction_Check(obj)) {
1599 static const char* argumentList[] ={"bool"};
1644 static const char* argumentList[] ={"bool"};
1600 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1645 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1601 bool returnValue;
1646 bool returnValue;
1602 void* args[1] = {NULL};
1647 void* args[1] = {NULL};
1603 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1648 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1604 if (result) {
1649 if (result) {
1605 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1650 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1606 if (args[0]!=&returnValue) {
1651 if (args[0]!=&returnValue) {
1607 if (args[0]==NULL) {
1652 if (args[0]==NULL) {
1608 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
1653 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
1609 } else {
1654 } else {
1610 returnValue = *((bool*)args[0]);
1655 returnValue = *((bool*)args[0]);
1611 }
1656 }
1612 }
1657 }
1613 }
1658 }
1614 if (result) { Py_DECREF(result); }
1659 if (result) { Py_DECREF(result); }
1615 Py_DECREF(obj);
1660 Py_DECREF(obj);
1616 return returnValue;
1661 return returnValue;
1617 }
1662 }
1618 }
1663 }
1619 return QHexEdit::hasHeightForWidth();
1664 return QHexEdit::hasHeightForWidth();
1620 }
1665 }
1621 int PythonQtShell_QHexEdit::heightForWidth(int arg__1) const
1666 int PythonQtShell_QHexEdit::heightForWidth(int arg__1) const
1622 {
1667 {
1623 if (_wrapper) {
1668 if (_wrapper) {
1624 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
1669 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
1625 PyErr_Clear();
1670 PyErr_Clear();
1626 if (obj && !PythonQtSlotFunction_Check(obj)) {
1671 if (obj && !PythonQtSlotFunction_Check(obj)) {
1627 static const char* argumentList[] ={"int" , "int"};
1672 static const char* argumentList[] ={"int" , "int"};
1628 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1673 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1629 int returnValue;
1674 int returnValue;
1630 void* args[2] = {NULL, (void*)&arg__1};
1675 void* args[2] = {NULL, (void*)&arg__1};
1631 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1676 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1632 if (result) {
1677 if (result) {
1633 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1678 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1634 if (args[0]!=&returnValue) {
1679 if (args[0]!=&returnValue) {
1635 if (args[0]==NULL) {
1680 if (args[0]==NULL) {
1636 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
1681 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
1637 } else {
1682 } else {
1638 returnValue = *((int*)args[0]);
1683 returnValue = *((int*)args[0]);
1639 }
1684 }
1640 }
1685 }
1641 }
1686 }
1642 if (result) { Py_DECREF(result); }
1687 if (result) { Py_DECREF(result); }
1643 Py_DECREF(obj);
1688 Py_DECREF(obj);
1644 return returnValue;
1689 return returnValue;
1645 }
1690 }
1646 }
1691 }
1647 return QHexEdit::heightForWidth(arg__1);
1692 return QHexEdit::heightForWidth(arg__1);
1648 }
1693 }
1649 void PythonQtShell_QHexEdit::hideEvent(QHideEvent* arg__1)
1694 void PythonQtShell_QHexEdit::hideEvent(QHideEvent* arg__1)
1650 {
1695 {
1651 if (_wrapper) {
1696 if (_wrapper) {
1652 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
1697 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
1653 PyErr_Clear();
1698 PyErr_Clear();
1654 if (obj && !PythonQtSlotFunction_Check(obj)) {
1699 if (obj && !PythonQtSlotFunction_Check(obj)) {
1655 static const char* argumentList[] ={"" , "QHideEvent*"};
1700 static const char* argumentList[] ={"" , "QHideEvent*"};
1656 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1701 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1657 void* args[2] = {NULL, (void*)&arg__1};
1702 void* args[2] = {NULL, (void*)&arg__1};
1658 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1703 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1659 if (result) { Py_DECREF(result); }
1704 if (result) { Py_DECREF(result); }
1660 Py_DECREF(obj);
1705 Py_DECREF(obj);
1661 return;
1706 return;
1662 }
1707 }
1663 }
1708 }
1664 QHexEdit::hideEvent(arg__1);
1709 QHexEdit::hideEvent(arg__1);
1665 }
1710 }
1666 void PythonQtShell_QHexEdit::initPainter(QPainter* painter) const
1711 void PythonQtShell_QHexEdit::initPainter(QPainter* painter) const
1667 {
1712 {
1668 if (_wrapper) {
1713 if (_wrapper) {
1669 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
1714 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
1670 PyErr_Clear();
1715 PyErr_Clear();
1671 if (obj && !PythonQtSlotFunction_Check(obj)) {
1716 if (obj && !PythonQtSlotFunction_Check(obj)) {
1672 static const char* argumentList[] ={"" , "QPainter*"};
1717 static const char* argumentList[] ={"" , "QPainter*"};
1673 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1718 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1674 void* args[2] = {NULL, (void*)&painter};
1719 void* args[2] = {NULL, (void*)&painter};
1675 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1720 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1676 if (result) { Py_DECREF(result); }
1721 if (result) { Py_DECREF(result); }
1677 Py_DECREF(obj);
1722 Py_DECREF(obj);
1678 return;
1723 return;
1679 }
1724 }
1680 }
1725 }
1681 QHexEdit::initPainter(painter);
1726 QHexEdit::initPainter(painter);
1682 }
1727 }
1683 void PythonQtShell_QHexEdit::inputMethodEvent(QInputMethodEvent* arg__1)
1728 void PythonQtShell_QHexEdit::inputMethodEvent(QInputMethodEvent* arg__1)
1684 {
1729 {
1685 if (_wrapper) {
1730 if (_wrapper) {
1686 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
1731 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
1687 PyErr_Clear();
1732 PyErr_Clear();
1688 if (obj && !PythonQtSlotFunction_Check(obj)) {
1733 if (obj && !PythonQtSlotFunction_Check(obj)) {
1689 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
1734 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
1690 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1735 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1691 void* args[2] = {NULL, (void*)&arg__1};
1736 void* args[2] = {NULL, (void*)&arg__1};
1692 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1737 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1693 if (result) { Py_DECREF(result); }
1738 if (result) { Py_DECREF(result); }
1694 Py_DECREF(obj);
1739 Py_DECREF(obj);
1695 return;
1740 return;
1696 }
1741 }
1697 }
1742 }
1698 QHexEdit::inputMethodEvent(arg__1);
1743 QHexEdit::inputMethodEvent(arg__1);
1699 }
1744 }
1700 QVariant PythonQtShell_QHexEdit::inputMethodQuery(Qt::InputMethodQuery arg__1) const
1745 QVariant PythonQtShell_QHexEdit::inputMethodQuery(Qt::InputMethodQuery arg__1) const
1701 {
1746 {
1702 if (_wrapper) {
1747 if (_wrapper) {
1703 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
1748 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
1704 PyErr_Clear();
1749 PyErr_Clear();
1705 if (obj && !PythonQtSlotFunction_Check(obj)) {
1750 if (obj && !PythonQtSlotFunction_Check(obj)) {
1706 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
1751 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
1707 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1752 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1708 QVariant returnValue;
1753 QVariant returnValue;
1709 void* args[2] = {NULL, (void*)&arg__1};
1754 void* args[2] = {NULL, (void*)&arg__1};
1710 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1755 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1711 if (result) {
1756 if (result) {
1712 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1757 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1713 if (args[0]!=&returnValue) {
1758 if (args[0]!=&returnValue) {
1714 if (args[0]==NULL) {
1759 if (args[0]==NULL) {
1715 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
1760 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
1716 } else {
1761 } else {
1717 returnValue = *((QVariant*)args[0]);
1762 returnValue = *((QVariant*)args[0]);
1718 }
1763 }
1719 }
1764 }
1720 }
1765 }
1721 if (result) { Py_DECREF(result); }
1766 if (result) { Py_DECREF(result); }
1722 Py_DECREF(obj);
1767 Py_DECREF(obj);
1723 return returnValue;
1768 return returnValue;
1724 }
1769 }
1725 }
1770 }
1726 return QHexEdit::inputMethodQuery(arg__1);
1771 return QHexEdit::inputMethodQuery(arg__1);
1727 }
1772 }
1728 void PythonQtShell_QHexEdit::keyPressEvent(QKeyEvent* arg__1)
1773 void PythonQtShell_QHexEdit::keyPressEvent(QKeyEvent* arg__1)
1729 {
1774 {
1730 if (_wrapper) {
1775 if (_wrapper) {
1731 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
1776 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
1732 PyErr_Clear();
1777 PyErr_Clear();
1733 if (obj && !PythonQtSlotFunction_Check(obj)) {
1778 if (obj && !PythonQtSlotFunction_Check(obj)) {
1734 static const char* argumentList[] ={"" , "QKeyEvent*"};
1779 static const char* argumentList[] ={"" , "QKeyEvent*"};
1735 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1780 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1736 void* args[2] = {NULL, (void*)&arg__1};
1781 void* args[2] = {NULL, (void*)&arg__1};
1737 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1782 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1738 if (result) { Py_DECREF(result); }
1783 if (result) { Py_DECREF(result); }
1739 Py_DECREF(obj);
1784 Py_DECREF(obj);
1740 return;
1785 return;
1741 }
1786 }
1742 }
1787 }
1743 QHexEdit::keyPressEvent(arg__1);
1788 QHexEdit::keyPressEvent(arg__1);
1744 }
1789 }
1745 void PythonQtShell_QHexEdit::keyReleaseEvent(QKeyEvent* arg__1)
1790 void PythonQtShell_QHexEdit::keyReleaseEvent(QKeyEvent* arg__1)
1746 {
1791 {
1747 if (_wrapper) {
1792 if (_wrapper) {
1748 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
1793 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
1749 PyErr_Clear();
1794 PyErr_Clear();
1750 if (obj && !PythonQtSlotFunction_Check(obj)) {
1795 if (obj && !PythonQtSlotFunction_Check(obj)) {
1751 static const char* argumentList[] ={"" , "QKeyEvent*"};
1796 static const char* argumentList[] ={"" , "QKeyEvent*"};
1752 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1797 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1753 void* args[2] = {NULL, (void*)&arg__1};
1798 void* args[2] = {NULL, (void*)&arg__1};
1754 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1799 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1755 if (result) { Py_DECREF(result); }
1800 if (result) { Py_DECREF(result); }
1756 Py_DECREF(obj);
1801 Py_DECREF(obj);
1757 return;
1802 return;
1758 }
1803 }
1759 }
1804 }
1760 QHexEdit::keyReleaseEvent(arg__1);
1805 QHexEdit::keyReleaseEvent(arg__1);
1761 }
1806 }
1762 void PythonQtShell_QHexEdit::leaveEvent(QEvent* arg__1)
1807 void PythonQtShell_QHexEdit::leaveEvent(QEvent* arg__1)
1763 {
1808 {
1764 if (_wrapper) {
1809 if (_wrapper) {
1765 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
1810 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
1766 PyErr_Clear();
1811 PyErr_Clear();
1767 if (obj && !PythonQtSlotFunction_Check(obj)) {
1812 if (obj && !PythonQtSlotFunction_Check(obj)) {
1768 static const char* argumentList[] ={"" , "QEvent*"};
1813 static const char* argumentList[] ={"" , "QEvent*"};
1769 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1814 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1770 void* args[2] = {NULL, (void*)&arg__1};
1815 void* args[2] = {NULL, (void*)&arg__1};
1771 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1816 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1772 if (result) { Py_DECREF(result); }
1817 if (result) { Py_DECREF(result); }
1773 Py_DECREF(obj);
1818 Py_DECREF(obj);
1774 return;
1819 return;
1775 }
1820 }
1776 }
1821 }
1777 QHexEdit::leaveEvent(arg__1);
1822 QHexEdit::leaveEvent(arg__1);
1778 }
1823 }
1779 int PythonQtShell_QHexEdit::metric(QPaintDevice::PaintDeviceMetric arg__1) const
1824 int PythonQtShell_QHexEdit::metric(QPaintDevice::PaintDeviceMetric arg__1) const
1780 {
1825 {
1781 if (_wrapper) {
1826 if (_wrapper) {
1782 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
1827 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
1783 PyErr_Clear();
1828 PyErr_Clear();
1784 if (obj && !PythonQtSlotFunction_Check(obj)) {
1829 if (obj && !PythonQtSlotFunction_Check(obj)) {
1785 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
1830 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
1786 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1831 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1787 int returnValue;
1832 int returnValue;
1788 void* args[2] = {NULL, (void*)&arg__1};
1833 void* args[2] = {NULL, (void*)&arg__1};
1789 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1834 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1790 if (result) {
1835 if (result) {
1791 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1836 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1792 if (args[0]!=&returnValue) {
1837 if (args[0]!=&returnValue) {
1793 if (args[0]==NULL) {
1838 if (args[0]==NULL) {
1794 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
1839 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
1795 } else {
1840 } else {
1796 returnValue = *((int*)args[0]);
1841 returnValue = *((int*)args[0]);
1797 }
1842 }
1798 }
1843 }
1799 }
1844 }
1800 if (result) { Py_DECREF(result); }
1845 if (result) { Py_DECREF(result); }
1801 Py_DECREF(obj);
1846 Py_DECREF(obj);
1802 return returnValue;
1847 return returnValue;
1803 }
1848 }
1804 }
1849 }
1805 return QHexEdit::metric(arg__1);
1850 return QHexEdit::metric(arg__1);
1806 }
1851 }
1807 void PythonQtShell_QHexEdit::mouseDoubleClickEvent(QMouseEvent* arg__1)
1852 void PythonQtShell_QHexEdit::mouseDoubleClickEvent(QMouseEvent* arg__1)
1808 {
1853 {
1809 if (_wrapper) {
1854 if (_wrapper) {
1810 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
1855 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
1811 PyErr_Clear();
1856 PyErr_Clear();
1812 if (obj && !PythonQtSlotFunction_Check(obj)) {
1857 if (obj && !PythonQtSlotFunction_Check(obj)) {
1813 static const char* argumentList[] ={"" , "QMouseEvent*"};
1858 static const char* argumentList[] ={"" , "QMouseEvent*"};
1814 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1859 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1815 void* args[2] = {NULL, (void*)&arg__1};
1860 void* args[2] = {NULL, (void*)&arg__1};
1816 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1861 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1817 if (result) { Py_DECREF(result); }
1862 if (result) { Py_DECREF(result); }
1818 Py_DECREF(obj);
1863 Py_DECREF(obj);
1819 return;
1864 return;
1820 }
1865 }
1821 }
1866 }
1822 QHexEdit::mouseDoubleClickEvent(arg__1);
1867 QHexEdit::mouseDoubleClickEvent(arg__1);
1823 }
1868 }
1824 void PythonQtShell_QHexEdit::mouseMoveEvent(QMouseEvent* arg__1)
1869 void PythonQtShell_QHexEdit::mouseMoveEvent(QMouseEvent* arg__1)
1825 {
1870 {
1826 if (_wrapper) {
1871 if (_wrapper) {
1827 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
1872 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
1828 PyErr_Clear();
1873 PyErr_Clear();
1829 if (obj && !PythonQtSlotFunction_Check(obj)) {
1874 if (obj && !PythonQtSlotFunction_Check(obj)) {
1830 static const char* argumentList[] ={"" , "QMouseEvent*"};
1875 static const char* argumentList[] ={"" , "QMouseEvent*"};
1831 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1876 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1832 void* args[2] = {NULL, (void*)&arg__1};
1877 void* args[2] = {NULL, (void*)&arg__1};
1833 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1878 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1834 if (result) { Py_DECREF(result); }
1879 if (result) { Py_DECREF(result); }
1835 Py_DECREF(obj);
1880 Py_DECREF(obj);
1836 return;
1881 return;
1837 }
1882 }
1838 }
1883 }
1839 QHexEdit::mouseMoveEvent(arg__1);
1884 QHexEdit::mouseMoveEvent(arg__1);
1840 }
1885 }
1841 void PythonQtShell_QHexEdit::mousePressEvent(QMouseEvent* arg__1)
1886 void PythonQtShell_QHexEdit::mousePressEvent(QMouseEvent* arg__1)
1842 {
1887 {
1843 if (_wrapper) {
1888 if (_wrapper) {
1844 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
1889 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
1845 PyErr_Clear();
1890 PyErr_Clear();
1846 if (obj && !PythonQtSlotFunction_Check(obj)) {
1891 if (obj && !PythonQtSlotFunction_Check(obj)) {
1847 static const char* argumentList[] ={"" , "QMouseEvent*"};
1892 static const char* argumentList[] ={"" , "QMouseEvent*"};
1848 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1893 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1849 void* args[2] = {NULL, (void*)&arg__1};
1894 void* args[2] = {NULL, (void*)&arg__1};
1850 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1895 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1851 if (result) { Py_DECREF(result); }
1896 if (result) { Py_DECREF(result); }
1852 Py_DECREF(obj);
1897 Py_DECREF(obj);
1853 return;
1898 return;
1854 }
1899 }
1855 }
1900 }
1856 QHexEdit::mousePressEvent(arg__1);
1901 QHexEdit::mousePressEvent(arg__1);
1857 }
1902 }
1858 void PythonQtShell_QHexEdit::mouseReleaseEvent(QMouseEvent* arg__1)
1903 void PythonQtShell_QHexEdit::mouseReleaseEvent(QMouseEvent* arg__1)
1859 {
1904 {
1860 if (_wrapper) {
1905 if (_wrapper) {
1861 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
1906 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
1862 PyErr_Clear();
1907 PyErr_Clear();
1863 if (obj && !PythonQtSlotFunction_Check(obj)) {
1908 if (obj && !PythonQtSlotFunction_Check(obj)) {
1864 static const char* argumentList[] ={"" , "QMouseEvent*"};
1909 static const char* argumentList[] ={"" , "QMouseEvent*"};
1865 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1910 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1866 void* args[2] = {NULL, (void*)&arg__1};
1911 void* args[2] = {NULL, (void*)&arg__1};
1867 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1912 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1868 if (result) { Py_DECREF(result); }
1913 if (result) { Py_DECREF(result); }
1869 Py_DECREF(obj);
1914 Py_DECREF(obj);
1870 return;
1915 return;
1871 }
1916 }
1872 }
1917 }
1873 QHexEdit::mouseReleaseEvent(arg__1);
1918 QHexEdit::mouseReleaseEvent(arg__1);
1874 }
1919 }
1875 void PythonQtShell_QHexEdit::moveEvent(QMoveEvent* arg__1)
1920 void PythonQtShell_QHexEdit::moveEvent(QMoveEvent* arg__1)
1876 {
1921 {
1877 if (_wrapper) {
1922 if (_wrapper) {
1878 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
1923 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
1879 PyErr_Clear();
1924 PyErr_Clear();
1880 if (obj && !PythonQtSlotFunction_Check(obj)) {
1925 if (obj && !PythonQtSlotFunction_Check(obj)) {
1881 static const char* argumentList[] ={"" , "QMoveEvent*"};
1926 static const char* argumentList[] ={"" , "QMoveEvent*"};
1882 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1927 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1883 void* args[2] = {NULL, (void*)&arg__1};
1928 void* args[2] = {NULL, (void*)&arg__1};
1884 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1929 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1885 if (result) { Py_DECREF(result); }
1930 if (result) { Py_DECREF(result); }
1886 Py_DECREF(obj);
1931 Py_DECREF(obj);
1887 return;
1932 return;
1888 }
1933 }
1889 }
1934 }
1890 QHexEdit::moveEvent(arg__1);
1935 QHexEdit::moveEvent(arg__1);
1891 }
1936 }
1892 bool PythonQtShell_QHexEdit::nativeEvent(const QByteArray& eventType, void* message, long* result)
1937 bool PythonQtShell_QHexEdit::nativeEvent(const QByteArray& eventType, void* message, long* result)
1893 {
1938 {
1894 if (_wrapper) {
1939 if (_wrapper) {
1895 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
1940 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
1896 PyErr_Clear();
1941 PyErr_Clear();
1897 if (obj && !PythonQtSlotFunction_Check(obj)) {
1942 if (obj && !PythonQtSlotFunction_Check(obj)) {
1898 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
1943 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
1899 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
1944 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
1900 bool returnValue;
1945 bool returnValue;
1901 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
1946 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
1902 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1947 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1903 if (result) {
1948 if (result) {
1904 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1949 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1905 if (args[0]!=&returnValue) {
1950 if (args[0]!=&returnValue) {
1906 if (args[0]==NULL) {
1951 if (args[0]==NULL) {
1907 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
1952 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
1908 } else {
1953 } else {
1909 returnValue = *((bool*)args[0]);
1954 returnValue = *((bool*)args[0]);
1910 }
1955 }
1911 }
1956 }
1912 }
1957 }
1913 if (result) { Py_DECREF(result); }
1958 if (result) { Py_DECREF(result); }
1914 Py_DECREF(obj);
1959 Py_DECREF(obj);
1915 return returnValue;
1960 return returnValue;
1916 }
1961 }
1917 }
1962 }
1918 return QHexEdit::nativeEvent(eventType, message, result);
1963 return QHexEdit::nativeEvent(eventType, message, result);
1919 }
1964 }
1920 QPaintEngine* PythonQtShell_QHexEdit::paintEngine() const
1965 QPaintEngine* PythonQtShell_QHexEdit::paintEngine() const
1921 {
1966 {
1922 if (_wrapper) {
1967 if (_wrapper) {
1923 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
1968 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
1924 PyErr_Clear();
1969 PyErr_Clear();
1925 if (obj && !PythonQtSlotFunction_Check(obj)) {
1970 if (obj && !PythonQtSlotFunction_Check(obj)) {
1926 static const char* argumentList[] ={"QPaintEngine*"};
1971 static const char* argumentList[] ={"QPaintEngine*"};
1927 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1972 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1928 QPaintEngine* returnValue;
1973 QPaintEngine* returnValue;
1929 void* args[1] = {NULL};
1974 void* args[1] = {NULL};
1930 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1975 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1931 if (result) {
1976 if (result) {
1932 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1977 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1933 if (args[0]!=&returnValue) {
1978 if (args[0]!=&returnValue) {
1934 if (args[0]==NULL) {
1979 if (args[0]==NULL) {
1935 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
1980 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
1936 } else {
1981 } else {
1937 returnValue = *((QPaintEngine**)args[0]);
1982 returnValue = *((QPaintEngine**)args[0]);
1938 }
1983 }
1939 }
1984 }
1940 }
1985 }
1941 if (result) { Py_DECREF(result); }
1986 if (result) { Py_DECREF(result); }
1942 Py_DECREF(obj);
1987 Py_DECREF(obj);
1943 return returnValue;
1988 return returnValue;
1944 }
1989 }
1945 }
1990 }
1946 return QHexEdit::paintEngine();
1991 return QHexEdit::paintEngine();
1947 }
1992 }
1948 void PythonQtShell_QHexEdit::paintEvent(QPaintEvent* arg__1)
1993 void PythonQtShell_QHexEdit::paintEvent(QPaintEvent* arg__1)
1949 {
1994 {
1950 if (_wrapper) {
1995 if (_wrapper) {
1951 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
1996 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
1952 PyErr_Clear();
1997 PyErr_Clear();
1953 if (obj && !PythonQtSlotFunction_Check(obj)) {
1998 if (obj && !PythonQtSlotFunction_Check(obj)) {
1954 static const char* argumentList[] ={"" , "QPaintEvent*"};
1999 static const char* argumentList[] ={"" , "QPaintEvent*"};
1955 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2000 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1956 void* args[2] = {NULL, (void*)&arg__1};
2001 void* args[2] = {NULL, (void*)&arg__1};
1957 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2002 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1958 if (result) { Py_DECREF(result); }
2003 if (result) { Py_DECREF(result); }
1959 Py_DECREF(obj);
2004 Py_DECREF(obj);
1960 return;
2005 return;
1961 }
2006 }
1962 }
2007 }
1963 QHexEdit::paintEvent(arg__1);
2008 QHexEdit::paintEvent(arg__1);
1964 }
2009 }
1965 QPaintDevice* PythonQtShell_QHexEdit::redirected(QPoint* offset) const
2010 QPaintDevice* PythonQtShell_QHexEdit::redirected(QPoint* offset) const
1966 {
2011 {
1967 if (_wrapper) {
2012 if (_wrapper) {
1968 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
2013 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
1969 PyErr_Clear();
2014 PyErr_Clear();
1970 if (obj && !PythonQtSlotFunction_Check(obj)) {
2015 if (obj && !PythonQtSlotFunction_Check(obj)) {
1971 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
2016 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
1972 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2017 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1973 QPaintDevice* returnValue;
2018 QPaintDevice* returnValue;
1974 void* args[2] = {NULL, (void*)&offset};
2019 void* args[2] = {NULL, (void*)&offset};
1975 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2020 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1976 if (result) {
2021 if (result) {
1977 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2022 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1978 if (args[0]!=&returnValue) {
2023 if (args[0]!=&returnValue) {
1979 if (args[0]==NULL) {
2024 if (args[0]==NULL) {
1980 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
2025 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
1981 } else {
2026 } else {
1982 returnValue = *((QPaintDevice**)args[0]);
2027 returnValue = *((QPaintDevice**)args[0]);
1983 }
2028 }
1984 }
2029 }
1985 }
2030 }
1986 if (result) { Py_DECREF(result); }
2031 if (result) { Py_DECREF(result); }
1987 Py_DECREF(obj);
2032 Py_DECREF(obj);
1988 return returnValue;
2033 return returnValue;
1989 }
2034 }
1990 }
2035 }
1991 return QHexEdit::redirected(offset);
2036 return QHexEdit::redirected(offset);
1992 }
2037 }
1993 void PythonQtShell_QHexEdit::resizeEvent(QResizeEvent* arg__1)
2038 void PythonQtShell_QHexEdit::resizeEvent(QResizeEvent* arg__1)
1994 {
2039 {
1995 if (_wrapper) {
2040 if (_wrapper) {
1996 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
2041 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
1997 PyErr_Clear();
2042 PyErr_Clear();
1998 if (obj && !PythonQtSlotFunction_Check(obj)) {
2043 if (obj && !PythonQtSlotFunction_Check(obj)) {
1999 static const char* argumentList[] ={"" , "QResizeEvent*"};
2044 static const char* argumentList[] ={"" , "QResizeEvent*"};
2000 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2045 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2001 void* args[2] = {NULL, (void*)&arg__1};
2046 void* args[2] = {NULL, (void*)&arg__1};
2002 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2047 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2003 if (result) { Py_DECREF(result); }
2048 if (result) { Py_DECREF(result); }
2004 Py_DECREF(obj);
2049 Py_DECREF(obj);
2005 return;
2050 return;
2006 }
2051 }
2007 }
2052 }
2008 QHexEdit::resizeEvent(arg__1);
2053 QHexEdit::resizeEvent(arg__1);
2009 }
2054 }
2010 void PythonQtShell_QHexEdit::scrollContentsBy(int dx, int dy)
2055 void PythonQtShell_QHexEdit::scrollContentsBy(int dx, int dy)
2011 {
2056 {
2012 if (_wrapper) {
2057 if (_wrapper) {
2013 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "scrollContentsBy");
2058 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "scrollContentsBy");
2014 PyErr_Clear();
2059 PyErr_Clear();
2015 if (obj && !PythonQtSlotFunction_Check(obj)) {
2060 if (obj && !PythonQtSlotFunction_Check(obj)) {
2016 static const char* argumentList[] ={"" , "int" , "int"};
2061 static const char* argumentList[] ={"" , "int" , "int"};
2017 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2062 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2018 void* args[3] = {NULL, (void*)&dx, (void*)&dy};
2063 void* args[3] = {NULL, (void*)&dx, (void*)&dy};
2019 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2064 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2020 if (result) { Py_DECREF(result); }
2065 if (result) { Py_DECREF(result); }
2021 Py_DECREF(obj);
2066 Py_DECREF(obj);
2022 return;
2067 return;
2023 }
2068 }
2024 }
2069 }
2025 QHexEdit::scrollContentsBy(dx, dy);
2070 QHexEdit::scrollContentsBy(dx, dy);
2026 }
2071 }
2027 void PythonQtShell_QHexEdit::setupViewport(QWidget* viewport)
2072 void PythonQtShell_QHexEdit::setupViewport(QWidget* viewport)
2028 {
2073 {
2029 if (_wrapper) {
2074 if (_wrapper) {
2030 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setupViewport");
2075 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setupViewport");
2031 PyErr_Clear();
2076 PyErr_Clear();
2032 if (obj && !PythonQtSlotFunction_Check(obj)) {
2077 if (obj && !PythonQtSlotFunction_Check(obj)) {
2033 static const char* argumentList[] ={"" , "QWidget*"};
2078 static const char* argumentList[] ={"" , "QWidget*"};
2034 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2079 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2035 void* args[2] = {NULL, (void*)&viewport};
2080 void* args[2] = {NULL, (void*)&viewport};
2036 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2081 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2037 if (result) { Py_DECREF(result); }
2082 if (result) { Py_DECREF(result); }
2038 Py_DECREF(obj);
2083 Py_DECREF(obj);
2039 return;
2084 return;
2040 }
2085 }
2041 }
2086 }
2042 QHexEdit::setupViewport(viewport);
2087 QHexEdit::setupViewport(viewport);
2043 }
2088 }
2044 QPainter* PythonQtShell_QHexEdit::sharedPainter() const
2089 QPainter* PythonQtShell_QHexEdit::sharedPainter() const
2045 {
2090 {
2046 if (_wrapper) {
2091 if (_wrapper) {
2047 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
2092 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
2048 PyErr_Clear();
2093 PyErr_Clear();
2049 if (obj && !PythonQtSlotFunction_Check(obj)) {
2094 if (obj && !PythonQtSlotFunction_Check(obj)) {
2050 static const char* argumentList[] ={"QPainter*"};
2095 static const char* argumentList[] ={"QPainter*"};
2051 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2096 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2052 QPainter* returnValue;
2097 QPainter* returnValue;
2053 void* args[1] = {NULL};
2098 void* args[1] = {NULL};
2054 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2099 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2055 if (result) {
2100 if (result) {
2056 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2101 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2057 if (args[0]!=&returnValue) {
2102 if (args[0]!=&returnValue) {
2058 if (args[0]==NULL) {
2103 if (args[0]==NULL) {
2059 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
2104 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
2060 } else {
2105 } else {
2061 returnValue = *((QPainter**)args[0]);
2106 returnValue = *((QPainter**)args[0]);
2062 }
2107 }
2063 }
2108 }
2064 }
2109 }
2065 if (result) { Py_DECREF(result); }
2110 if (result) { Py_DECREF(result); }
2066 Py_DECREF(obj);
2111 Py_DECREF(obj);
2067 return returnValue;
2112 return returnValue;
2068 }
2113 }
2069 }
2114 }
2070 return QHexEdit::sharedPainter();
2115 return QHexEdit::sharedPainter();
2071 }
2116 }
2072 void PythonQtShell_QHexEdit::showEvent(QShowEvent* arg__1)
2117 void PythonQtShell_QHexEdit::showEvent(QShowEvent* arg__1)
2073 {
2118 {
2074 if (_wrapper) {
2119 if (_wrapper) {
2075 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
2120 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
2076 PyErr_Clear();
2121 PyErr_Clear();
2077 if (obj && !PythonQtSlotFunction_Check(obj)) {
2122 if (obj && !PythonQtSlotFunction_Check(obj)) {
2078 static const char* argumentList[] ={"" , "QShowEvent*"};
2123 static const char* argumentList[] ={"" , "QShowEvent*"};
2079 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2124 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2080 void* args[2] = {NULL, (void*)&arg__1};
2125 void* args[2] = {NULL, (void*)&arg__1};
2081 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2126 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2082 if (result) { Py_DECREF(result); }
2127 if (result) { Py_DECREF(result); }
2083 Py_DECREF(obj);
2128 Py_DECREF(obj);
2084 return;
2129 return;
2085 }
2130 }
2086 }
2131 }
2087 QHexEdit::showEvent(arg__1);
2132 QHexEdit::showEvent(arg__1);
2088 }
2133 }
2089 void PythonQtShell_QHexEdit::tabletEvent(QTabletEvent* arg__1)
2134 void PythonQtShell_QHexEdit::tabletEvent(QTabletEvent* arg__1)
2090 {
2135 {
2091 if (_wrapper) {
2136 if (_wrapper) {
2092 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
2137 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
2093 PyErr_Clear();
2138 PyErr_Clear();
2094 if (obj && !PythonQtSlotFunction_Check(obj)) {
2139 if (obj && !PythonQtSlotFunction_Check(obj)) {
2095 static const char* argumentList[] ={"" , "QTabletEvent*"};
2140 static const char* argumentList[] ={"" , "QTabletEvent*"};
2096 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2141 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2097 void* args[2] = {NULL, (void*)&arg__1};
2142 void* args[2] = {NULL, (void*)&arg__1};
2098 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2143 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2099 if (result) { Py_DECREF(result); }
2144 if (result) { Py_DECREF(result); }
2100 Py_DECREF(obj);
2145 Py_DECREF(obj);
2101 return;
2146 return;
2102 }
2147 }
2103 }
2148 }
2104 QHexEdit::tabletEvent(arg__1);
2149 QHexEdit::tabletEvent(arg__1);
2105 }
2150 }
2106 void PythonQtShell_QHexEdit::timerEvent(QTimerEvent* arg__1)
2151 void PythonQtShell_QHexEdit::timerEvent(QTimerEvent* arg__1)
2107 {
2152 {
2108 if (_wrapper) {
2153 if (_wrapper) {
2109 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
2154 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
2110 PyErr_Clear();
2155 PyErr_Clear();
2111 if (obj && !PythonQtSlotFunction_Check(obj)) {
2156 if (obj && !PythonQtSlotFunction_Check(obj)) {
2112 static const char* argumentList[] ={"" , "QTimerEvent*"};
2157 static const char* argumentList[] ={"" , "QTimerEvent*"};
2113 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2158 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2114 void* args[2] = {NULL, (void*)&arg__1};
2159 void* args[2] = {NULL, (void*)&arg__1};
2115 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2160 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2116 if (result) { Py_DECREF(result); }
2161 if (result) { Py_DECREF(result); }
2117 Py_DECREF(obj);
2162 Py_DECREF(obj);
2118 return;
2163 return;
2119 }
2164 }
2120 }
2165 }
2121 QHexEdit::timerEvent(arg__1);
2166 QHexEdit::timerEvent(arg__1);
2122 }
2167 }
2123 bool PythonQtShell_QHexEdit::viewportEvent(QEvent* arg__1)
2168 bool PythonQtShell_QHexEdit::viewportEvent(QEvent* arg__1)
2124 {
2169 {
2125 if (_wrapper) {
2170 if (_wrapper) {
2126 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportEvent");
2171 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportEvent");
2127 PyErr_Clear();
2172 PyErr_Clear();
2128 if (obj && !PythonQtSlotFunction_Check(obj)) {
2173 if (obj && !PythonQtSlotFunction_Check(obj)) {
2129 static const char* argumentList[] ={"bool" , "QEvent*"};
2174 static const char* argumentList[] ={"bool" , "QEvent*"};
2130 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2175 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2131 bool returnValue;
2176 bool returnValue;
2132 void* args[2] = {NULL, (void*)&arg__1};
2177 void* args[2] = {NULL, (void*)&arg__1};
2133 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2178 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2134 if (result) {
2179 if (result) {
2135 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2180 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2136 if (args[0]!=&returnValue) {
2181 if (args[0]!=&returnValue) {
2137 if (args[0]==NULL) {
2182 if (args[0]==NULL) {
2138 PythonQt::priv()->handleVirtualOverloadReturnError("viewportEvent", methodInfo, result);
2183 PythonQt::priv()->handleVirtualOverloadReturnError("viewportEvent", methodInfo, result);
2139 } else {
2184 } else {
2140 returnValue = *((bool*)args[0]);
2185 returnValue = *((bool*)args[0]);
2141 }
2186 }
2142 }
2187 }
2143 }
2188 }
2144 if (result) { Py_DECREF(result); }
2189 if (result) { Py_DECREF(result); }
2145 Py_DECREF(obj);
2190 Py_DECREF(obj);
2146 return returnValue;
2191 return returnValue;
2147 }
2192 }
2148 }
2193 }
2149 return QHexEdit::viewportEvent(arg__1);
2194 return QHexEdit::viewportEvent(arg__1);
2150 }
2195 }
2151 QSize PythonQtShell_QHexEdit::viewportSizeHint() const
2196 QSize PythonQtShell_QHexEdit::viewportSizeHint() const
2152 {
2197 {
2153 if (_wrapper) {
2198 if (_wrapper) {
2154 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportSizeHint");
2199 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportSizeHint");
2155 PyErr_Clear();
2200 PyErr_Clear();
2156 if (obj && !PythonQtSlotFunction_Check(obj)) {
2201 if (obj && !PythonQtSlotFunction_Check(obj)) {
2157 static const char* argumentList[] ={"QSize"};
2202 static const char* argumentList[] ={"QSize"};
2158 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2203 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2159 QSize returnValue;
2204 QSize returnValue;
2160 void* args[1] = {NULL};
2205 void* args[1] = {NULL};
2161 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2206 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2162 if (result) {
2207 if (result) {
2163 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2208 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2164 if (args[0]!=&returnValue) {
2209 if (args[0]!=&returnValue) {
2165 if (args[0]==NULL) {
2210 if (args[0]==NULL) {
2166 PythonQt::priv()->handleVirtualOverloadReturnError("viewportSizeHint", methodInfo, result);
2211 PythonQt::priv()->handleVirtualOverloadReturnError("viewportSizeHint", methodInfo, result);
2167 } else {
2212 } else {
2168 returnValue = *((QSize*)args[0]);
2213 returnValue = *((QSize*)args[0]);
2169 }
2214 }
2170 }
2215 }
2171 }
2216 }
2172 if (result) { Py_DECREF(result); }
2217 if (result) { Py_DECREF(result); }
2173 Py_DECREF(obj);
2218 Py_DECREF(obj);
2174 return returnValue;
2219 return returnValue;
2175 }
2220 }
2176 }
2221 }
2177 return QHexEdit::viewportSizeHint();
2222 return QHexEdit::viewportSizeHint();
2178 }
2223 }
2179 void PythonQtShell_QHexEdit::wheelEvent(QWheelEvent* arg__1)
2224 void PythonQtShell_QHexEdit::wheelEvent(QWheelEvent* arg__1)
2180 {
2225 {
2181 if (_wrapper) {
2226 if (_wrapper) {
2182 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
2227 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
2183 PyErr_Clear();
2228 PyErr_Clear();
2184 if (obj && !PythonQtSlotFunction_Check(obj)) {
2229 if (obj && !PythonQtSlotFunction_Check(obj)) {
2185 static const char* argumentList[] ={"" , "QWheelEvent*"};
2230 static const char* argumentList[] ={"" , "QWheelEvent*"};
2186 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2231 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2187 void* args[2] = {NULL, (void*)&arg__1};
2232 void* args[2] = {NULL, (void*)&arg__1};
2188 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2233 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2189 if (result) { Py_DECREF(result); }
2234 if (result) { Py_DECREF(result); }
2190 Py_DECREF(obj);
2235 Py_DECREF(obj);
2191 return;
2236 return;
2192 }
2237 }
2193 }
2238 }
2194 QHexEdit::wheelEvent(arg__1);
2239 QHexEdit::wheelEvent(arg__1);
2195 }
2240 }
2196 QHexEdit* PythonQtWrapper_QHexEdit::new_QHexEdit(QWidget* parent)
2241 QHexEdit* PythonQtWrapper_QHexEdit::new_QHexEdit(QWidget* parent)
2197 {
2242 {
2198 return new PythonQtShell_QHexEdit(parent); }
2243 return new PythonQtShell_QHexEdit(parent); }
2199
2244
2200 QColor PythonQtWrapper_QHexEdit::addressAreaColor(QHexEdit* theWrappedObject)
2245 QColor PythonQtWrapper_QHexEdit::addressAreaColor(QHexEdit* theWrappedObject)
2201 {
2246 {
2202 return ( theWrappedObject->addressAreaColor());
2247 return ( theWrappedObject->addressAreaColor());
2203 }
2248 }
2204
2249
2205 int PythonQtWrapper_QHexEdit::addressOffset(QHexEdit* theWrappedObject)
2250 int PythonQtWrapper_QHexEdit::addressOffset(QHexEdit* theWrappedObject)
2206 {
2251 {
2207 return ( theWrappedObject->addressOffset());
2252 return ( theWrappedObject->addressOffset());
2208 }
2253 }
2209
2254
2210 int PythonQtWrapper_QHexEdit::cursorPosition(QHexEdit* theWrappedObject)
2255 int PythonQtWrapper_QHexEdit::cursorPosition(QHexEdit* theWrappedObject)
2211 {
2256 {
2212 return ( theWrappedObject->cursorPosition());
2257 return ( theWrappedObject->cursorPosition());
2213 }
2258 }
2214
2259
2215 QByteArray PythonQtWrapper_QHexEdit::data(QHexEdit* theWrappedObject)
2260 QByteArray PythonQtWrapper_QHexEdit::data(QHexEdit* theWrappedObject)
2216 {
2261 {
2217 return ( theWrappedObject->data());
2262 return ( theWrappedObject->data());
2218 }
2263 }
2219
2264
2220 const QFont* PythonQtWrapper_QHexEdit::font(QHexEdit* theWrappedObject) const
2265 const QFont* PythonQtWrapper_QHexEdit::font(QHexEdit* theWrappedObject) const
2221 {
2266 {
2222 return &( theWrappedObject->font());
2267 return &( theWrappedObject->font());
2223 }
2268 }
2224
2269
2225 QColor PythonQtWrapper_QHexEdit::highlightingColor(QHexEdit* theWrappedObject)
2270 QColor PythonQtWrapper_QHexEdit::highlightingColor(QHexEdit* theWrappedObject)
2226 {
2271 {
2227 return ( theWrappedObject->highlightingColor());
2272 return ( theWrappedObject->highlightingColor());
2228 }
2273 }
2229
2274
2230 int PythonQtWrapper_QHexEdit::indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2275 int PythonQtWrapper_QHexEdit::indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2231 {
2276 {
2232 return ( theWrappedObject->indexOf(ba, from));
2277 return ( theWrappedObject->indexOf(ba, from));
2233 }
2278 }
2234
2279
2235 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, char ch)
2280 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, char ch)
2236 {
2281 {
2237 ( theWrappedObject->insert(i, ch));
2282 ( theWrappedObject->insert(i, ch));
2238 }
2283 }
2239
2284
2240 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba)
2285 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba)
2241 {
2286 {
2242 ( theWrappedObject->insert(i, ba));
2287 ( theWrappedObject->insert(i, ba));
2243 }
2288 }
2244
2289
2245 bool PythonQtWrapper_QHexEdit::isReadOnly(QHexEdit* theWrappedObject)
2290 bool PythonQtWrapper_QHexEdit::isReadOnly(QHexEdit* theWrappedObject)
2246 {
2291 {
2247 return ( theWrappedObject->isReadOnly());
2292 return ( theWrappedObject->isReadOnly());
2248 }
2293 }
2249
2294
2250 int PythonQtWrapper_QHexEdit::lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2295 int PythonQtWrapper_QHexEdit::lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2251 {
2296 {
2252 return ( theWrappedObject->lastIndexOf(ba, from));
2297 return ( theWrappedObject->lastIndexOf(ba, from));
2253 }
2298 }
2254
2299
2255 bool PythonQtWrapper_QHexEdit::overwriteMode(QHexEdit* theWrappedObject)
2300 bool PythonQtWrapper_QHexEdit::overwriteMode(QHexEdit* theWrappedObject)
2256 {
2301 {
2257 return ( theWrappedObject->overwriteMode());
2302 return ( theWrappedObject->overwriteMode());
2258 }
2303 }
2259
2304
2260 void PythonQtWrapper_QHexEdit::remove(QHexEdit* theWrappedObject, int pos, int len)
2305 void PythonQtWrapper_QHexEdit::remove(QHexEdit* theWrappedObject, int pos, int len)
2261 {
2306 {
2262 ( theWrappedObject->remove(pos, len));
2307 ( theWrappedObject->remove(pos, len));
2263 }
2308 }
2264
2309
2265 void PythonQtWrapper_QHexEdit::replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after)
2310 void PythonQtWrapper_QHexEdit::replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after)
2266 {
2311 {
2267 ( theWrappedObject->replace(pos, len, after));
2312 ( theWrappedObject->replace(pos, len, after));
2268 }
2313 }
2269
2314
2270 QColor PythonQtWrapper_QHexEdit::selectionColor(QHexEdit* theWrappedObject)
2315 QColor PythonQtWrapper_QHexEdit::selectionColor(QHexEdit* theWrappedObject)
2271 {
2316 {
2272 return ( theWrappedObject->selectionColor());
2317 return ( theWrappedObject->selectionColor());
2273 }
2318 }
2274
2319
2275 QString PythonQtWrapper_QHexEdit::selectionToReadableString(QHexEdit* theWrappedObject)
2320 QString PythonQtWrapper_QHexEdit::selectionToReadableString(QHexEdit* theWrappedObject)
2276 {
2321 {
2277 return ( theWrappedObject->selectionToReadableString());
2322 return ( theWrappedObject->selectionToReadableString());
2278 }
2323 }
2279
2324
2280 void PythonQtWrapper_QHexEdit::setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color)
2325 void PythonQtWrapper_QHexEdit::setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color)
2281 {
2326 {
2282 ( theWrappedObject->setAddressAreaColor(color));
2327 ( theWrappedObject->setAddressAreaColor(color));
2283 }
2328 }
2284
2329
2285 void PythonQtWrapper_QHexEdit::setAddressOffset(QHexEdit* theWrappedObject, int offset)
2330 void PythonQtWrapper_QHexEdit::setAddressOffset(QHexEdit* theWrappedObject, int offset)
2286 {
2331 {
2287 ( theWrappedObject->setAddressOffset(offset));
2332 ( theWrappedObject->setAddressOffset(offset));
2288 }
2333 }
2289
2334
2290 void PythonQtWrapper_QHexEdit::setCursorPosition(QHexEdit* theWrappedObject, int cusorPos)
2335 void PythonQtWrapper_QHexEdit::setCursorPosition(QHexEdit* theWrappedObject, int cusorPos)
2291 {
2336 {
2292 ( theWrappedObject->setCursorPosition(cusorPos));
2337 ( theWrappedObject->setCursorPosition(cusorPos));
2293 }
2338 }
2294
2339
2295 void PythonQtWrapper_QHexEdit::setData(QHexEdit* theWrappedObject, const QByteArray& data)
2340 void PythonQtWrapper_QHexEdit::setData(QHexEdit* theWrappedObject, const QByteArray& data)
2296 {
2341 {
2297 ( theWrappedObject->setData(data));
2342 ( theWrappedObject->setData(data));
2298 }
2343 }
2299
2344
2300 void PythonQtWrapper_QHexEdit::setFont(QHexEdit* theWrappedObject, const QFont& arg__1)
2345 void PythonQtWrapper_QHexEdit::setFont(QHexEdit* theWrappedObject, const QFont& arg__1)
2301 {
2346 {
2302 ( theWrappedObject->setFont(arg__1));
2347 ( theWrappedObject->setFont(arg__1));
2303 }
2348 }
2304
2349
2305 void PythonQtWrapper_QHexEdit::setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color)
2350 void PythonQtWrapper_QHexEdit::setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color)
2306 {
2351 {
2307 ( theWrappedObject->setHighlightingColor(color));
2352 ( theWrappedObject->setHighlightingColor(color));
2308 }
2353 }
2309
2354
2310 void PythonQtWrapper_QHexEdit::setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1)
2355 void PythonQtWrapper_QHexEdit::setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1)
2311 {
2356 {
2312 ( theWrappedObject->setOverwriteMode(arg__1));
2357 ( theWrappedObject->setOverwriteMode(arg__1));
2313 }
2358 }
2314
2359
2315 void PythonQtWrapper_QHexEdit::setReadOnly(QHexEdit* theWrappedObject, bool arg__1)
2360 void PythonQtWrapper_QHexEdit::setReadOnly(QHexEdit* theWrappedObject, bool arg__1)
2316 {
2361 {
2317 ( theWrappedObject->setReadOnly(arg__1));
2362 ( theWrappedObject->setReadOnly(arg__1));
2318 }
2363 }
2319
2364
2320 void PythonQtWrapper_QHexEdit::setSelectionColor(QHexEdit* theWrappedObject, const QColor& color)
2365 void PythonQtWrapper_QHexEdit::setSelectionColor(QHexEdit* theWrappedObject, const QColor& color)
2321 {
2366 {
2322 ( theWrappedObject->setSelectionColor(color));
2367 ( theWrappedObject->setSelectionColor(color));
2323 }
2368 }
2324
2369
2325 QString PythonQtWrapper_QHexEdit::toReadableString(QHexEdit* theWrappedObject)
2370 QString PythonQtWrapper_QHexEdit::toReadableString(QHexEdit* theWrappedObject)
2326 {
2371 {
2327 return ( theWrappedObject->toReadableString());
2372 return ( theWrappedObject->toReadableString());
2328 }
2373 }
2329
2374
2330
2375
2331
2376
2332 PythonQtShell_QHexSpinBox::~PythonQtShell_QHexSpinBox() {
2377 PythonQtShell_QHexSpinBox::~PythonQtShell_QHexSpinBox() {
2333 PythonQtPrivate* priv = PythonQt::priv();
2378 PythonQtPrivate* priv = PythonQt::priv();
2334 if (priv) { priv->shellClassDeleted(this); }
2379 if (priv) { priv->shellClassDeleted(this); }
2335 }
2380 }
2336 void PythonQtShell_QHexSpinBox::actionEvent(QActionEvent* arg__1)
2381 void PythonQtShell_QHexSpinBox::actionEvent(QActionEvent* arg__1)
2337 {
2382 {
2338 if (_wrapper) {
2383 if (_wrapper) {
2339 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
2384 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
2340 PyErr_Clear();
2385 PyErr_Clear();
2341 if (obj && !PythonQtSlotFunction_Check(obj)) {
2386 if (obj && !PythonQtSlotFunction_Check(obj)) {
2342 static const char* argumentList[] ={"" , "QActionEvent*"};
2387 static const char* argumentList[] ={"" , "QActionEvent*"};
2343 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2388 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2344 void* args[2] = {NULL, (void*)&arg__1};
2389 void* args[2] = {NULL, (void*)&arg__1};
2345 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2390 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2346 if (result) { Py_DECREF(result); }
2391 if (result) { Py_DECREF(result); }
2347 Py_DECREF(obj);
2392 Py_DECREF(obj);
2348 return;
2393 return;
2349 }
2394 }
2350 }
2395 }
2351 QHexSpinBox::actionEvent(arg__1);
2396 QHexSpinBox::actionEvent(arg__1);
2352 }
2397 }
2353 void PythonQtShell_QHexSpinBox::changeEvent(QEvent* event)
2398 void PythonQtShell_QHexSpinBox::changeEvent(QEvent* event)
2354 {
2399 {
2355 if (_wrapper) {
2400 if (_wrapper) {
2356 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
2401 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
2357 PyErr_Clear();
2402 PyErr_Clear();
2358 if (obj && !PythonQtSlotFunction_Check(obj)) {
2403 if (obj && !PythonQtSlotFunction_Check(obj)) {
2359 static const char* argumentList[] ={"" , "QEvent*"};
2404 static const char* argumentList[] ={"" , "QEvent*"};
2360 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2405 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2361 void* args[2] = {NULL, (void*)&event};
2406 void* args[2] = {NULL, (void*)&event};
2362 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2407 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2363 if (result) { Py_DECREF(result); }
2408 if (result) { Py_DECREF(result); }
2364 Py_DECREF(obj);
2409 Py_DECREF(obj);
2365 return;
2410 return;
2366 }
2411 }
2367 }
2412 }
2368 QHexSpinBox::changeEvent(event);
2413 QHexSpinBox::changeEvent(event);
2369 }
2414 }
2370 void PythonQtShell_QHexSpinBox::childEvent(QChildEvent* arg__1)
2415 void PythonQtShell_QHexSpinBox::childEvent(QChildEvent* arg__1)
2371 {
2416 {
2372 if (_wrapper) {
2417 if (_wrapper) {
2373 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
2418 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
2374 PyErr_Clear();
2419 PyErr_Clear();
2375 if (obj && !PythonQtSlotFunction_Check(obj)) {
2420 if (obj && !PythonQtSlotFunction_Check(obj)) {
2376 static const char* argumentList[] ={"" , "QChildEvent*"};
2421 static const char* argumentList[] ={"" , "QChildEvent*"};
2377 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2422 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2378 void* args[2] = {NULL, (void*)&arg__1};
2423 void* args[2] = {NULL, (void*)&arg__1};
2379 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2424 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2380 if (result) { Py_DECREF(result); }
2425 if (result) { Py_DECREF(result); }
2381 Py_DECREF(obj);
2426 Py_DECREF(obj);
2382 return;
2427 return;
2383 }
2428 }
2384 }
2429 }
2385 QHexSpinBox::childEvent(arg__1);
2430 QHexSpinBox::childEvent(arg__1);
2386 }
2431 }
2387 void PythonQtShell_QHexSpinBox::clear()
2432 void PythonQtShell_QHexSpinBox::clear()
2388 {
2433 {
2389 if (_wrapper) {
2434 if (_wrapper) {
2390 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "clear");
2435 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "clear");
2391 PyErr_Clear();
2436 PyErr_Clear();
2392 if (obj && !PythonQtSlotFunction_Check(obj)) {
2437 if (obj && !PythonQtSlotFunction_Check(obj)) {
2393 static const char* argumentList[] ={""};
2438 static const char* argumentList[] ={""};
2394 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2439 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2395 void* args[1] = {NULL};
2440 void* args[1] = {NULL};
2396 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2441 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2397 if (result) { Py_DECREF(result); }
2442 if (result) { Py_DECREF(result); }
2398 Py_DECREF(obj);
2443 Py_DECREF(obj);
2399 return;
2444 return;
2400 }
2445 }
2401 }
2446 }
2402 QHexSpinBox::clear();
2447 QHexSpinBox::clear();
2403 }
2448 }
2404 void PythonQtShell_QHexSpinBox::closeEvent(QCloseEvent* event)
2449 void PythonQtShell_QHexSpinBox::closeEvent(QCloseEvent* event)
2405 {
2450 {
2406 if (_wrapper) {
2451 if (_wrapper) {
2407 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
2452 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
2408 PyErr_Clear();
2453 PyErr_Clear();
2409 if (obj && !PythonQtSlotFunction_Check(obj)) {
2454 if (obj && !PythonQtSlotFunction_Check(obj)) {
2410 static const char* argumentList[] ={"" , "QCloseEvent*"};
2455 static const char* argumentList[] ={"" , "QCloseEvent*"};
2411 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2456 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2412 void* args[2] = {NULL, (void*)&event};
2457 void* args[2] = {NULL, (void*)&event};
2413 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2458 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2414 if (result) { Py_DECREF(result); }
2459 if (result) { Py_DECREF(result); }
2415 Py_DECREF(obj);
2460 Py_DECREF(obj);
2416 return;
2461 return;
2417 }
2462 }
2418 }
2463 }
2419 QHexSpinBox::closeEvent(event);
2464 QHexSpinBox::closeEvent(event);
2420 }
2465 }
2421 void PythonQtShell_QHexSpinBox::contextMenuEvent(QContextMenuEvent* event)
2466 void PythonQtShell_QHexSpinBox::contextMenuEvent(QContextMenuEvent* event)
2422 {
2467 {
2423 if (_wrapper) {
2468 if (_wrapper) {
2424 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
2469 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
2425 PyErr_Clear();
2470 PyErr_Clear();
2426 if (obj && !PythonQtSlotFunction_Check(obj)) {
2471 if (obj && !PythonQtSlotFunction_Check(obj)) {
2427 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
2472 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
2428 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2473 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2429 void* args[2] = {NULL, (void*)&event};
2474 void* args[2] = {NULL, (void*)&event};
2430 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2475 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2431 if (result) { Py_DECREF(result); }
2476 if (result) { Py_DECREF(result); }
2432 Py_DECREF(obj);
2477 Py_DECREF(obj);
2433 return;
2478 return;
2434 }
2479 }
2435 }
2480 }
2436 QHexSpinBox::contextMenuEvent(event);
2481 QHexSpinBox::contextMenuEvent(event);
2437 }
2482 }
2438 void PythonQtShell_QHexSpinBox::customEvent(QEvent* arg__1)
2483 void PythonQtShell_QHexSpinBox::customEvent(QEvent* arg__1)
2439 {
2484 {
2440 if (_wrapper) {
2485 if (_wrapper) {
2441 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
2486 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
2442 PyErr_Clear();
2487 PyErr_Clear();
2443 if (obj && !PythonQtSlotFunction_Check(obj)) {
2488 if (obj && !PythonQtSlotFunction_Check(obj)) {
2444 static const char* argumentList[] ={"" , "QEvent*"};
2489 static const char* argumentList[] ={"" , "QEvent*"};
2445 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2490 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2446 void* args[2] = {NULL, (void*)&arg__1};
2491 void* args[2] = {NULL, (void*)&arg__1};
2447 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2492 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2448 if (result) { Py_DECREF(result); }
2493 if (result) { Py_DECREF(result); }
2449 Py_DECREF(obj);
2494 Py_DECREF(obj);
2450 return;
2495 return;
2451 }
2496 }
2452 }
2497 }
2453 QHexSpinBox::customEvent(arg__1);
2498 QHexSpinBox::customEvent(arg__1);
2454 }
2499 }
2455 int PythonQtShell_QHexSpinBox::devType() const
2500 int PythonQtShell_QHexSpinBox::devType() const
2456 {
2501 {
2457 if (_wrapper) {
2502 if (_wrapper) {
2458 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
2503 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
2459 PyErr_Clear();
2504 PyErr_Clear();
2460 if (obj && !PythonQtSlotFunction_Check(obj)) {
2505 if (obj && !PythonQtSlotFunction_Check(obj)) {
2461 static const char* argumentList[] ={"int"};
2506 static const char* argumentList[] ={"int"};
2462 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2507 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2463 int returnValue;
2508 int returnValue;
2464 void* args[1] = {NULL};
2509 void* args[1] = {NULL};
2465 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2510 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2466 if (result) {
2511 if (result) {
2467 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2512 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2468 if (args[0]!=&returnValue) {
2513 if (args[0]!=&returnValue) {
2469 if (args[0]==NULL) {
2514 if (args[0]==NULL) {
2470 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
2515 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
2471 } else {
2516 } else {
2472 returnValue = *((int*)args[0]);
2517 returnValue = *((int*)args[0]);
2473 }
2518 }
2474 }
2519 }
2475 }
2520 }
2476 if (result) { Py_DECREF(result); }
2521 if (result) { Py_DECREF(result); }
2477 Py_DECREF(obj);
2522 Py_DECREF(obj);
2478 return returnValue;
2523 return returnValue;
2479 }
2524 }
2480 }
2525 }
2481 return QHexSpinBox::devType();
2526 return QHexSpinBox::devType();
2482 }
2527 }
2483 void PythonQtShell_QHexSpinBox::dragEnterEvent(QDragEnterEvent* arg__1)
2528 void PythonQtShell_QHexSpinBox::dragEnterEvent(QDragEnterEvent* arg__1)
2484 {
2529 {
2485 if (_wrapper) {
2530 if (_wrapper) {
2486 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
2531 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
2487 PyErr_Clear();
2532 PyErr_Clear();
2488 if (obj && !PythonQtSlotFunction_Check(obj)) {
2533 if (obj && !PythonQtSlotFunction_Check(obj)) {
2489 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
2534 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
2490 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2535 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2491 void* args[2] = {NULL, (void*)&arg__1};
2536 void* args[2] = {NULL, (void*)&arg__1};
2492 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2537 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2493 if (result) { Py_DECREF(result); }
2538 if (result) { Py_DECREF(result); }
2494 Py_DECREF(obj);
2539 Py_DECREF(obj);
2495 return;
2540 return;
2496 }
2541 }
2497 }
2542 }
2498 QHexSpinBox::dragEnterEvent(arg__1);
2543 QHexSpinBox::dragEnterEvent(arg__1);
2499 }
2544 }
2500 void PythonQtShell_QHexSpinBox::dragLeaveEvent(QDragLeaveEvent* arg__1)
2545 void PythonQtShell_QHexSpinBox::dragLeaveEvent(QDragLeaveEvent* arg__1)
2501 {
2546 {
2502 if (_wrapper) {
2547 if (_wrapper) {
2503 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
2548 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
2504 PyErr_Clear();
2549 PyErr_Clear();
2505 if (obj && !PythonQtSlotFunction_Check(obj)) {
2550 if (obj && !PythonQtSlotFunction_Check(obj)) {
2506 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
2551 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
2507 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2552 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2508 void* args[2] = {NULL, (void*)&arg__1};
2553 void* args[2] = {NULL, (void*)&arg__1};
2509 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2554 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2510 if (result) { Py_DECREF(result); }
2555 if (result) { Py_DECREF(result); }
2511 Py_DECREF(obj);
2556 Py_DECREF(obj);
2512 return;
2557 return;
2513 }
2558 }
2514 }
2559 }
2515 QHexSpinBox::dragLeaveEvent(arg__1);
2560 QHexSpinBox::dragLeaveEvent(arg__1);
2516 }
2561 }
2517 void PythonQtShell_QHexSpinBox::dragMoveEvent(QDragMoveEvent* arg__1)
2562 void PythonQtShell_QHexSpinBox::dragMoveEvent(QDragMoveEvent* arg__1)
2518 {
2563 {
2519 if (_wrapper) {
2564 if (_wrapper) {
2520 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
2565 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
2521 PyErr_Clear();
2566 PyErr_Clear();
2522 if (obj && !PythonQtSlotFunction_Check(obj)) {
2567 if (obj && !PythonQtSlotFunction_Check(obj)) {
2523 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
2568 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
2524 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2569 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2525 void* args[2] = {NULL, (void*)&arg__1};
2570 void* args[2] = {NULL, (void*)&arg__1};
2526 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2571 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2527 if (result) { Py_DECREF(result); }
2572 if (result) { Py_DECREF(result); }
2528 Py_DECREF(obj);
2573 Py_DECREF(obj);
2529 return;
2574 return;
2530 }
2575 }
2531 }
2576 }
2532 QHexSpinBox::dragMoveEvent(arg__1);
2577 QHexSpinBox::dragMoveEvent(arg__1);
2533 }
2578 }
2534 void PythonQtShell_QHexSpinBox::dropEvent(QDropEvent* arg__1)
2579 void PythonQtShell_QHexSpinBox::dropEvent(QDropEvent* arg__1)
2535 {
2580 {
2536 if (_wrapper) {
2581 if (_wrapper) {
2537 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
2582 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
2538 PyErr_Clear();
2583 PyErr_Clear();
2539 if (obj && !PythonQtSlotFunction_Check(obj)) {
2584 if (obj && !PythonQtSlotFunction_Check(obj)) {
2540 static const char* argumentList[] ={"" , "QDropEvent*"};
2585 static const char* argumentList[] ={"" , "QDropEvent*"};
2541 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2586 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2542 void* args[2] = {NULL, (void*)&arg__1};
2587 void* args[2] = {NULL, (void*)&arg__1};
2543 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2588 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2544 if (result) { Py_DECREF(result); }
2589 if (result) { Py_DECREF(result); }
2545 Py_DECREF(obj);
2590 Py_DECREF(obj);
2546 return;
2591 return;
2547 }
2592 }
2548 }
2593 }
2549 QHexSpinBox::dropEvent(arg__1);
2594 QHexSpinBox::dropEvent(arg__1);
2550 }
2595 }
2551 void PythonQtShell_QHexSpinBox::enterEvent(QEvent* arg__1)
2596 void PythonQtShell_QHexSpinBox::enterEvent(QEvent* arg__1)
2552 {
2597 {
2553 if (_wrapper) {
2598 if (_wrapper) {
2554 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
2599 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
2555 PyErr_Clear();
2600 PyErr_Clear();
2556 if (obj && !PythonQtSlotFunction_Check(obj)) {
2601 if (obj && !PythonQtSlotFunction_Check(obj)) {
2557 static const char* argumentList[] ={"" , "QEvent*"};
2602 static const char* argumentList[] ={"" , "QEvent*"};
2558 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2603 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2559 void* args[2] = {NULL, (void*)&arg__1};
2604 void* args[2] = {NULL, (void*)&arg__1};
2560 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2605 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2561 if (result) { Py_DECREF(result); }
2606 if (result) { Py_DECREF(result); }
2562 Py_DECREF(obj);
2607 Py_DECREF(obj);
2563 return;
2608 return;
2564 }
2609 }
2565 }
2610 }
2566 QHexSpinBox::enterEvent(arg__1);
2611 QHexSpinBox::enterEvent(arg__1);
2567 }
2612 }
2568 bool PythonQtShell_QHexSpinBox::event(QEvent* event)
2613 bool PythonQtShell_QHexSpinBox::event(QEvent* event)
2569 {
2614 {
2570 if (_wrapper) {
2615 if (_wrapper) {
2571 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
2616 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
2572 PyErr_Clear();
2617 PyErr_Clear();
2573 if (obj && !PythonQtSlotFunction_Check(obj)) {
2618 if (obj && !PythonQtSlotFunction_Check(obj)) {
2574 static const char* argumentList[] ={"bool" , "QEvent*"};
2619 static const char* argumentList[] ={"bool" , "QEvent*"};
2575 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2620 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2576 bool returnValue;
2621 bool returnValue;
2577 void* args[2] = {NULL, (void*)&event};
2622 void* args[2] = {NULL, (void*)&event};
2578 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2623 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2579 if (result) {
2624 if (result) {
2580 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2625 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2581 if (args[0]!=&returnValue) {
2626 if (args[0]!=&returnValue) {
2582 if (args[0]==NULL) {
2627 if (args[0]==NULL) {
2583 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
2628 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
2584 } else {
2629 } else {
2585 returnValue = *((bool*)args[0]);
2630 returnValue = *((bool*)args[0]);
2586 }
2631 }
2587 }
2632 }
2588 }
2633 }
2589 if (result) { Py_DECREF(result); }
2634 if (result) { Py_DECREF(result); }
2590 Py_DECREF(obj);
2635 Py_DECREF(obj);
2591 return returnValue;
2636 return returnValue;
2592 }
2637 }
2593 }
2638 }
2594 return QHexSpinBox::event(event);
2639 return QHexSpinBox::event(event);
2595 }
2640 }
2596 bool PythonQtShell_QHexSpinBox::eventFilter(QObject* arg__1, QEvent* arg__2)
2641 bool PythonQtShell_QHexSpinBox::eventFilter(QObject* arg__1, QEvent* arg__2)
2597 {
2642 {
2598 if (_wrapper) {
2643 if (_wrapper) {
2599 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
2644 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
2600 PyErr_Clear();
2645 PyErr_Clear();
2601 if (obj && !PythonQtSlotFunction_Check(obj)) {
2646 if (obj && !PythonQtSlotFunction_Check(obj)) {
2602 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
2647 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
2603 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2648 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2604 bool returnValue;
2649 bool returnValue;
2605 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
2650 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
2606 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2651 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2607 if (result) {
2652 if (result) {
2608 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2653 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2609 if (args[0]!=&returnValue) {
2654 if (args[0]!=&returnValue) {
2610 if (args[0]==NULL) {
2655 if (args[0]==NULL) {
2611 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
2656 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
2612 } else {
2657 } else {
2613 returnValue = *((bool*)args[0]);
2658 returnValue = *((bool*)args[0]);
2614 }
2659 }
2615 }
2660 }
2616 }
2661 }
2617 if (result) { Py_DECREF(result); }
2662 if (result) { Py_DECREF(result); }
2618 Py_DECREF(obj);
2663 Py_DECREF(obj);
2619 return returnValue;
2664 return returnValue;
2620 }
2665 }
2621 }
2666 }
2622 return QHexSpinBox::eventFilter(arg__1, arg__2);
2667 return QHexSpinBox::eventFilter(arg__1, arg__2);
2623 }
2668 }
2624 void PythonQtShell_QHexSpinBox::fixup(QString& str) const
2669 void PythonQtShell_QHexSpinBox::fixup(QString& str) const
2625 {
2670 {
2626 if (_wrapper) {
2671 if (_wrapper) {
2627 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "fixup");
2672 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "fixup");
2628 PyErr_Clear();
2673 PyErr_Clear();
2629 if (obj && !PythonQtSlotFunction_Check(obj)) {
2674 if (obj && !PythonQtSlotFunction_Check(obj)) {
2630 static const char* argumentList[] ={"" , "QString&"};
2675 static const char* argumentList[] ={"" , "QString&"};
2631 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2676 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2632 void* args[2] = {NULL, (void*)&str};
2677 void* args[2] = {NULL, (void*)&str};
2633 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2678 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2634 if (result) { Py_DECREF(result); }
2679 if (result) { Py_DECREF(result); }
2635 Py_DECREF(obj);
2680 Py_DECREF(obj);
2636 return;
2681 return;
2637 }
2682 }
2638 }
2683 }
2639 QHexSpinBox::fixup(str);
2684 QHexSpinBox::fixup(str);
2640 }
2685 }
2641 void PythonQtShell_QHexSpinBox::focusInEvent(QFocusEvent* event)
2686 void PythonQtShell_QHexSpinBox::focusInEvent(QFocusEvent* event)
2642 {
2687 {
2643 if (_wrapper) {
2688 if (_wrapper) {
2644 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
2689 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
2645 PyErr_Clear();
2690 PyErr_Clear();
2646 if (obj && !PythonQtSlotFunction_Check(obj)) {
2691 if (obj && !PythonQtSlotFunction_Check(obj)) {
2647 static const char* argumentList[] ={"" , "QFocusEvent*"};
2692 static const char* argumentList[] ={"" , "QFocusEvent*"};
2648 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2693 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2649 void* args[2] = {NULL, (void*)&event};
2694 void* args[2] = {NULL, (void*)&event};
2650 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2695 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2651 if (result) { Py_DECREF(result); }
2696 if (result) { Py_DECREF(result); }
2652 Py_DECREF(obj);
2697 Py_DECREF(obj);
2653 return;
2698 return;
2654 }
2699 }
2655 }
2700 }
2656 QHexSpinBox::focusInEvent(event);
2701 QHexSpinBox::focusInEvent(event);
2657 }
2702 }
2658 bool PythonQtShell_QHexSpinBox::focusNextPrevChild(bool next)
2703 bool PythonQtShell_QHexSpinBox::focusNextPrevChild(bool next)
2659 {
2704 {
2660 if (_wrapper) {
2705 if (_wrapper) {
2661 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
2706 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
2662 PyErr_Clear();
2707 PyErr_Clear();
2663 if (obj && !PythonQtSlotFunction_Check(obj)) {
2708 if (obj && !PythonQtSlotFunction_Check(obj)) {
2664 static const char* argumentList[] ={"bool" , "bool"};
2709 static const char* argumentList[] ={"bool" , "bool"};
2665 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2710 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2666 bool returnValue;
2711 bool returnValue;
2667 void* args[2] = {NULL, (void*)&next};
2712 void* args[2] = {NULL, (void*)&next};
2668 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2713 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2669 if (result) {
2714 if (result) {
2670 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2715 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2671 if (args[0]!=&returnValue) {
2716 if (args[0]!=&returnValue) {
2672 if (args[0]==NULL) {
2717 if (args[0]==NULL) {
2673 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
2718 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
2674 } else {
2719 } else {
2675 returnValue = *((bool*)args[0]);
2720 returnValue = *((bool*)args[0]);
2676 }
2721 }
2677 }
2722 }
2678 }
2723 }
2679 if (result) { Py_DECREF(result); }
2724 if (result) { Py_DECREF(result); }
2680 Py_DECREF(obj);
2725 Py_DECREF(obj);
2681 return returnValue;
2726 return returnValue;
2682 }
2727 }
2683 }
2728 }
2684 return QHexSpinBox::focusNextPrevChild(next);
2729 return QHexSpinBox::focusNextPrevChild(next);
2685 }
2730 }
2686 void PythonQtShell_QHexSpinBox::focusOutEvent(QFocusEvent* event)
2731 void PythonQtShell_QHexSpinBox::focusOutEvent(QFocusEvent* event)
2687 {
2732 {
2688 if (_wrapper) {
2733 if (_wrapper) {
2689 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
2734 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
2690 PyErr_Clear();
2735 PyErr_Clear();
2691 if (obj && !PythonQtSlotFunction_Check(obj)) {
2736 if (obj && !PythonQtSlotFunction_Check(obj)) {
2692 static const char* argumentList[] ={"" , "QFocusEvent*"};
2737 static const char* argumentList[] ={"" , "QFocusEvent*"};
2693 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2738 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2694 void* args[2] = {NULL, (void*)&event};
2739 void* args[2] = {NULL, (void*)&event};
2695 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2740 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2696 if (result) { Py_DECREF(result); }
2741 if (result) { Py_DECREF(result); }
2697 Py_DECREF(obj);
2742 Py_DECREF(obj);
2698 return;
2743 return;
2699 }
2744 }
2700 }
2745 }
2701 QHexSpinBox::focusOutEvent(event);
2746 QHexSpinBox::focusOutEvent(event);
2702 }
2747 }
2703 bool PythonQtShell_QHexSpinBox::hasHeightForWidth() const
2748 bool PythonQtShell_QHexSpinBox::hasHeightForWidth() const
2704 {
2749 {
2705 if (_wrapper) {
2750 if (_wrapper) {
2706 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
2751 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
2707 PyErr_Clear();
2752 PyErr_Clear();
2708 if (obj && !PythonQtSlotFunction_Check(obj)) {
2753 if (obj && !PythonQtSlotFunction_Check(obj)) {
2709 static const char* argumentList[] ={"bool"};
2754 static const char* argumentList[] ={"bool"};
2710 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2755 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2711 bool returnValue;
2756 bool returnValue;
2712 void* args[1] = {NULL};
2757 void* args[1] = {NULL};
2713 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2758 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2714 if (result) {
2759 if (result) {
2715 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2760 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2716 if (args[0]!=&returnValue) {
2761 if (args[0]!=&returnValue) {
2717 if (args[0]==NULL) {
2762 if (args[0]==NULL) {
2718 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
2763 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
2719 } else {
2764 } else {
2720 returnValue = *((bool*)args[0]);
2765 returnValue = *((bool*)args[0]);
2721 }
2766 }
2722 }
2767 }
2723 }
2768 }
2724 if (result) { Py_DECREF(result); }
2769 if (result) { Py_DECREF(result); }
2725 Py_DECREF(obj);
2770 Py_DECREF(obj);
2726 return returnValue;
2771 return returnValue;
2727 }
2772 }
2728 }
2773 }
2729 return QHexSpinBox::hasHeightForWidth();
2774 return QHexSpinBox::hasHeightForWidth();
2730 }
2775 }
2731 int PythonQtShell_QHexSpinBox::heightForWidth(int arg__1) const
2776 int PythonQtShell_QHexSpinBox::heightForWidth(int arg__1) const
2732 {
2777 {
2733 if (_wrapper) {
2778 if (_wrapper) {
2734 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
2779 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
2735 PyErr_Clear();
2780 PyErr_Clear();
2736 if (obj && !PythonQtSlotFunction_Check(obj)) {
2781 if (obj && !PythonQtSlotFunction_Check(obj)) {
2737 static const char* argumentList[] ={"int" , "int"};
2782 static const char* argumentList[] ={"int" , "int"};
2738 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2783 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2739 int returnValue;
2784 int returnValue;
2740 void* args[2] = {NULL, (void*)&arg__1};
2785 void* args[2] = {NULL, (void*)&arg__1};
2741 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2786 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2742 if (result) {
2787 if (result) {
2743 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2788 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2744 if (args[0]!=&returnValue) {
2789 if (args[0]!=&returnValue) {
2745 if (args[0]==NULL) {
2790 if (args[0]==NULL) {
2746 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
2791 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
2747 } else {
2792 } else {
2748 returnValue = *((int*)args[0]);
2793 returnValue = *((int*)args[0]);
2749 }
2794 }
2750 }
2795 }
2751 }
2796 }
2752 if (result) { Py_DECREF(result); }
2797 if (result) { Py_DECREF(result); }
2753 Py_DECREF(obj);
2798 Py_DECREF(obj);
2754 return returnValue;
2799 return returnValue;
2755 }
2800 }
2756 }
2801 }
2757 return QHexSpinBox::heightForWidth(arg__1);
2802 return QHexSpinBox::heightForWidth(arg__1);
2758 }
2803 }
2759 void PythonQtShell_QHexSpinBox::hideEvent(QHideEvent* event)
2804 void PythonQtShell_QHexSpinBox::hideEvent(QHideEvent* event)
2760 {
2805 {
2761 if (_wrapper) {
2806 if (_wrapper) {
2762 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
2807 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
2763 PyErr_Clear();
2808 PyErr_Clear();
2764 if (obj && !PythonQtSlotFunction_Check(obj)) {
2809 if (obj && !PythonQtSlotFunction_Check(obj)) {
2765 static const char* argumentList[] ={"" , "QHideEvent*"};
2810 static const char* argumentList[] ={"" , "QHideEvent*"};
2766 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2811 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2767 void* args[2] = {NULL, (void*)&event};
2812 void* args[2] = {NULL, (void*)&event};
2768 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2813 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2769 if (result) { Py_DECREF(result); }
2814 if (result) { Py_DECREF(result); }
2770 Py_DECREF(obj);
2815 Py_DECREF(obj);
2771 return;
2816 return;
2772 }
2817 }
2773 }
2818 }
2774 QHexSpinBox::hideEvent(event);
2819 QHexSpinBox::hideEvent(event);
2775 }
2820 }
2776 void PythonQtShell_QHexSpinBox::initPainter(QPainter* painter) const
2821 void PythonQtShell_QHexSpinBox::initPainter(QPainter* painter) const
2777 {
2822 {
2778 if (_wrapper) {
2823 if (_wrapper) {
2779 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
2824 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
2780 PyErr_Clear();
2825 PyErr_Clear();
2781 if (obj && !PythonQtSlotFunction_Check(obj)) {
2826 if (obj && !PythonQtSlotFunction_Check(obj)) {
2782 static const char* argumentList[] ={"" , "QPainter*"};
2827 static const char* argumentList[] ={"" , "QPainter*"};
2783 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2828 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2784 void* args[2] = {NULL, (void*)&painter};
2829 void* args[2] = {NULL, (void*)&painter};
2785 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2830 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2786 if (result) { Py_DECREF(result); }
2831 if (result) { Py_DECREF(result); }
2787 Py_DECREF(obj);
2832 Py_DECREF(obj);
2788 return;
2833 return;
2789 }
2834 }
2790 }
2835 }
2791 QHexSpinBox::initPainter(painter);
2836 QHexSpinBox::initPainter(painter);
2792 }
2837 }
2793 void PythonQtShell_QHexSpinBox::inputMethodEvent(QInputMethodEvent* arg__1)
2838 void PythonQtShell_QHexSpinBox::inputMethodEvent(QInputMethodEvent* arg__1)
2794 {
2839 {
2795 if (_wrapper) {
2840 if (_wrapper) {
2796 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
2841 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
2797 PyErr_Clear();
2842 PyErr_Clear();
2798 if (obj && !PythonQtSlotFunction_Check(obj)) {
2843 if (obj && !PythonQtSlotFunction_Check(obj)) {
2799 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
2844 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
2800 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2845 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2801 void* args[2] = {NULL, (void*)&arg__1};
2846 void* args[2] = {NULL, (void*)&arg__1};
2802 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2847 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2803 if (result) { Py_DECREF(result); }
2848 if (result) { Py_DECREF(result); }
2804 Py_DECREF(obj);
2849 Py_DECREF(obj);
2805 return;
2850 return;
2806 }
2851 }
2807 }
2852 }
2808 QHexSpinBox::inputMethodEvent(arg__1);
2853 QHexSpinBox::inputMethodEvent(arg__1);
2809 }
2854 }
2810 QVariant PythonQtShell_QHexSpinBox::inputMethodQuery(Qt::InputMethodQuery arg__1) const
2855 QVariant PythonQtShell_QHexSpinBox::inputMethodQuery(Qt::InputMethodQuery arg__1) const
2811 {
2856 {
2812 if (_wrapper) {
2857 if (_wrapper) {
2813 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
2858 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
2814 PyErr_Clear();
2859 PyErr_Clear();
2815 if (obj && !PythonQtSlotFunction_Check(obj)) {
2860 if (obj && !PythonQtSlotFunction_Check(obj)) {
2816 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
2861 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
2817 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2862 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2818 QVariant returnValue;
2863 QVariant returnValue;
2819 void* args[2] = {NULL, (void*)&arg__1};
2864 void* args[2] = {NULL, (void*)&arg__1};
2820 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2865 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2821 if (result) {
2866 if (result) {
2822 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2867 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2823 if (args[0]!=&returnValue) {
2868 if (args[0]!=&returnValue) {
2824 if (args[0]==NULL) {
2869 if (args[0]==NULL) {
2825 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
2870 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
2826 } else {
2871 } else {
2827 returnValue = *((QVariant*)args[0]);
2872 returnValue = *((QVariant*)args[0]);
2828 }
2873 }
2829 }
2874 }
2830 }
2875 }
2831 if (result) { Py_DECREF(result); }
2876 if (result) { Py_DECREF(result); }
2832 Py_DECREF(obj);
2877 Py_DECREF(obj);
2833 return returnValue;
2878 return returnValue;
2834 }
2879 }
2835 }
2880 }
2836 return QHexSpinBox::inputMethodQuery(arg__1);
2881 return QHexSpinBox::inputMethodQuery(arg__1);
2837 }
2882 }
2838 void PythonQtShell_QHexSpinBox::keyPressEvent(QKeyEvent* event)
2883 void PythonQtShell_QHexSpinBox::keyPressEvent(QKeyEvent* event)
2839 {
2884 {
2840 if (_wrapper) {
2885 if (_wrapper) {
2841 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
2886 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
2842 PyErr_Clear();
2887 PyErr_Clear();
2843 if (obj && !PythonQtSlotFunction_Check(obj)) {
2888 if (obj && !PythonQtSlotFunction_Check(obj)) {
2844 static const char* argumentList[] ={"" , "QKeyEvent*"};
2889 static const char* argumentList[] ={"" , "QKeyEvent*"};
2845 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2890 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2846 void* args[2] = {NULL, (void*)&event};
2891 void* args[2] = {NULL, (void*)&event};
2847 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2892 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2848 if (result) { Py_DECREF(result); }
2893 if (result) { Py_DECREF(result); }
2849 Py_DECREF(obj);
2894 Py_DECREF(obj);
2850 return;
2895 return;
2851 }
2896 }
2852 }
2897 }
2853 QHexSpinBox::keyPressEvent(event);
2898 QHexSpinBox::keyPressEvent(event);
2854 }
2899 }
2855 void PythonQtShell_QHexSpinBox::keyReleaseEvent(QKeyEvent* event)
2900 void PythonQtShell_QHexSpinBox::keyReleaseEvent(QKeyEvent* event)
2856 {
2901 {
2857 if (_wrapper) {
2902 if (_wrapper) {
2858 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
2903 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
2859 PyErr_Clear();
2904 PyErr_Clear();
2860 if (obj && !PythonQtSlotFunction_Check(obj)) {
2905 if (obj && !PythonQtSlotFunction_Check(obj)) {
2861 static const char* argumentList[] ={"" , "QKeyEvent*"};
2906 static const char* argumentList[] ={"" , "QKeyEvent*"};
2862 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2907 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2863 void* args[2] = {NULL, (void*)&event};
2908 void* args[2] = {NULL, (void*)&event};
2864 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2909 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2865 if (result) { Py_DECREF(result); }
2910 if (result) { Py_DECREF(result); }
2866 Py_DECREF(obj);
2911 Py_DECREF(obj);
2867 return;
2912 return;
2868 }
2913 }
2869 }
2914 }
2870 QHexSpinBox::keyReleaseEvent(event);
2915 QHexSpinBox::keyReleaseEvent(event);
2871 }
2916 }
2872 void PythonQtShell_QHexSpinBox::leaveEvent(QEvent* arg__1)
2917 void PythonQtShell_QHexSpinBox::leaveEvent(QEvent* arg__1)
2873 {
2918 {
2874 if (_wrapper) {
2919 if (_wrapper) {
2875 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
2920 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
2876 PyErr_Clear();
2921 PyErr_Clear();
2877 if (obj && !PythonQtSlotFunction_Check(obj)) {
2922 if (obj && !PythonQtSlotFunction_Check(obj)) {
2878 static const char* argumentList[] ={"" , "QEvent*"};
2923 static const char* argumentList[] ={"" , "QEvent*"};
2879 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2924 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2880 void* args[2] = {NULL, (void*)&arg__1};
2925 void* args[2] = {NULL, (void*)&arg__1};
2881 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2926 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2882 if (result) { Py_DECREF(result); }
2927 if (result) { Py_DECREF(result); }
2883 Py_DECREF(obj);
2928 Py_DECREF(obj);
2884 return;
2929 return;
2885 }
2930 }
2886 }
2931 }
2887 QHexSpinBox::leaveEvent(arg__1);
2932 QHexSpinBox::leaveEvent(arg__1);
2888 }
2933 }
2889 int PythonQtShell_QHexSpinBox::metric(QPaintDevice::PaintDeviceMetric arg__1) const
2934 int PythonQtShell_QHexSpinBox::metric(QPaintDevice::PaintDeviceMetric arg__1) const
2890 {
2935 {
2891 if (_wrapper) {
2936 if (_wrapper) {
2892 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
2937 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
2893 PyErr_Clear();
2938 PyErr_Clear();
2894 if (obj && !PythonQtSlotFunction_Check(obj)) {
2939 if (obj && !PythonQtSlotFunction_Check(obj)) {
2895 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
2940 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
2896 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2941 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2897 int returnValue;
2942 int returnValue;
2898 void* args[2] = {NULL, (void*)&arg__1};
2943 void* args[2] = {NULL, (void*)&arg__1};
2899 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2944 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2900 if (result) {
2945 if (result) {
2901 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2946 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2902 if (args[0]!=&returnValue) {
2947 if (args[0]!=&returnValue) {
2903 if (args[0]==NULL) {
2948 if (args[0]==NULL) {
2904 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
2949 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
2905 } else {
2950 } else {
2906 returnValue = *((int*)args[0]);
2951 returnValue = *((int*)args[0]);
2907 }
2952 }
2908 }
2953 }
2909 }
2954 }
2910 if (result) { Py_DECREF(result); }
2955 if (result) { Py_DECREF(result); }
2911 Py_DECREF(obj);
2956 Py_DECREF(obj);
2912 return returnValue;
2957 return returnValue;
2913 }
2958 }
2914 }
2959 }
2915 return QHexSpinBox::metric(arg__1);
2960 return QHexSpinBox::metric(arg__1);
2916 }
2961 }
2917 void PythonQtShell_QHexSpinBox::mouseDoubleClickEvent(QMouseEvent* arg__1)
2962 void PythonQtShell_QHexSpinBox::mouseDoubleClickEvent(QMouseEvent* arg__1)
2918 {
2963 {
2919 if (_wrapper) {
2964 if (_wrapper) {
2920 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
2965 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
2921 PyErr_Clear();
2966 PyErr_Clear();
2922 if (obj && !PythonQtSlotFunction_Check(obj)) {
2967 if (obj && !PythonQtSlotFunction_Check(obj)) {
2923 static const char* argumentList[] ={"" , "QMouseEvent*"};
2968 static const char* argumentList[] ={"" , "QMouseEvent*"};
2924 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2969 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2925 void* args[2] = {NULL, (void*)&arg__1};
2970 void* args[2] = {NULL, (void*)&arg__1};
2926 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2971 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2927 if (result) { Py_DECREF(result); }
2972 if (result) { Py_DECREF(result); }
2928 Py_DECREF(obj);
2973 Py_DECREF(obj);
2929 return;
2974 return;
2930 }
2975 }
2931 }
2976 }
2932 QHexSpinBox::mouseDoubleClickEvent(arg__1);
2977 QHexSpinBox::mouseDoubleClickEvent(arg__1);
2933 }
2978 }
2934 void PythonQtShell_QHexSpinBox::mouseMoveEvent(QMouseEvent* event)
2979 void PythonQtShell_QHexSpinBox::mouseMoveEvent(QMouseEvent* event)
2935 {
2980 {
2936 if (_wrapper) {
2981 if (_wrapper) {
2937 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
2982 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
2938 PyErr_Clear();
2983 PyErr_Clear();
2939 if (obj && !PythonQtSlotFunction_Check(obj)) {
2984 if (obj && !PythonQtSlotFunction_Check(obj)) {
2940 static const char* argumentList[] ={"" , "QMouseEvent*"};
2985 static const char* argumentList[] ={"" , "QMouseEvent*"};
2941 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2986 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2942 void* args[2] = {NULL, (void*)&event};
2987 void* args[2] = {NULL, (void*)&event};
2943 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2988 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2944 if (result) { Py_DECREF(result); }
2989 if (result) { Py_DECREF(result); }
2945 Py_DECREF(obj);
2990 Py_DECREF(obj);
2946 return;
2991 return;
2947 }
2992 }
2948 }
2993 }
2949 QHexSpinBox::mouseMoveEvent(event);
2994 QHexSpinBox::mouseMoveEvent(event);
2950 }
2995 }
2951 void PythonQtShell_QHexSpinBox::mousePressEvent(QMouseEvent* event)
2996 void PythonQtShell_QHexSpinBox::mousePressEvent(QMouseEvent* event)
2952 {
2997 {
2953 if (_wrapper) {
2998 if (_wrapper) {
2954 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
2999 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
2955 PyErr_Clear();
3000 PyErr_Clear();
2956 if (obj && !PythonQtSlotFunction_Check(obj)) {
3001 if (obj && !PythonQtSlotFunction_Check(obj)) {
2957 static const char* argumentList[] ={"" , "QMouseEvent*"};
3002 static const char* argumentList[] ={"" , "QMouseEvent*"};
2958 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3003 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2959 void* args[2] = {NULL, (void*)&event};
3004 void* args[2] = {NULL, (void*)&event};
2960 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3005 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2961 if (result) { Py_DECREF(result); }
3006 if (result) { Py_DECREF(result); }
2962 Py_DECREF(obj);
3007 Py_DECREF(obj);
2963 return;
3008 return;
2964 }
3009 }
2965 }
3010 }
2966 QHexSpinBox::mousePressEvent(event);
3011 QHexSpinBox::mousePressEvent(event);
2967 }
3012 }
2968 void PythonQtShell_QHexSpinBox::mouseReleaseEvent(QMouseEvent* event)
3013 void PythonQtShell_QHexSpinBox::mouseReleaseEvent(QMouseEvent* event)
2969 {
3014 {
2970 if (_wrapper) {
3015 if (_wrapper) {
2971 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
3016 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
2972 PyErr_Clear();
3017 PyErr_Clear();
2973 if (obj && !PythonQtSlotFunction_Check(obj)) {
3018 if (obj && !PythonQtSlotFunction_Check(obj)) {
2974 static const char* argumentList[] ={"" , "QMouseEvent*"};
3019 static const char* argumentList[] ={"" , "QMouseEvent*"};
2975 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3020 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2976 void* args[2] = {NULL, (void*)&event};
3021 void* args[2] = {NULL, (void*)&event};
2977 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3022 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2978 if (result) { Py_DECREF(result); }
3023 if (result) { Py_DECREF(result); }
2979 Py_DECREF(obj);
3024 Py_DECREF(obj);
2980 return;
3025 return;
2981 }
3026 }
2982 }
3027 }
2983 QHexSpinBox::mouseReleaseEvent(event);
3028 QHexSpinBox::mouseReleaseEvent(event);
2984 }
3029 }
2985 void PythonQtShell_QHexSpinBox::moveEvent(QMoveEvent* arg__1)
3030 void PythonQtShell_QHexSpinBox::moveEvent(QMoveEvent* arg__1)
2986 {
3031 {
2987 if (_wrapper) {
3032 if (_wrapper) {
2988 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
3033 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
2989 PyErr_Clear();
3034 PyErr_Clear();
2990 if (obj && !PythonQtSlotFunction_Check(obj)) {
3035 if (obj && !PythonQtSlotFunction_Check(obj)) {
2991 static const char* argumentList[] ={"" , "QMoveEvent*"};
3036 static const char* argumentList[] ={"" , "QMoveEvent*"};
2992 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3037 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2993 void* args[2] = {NULL, (void*)&arg__1};
3038 void* args[2] = {NULL, (void*)&arg__1};
2994 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3039 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2995 if (result) { Py_DECREF(result); }
3040 if (result) { Py_DECREF(result); }
2996 Py_DECREF(obj);
3041 Py_DECREF(obj);
2997 return;
3042 return;
2998 }
3043 }
2999 }
3044 }
3000 QHexSpinBox::moveEvent(arg__1);
3045 QHexSpinBox::moveEvent(arg__1);
3001 }
3046 }
3002 bool PythonQtShell_QHexSpinBox::nativeEvent(const QByteArray& eventType, void* message, long* result)
3047 bool PythonQtShell_QHexSpinBox::nativeEvent(const QByteArray& eventType, void* message, long* result)
3003 {
3048 {
3004 if (_wrapper) {
3049 if (_wrapper) {
3005 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
3050 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
3006 PyErr_Clear();
3051 PyErr_Clear();
3007 if (obj && !PythonQtSlotFunction_Check(obj)) {
3052 if (obj && !PythonQtSlotFunction_Check(obj)) {
3008 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
3053 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
3009 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
3054 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
3010 bool returnValue;
3055 bool returnValue;
3011 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
3056 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
3012 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3057 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3013 if (result) {
3058 if (result) {
3014 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3059 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3015 if (args[0]!=&returnValue) {
3060 if (args[0]!=&returnValue) {
3016 if (args[0]==NULL) {
3061 if (args[0]==NULL) {
3017 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
3062 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
3018 } else {
3063 } else {
3019 returnValue = *((bool*)args[0]);
3064 returnValue = *((bool*)args[0]);
3020 }
3065 }
3021 }
3066 }
3022 }
3067 }
3023 if (result) { Py_DECREF(result); }
3068 if (result) { Py_DECREF(result); }
3024 Py_DECREF(obj);
3069 Py_DECREF(obj);
3025 return returnValue;
3070 return returnValue;
3026 }
3071 }
3027 }
3072 }
3028 return QHexSpinBox::nativeEvent(eventType, message, result);
3073 return QHexSpinBox::nativeEvent(eventType, message, result);
3029 }
3074 }
3030 QPaintEngine* PythonQtShell_QHexSpinBox::paintEngine() const
3075 QPaintEngine* PythonQtShell_QHexSpinBox::paintEngine() const
3031 {
3076 {
3032 if (_wrapper) {
3077 if (_wrapper) {
3033 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
3078 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
3034 PyErr_Clear();
3079 PyErr_Clear();
3035 if (obj && !PythonQtSlotFunction_Check(obj)) {
3080 if (obj && !PythonQtSlotFunction_Check(obj)) {
3036 static const char* argumentList[] ={"QPaintEngine*"};
3081 static const char* argumentList[] ={"QPaintEngine*"};
3037 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3082 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3038 QPaintEngine* returnValue;
3083 QPaintEngine* returnValue;
3039 void* args[1] = {NULL};
3084 void* args[1] = {NULL};
3040 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3085 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3041 if (result) {
3086 if (result) {
3042 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3087 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3043 if (args[0]!=&returnValue) {
3088 if (args[0]!=&returnValue) {
3044 if (args[0]==NULL) {
3089 if (args[0]==NULL) {
3045 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
3090 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
3046 } else {
3091 } else {
3047 returnValue = *((QPaintEngine**)args[0]);
3092 returnValue = *((QPaintEngine**)args[0]);
3048 }
3093 }
3049 }
3094 }
3050 }
3095 }
3051 if (result) { Py_DECREF(result); }
3096 if (result) { Py_DECREF(result); }
3052 Py_DECREF(obj);
3097 Py_DECREF(obj);
3053 return returnValue;
3098 return returnValue;
3054 }
3099 }
3055 }
3100 }
3056 return QHexSpinBox::paintEngine();
3101 return QHexSpinBox::paintEngine();
3057 }
3102 }
3058 void PythonQtShell_QHexSpinBox::paintEvent(QPaintEvent* event)
3103 void PythonQtShell_QHexSpinBox::paintEvent(QPaintEvent* event)
3059 {
3104 {
3060 if (_wrapper) {
3105 if (_wrapper) {
3061 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
3106 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
3062 PyErr_Clear();
3107 PyErr_Clear();
3063 if (obj && !PythonQtSlotFunction_Check(obj)) {
3108 if (obj && !PythonQtSlotFunction_Check(obj)) {
3064 static const char* argumentList[] ={"" , "QPaintEvent*"};
3109 static const char* argumentList[] ={"" , "QPaintEvent*"};
3065 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3110 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3066 void* args[2] = {NULL, (void*)&event};
3111 void* args[2] = {NULL, (void*)&event};
3067 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3112 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3068 if (result) { Py_DECREF(result); }
3113 if (result) { Py_DECREF(result); }
3069 Py_DECREF(obj);
3114 Py_DECREF(obj);
3070 return;
3115 return;
3071 }
3116 }
3072 }
3117 }
3073 QHexSpinBox::paintEvent(event);
3118 QHexSpinBox::paintEvent(event);
3074 }
3119 }
3075 QPaintDevice* PythonQtShell_QHexSpinBox::redirected(QPoint* offset) const
3120 QPaintDevice* PythonQtShell_QHexSpinBox::redirected(QPoint* offset) const
3076 {
3121 {
3077 if (_wrapper) {
3122 if (_wrapper) {
3078 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
3123 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
3079 PyErr_Clear();
3124 PyErr_Clear();
3080 if (obj && !PythonQtSlotFunction_Check(obj)) {
3125 if (obj && !PythonQtSlotFunction_Check(obj)) {
3081 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
3126 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
3082 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3127 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3083 QPaintDevice* returnValue;
3128 QPaintDevice* returnValue;
3084 void* args[2] = {NULL, (void*)&offset};
3129 void* args[2] = {NULL, (void*)&offset};
3085 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3130 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3086 if (result) {
3131 if (result) {
3087 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3132 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3088 if (args[0]!=&returnValue) {
3133 if (args[0]!=&returnValue) {
3089 if (args[0]==NULL) {
3134 if (args[0]==NULL) {
3090 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
3135 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
3091 } else {
3136 } else {
3092 returnValue = *((QPaintDevice**)args[0]);
3137 returnValue = *((QPaintDevice**)args[0]);
3093 }
3138 }
3094 }
3139 }
3095 }
3140 }
3096 if (result) { Py_DECREF(result); }
3141 if (result) { Py_DECREF(result); }
3097 Py_DECREF(obj);
3142 Py_DECREF(obj);
3098 return returnValue;
3143 return returnValue;
3099 }
3144 }
3100 }
3145 }
3101 return QHexSpinBox::redirected(offset);
3146 return QHexSpinBox::redirected(offset);
3102 }
3147 }
3103 void PythonQtShell_QHexSpinBox::resizeEvent(QResizeEvent* event)
3148 void PythonQtShell_QHexSpinBox::resizeEvent(QResizeEvent* event)
3104 {
3149 {
3105 if (_wrapper) {
3150 if (_wrapper) {
3106 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
3151 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
3107 PyErr_Clear();
3152 PyErr_Clear();
3108 if (obj && !PythonQtSlotFunction_Check(obj)) {
3153 if (obj && !PythonQtSlotFunction_Check(obj)) {
3109 static const char* argumentList[] ={"" , "QResizeEvent*"};
3154 static const char* argumentList[] ={"" , "QResizeEvent*"};
3110 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3155 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3111 void* args[2] = {NULL, (void*)&event};
3156 void* args[2] = {NULL, (void*)&event};
3112 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3157 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3113 if (result) { Py_DECREF(result); }
3158 if (result) { Py_DECREF(result); }
3114 Py_DECREF(obj);
3159 Py_DECREF(obj);
3115 return;
3160 return;
3116 }
3161 }
3117 }
3162 }
3118 QHexSpinBox::resizeEvent(event);
3163 QHexSpinBox::resizeEvent(event);
3119 }
3164 }
3120 QPainter* PythonQtShell_QHexSpinBox::sharedPainter() const
3165 QPainter* PythonQtShell_QHexSpinBox::sharedPainter() const
3121 {
3166 {
3122 if (_wrapper) {
3167 if (_wrapper) {
3123 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
3168 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
3124 PyErr_Clear();
3169 PyErr_Clear();
3125 if (obj && !PythonQtSlotFunction_Check(obj)) {
3170 if (obj && !PythonQtSlotFunction_Check(obj)) {
3126 static const char* argumentList[] ={"QPainter*"};
3171 static const char* argumentList[] ={"QPainter*"};
3127 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3172 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3128 QPainter* returnValue;
3173 QPainter* returnValue;
3129 void* args[1] = {NULL};
3174 void* args[1] = {NULL};
3130 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3175 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3131 if (result) {
3176 if (result) {
3132 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3177 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3133 if (args[0]!=&returnValue) {
3178 if (args[0]!=&returnValue) {
3134 if (args[0]==NULL) {
3179 if (args[0]==NULL) {
3135 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
3180 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
3136 } else {
3181 } else {
3137 returnValue = *((QPainter**)args[0]);
3182 returnValue = *((QPainter**)args[0]);
3138 }
3183 }
3139 }
3184 }
3140 }
3185 }
3141 if (result) { Py_DECREF(result); }
3186 if (result) { Py_DECREF(result); }
3142 Py_DECREF(obj);
3187 Py_DECREF(obj);
3143 return returnValue;
3188 return returnValue;
3144 }
3189 }
3145 }
3190 }
3146 return QHexSpinBox::sharedPainter();
3191 return QHexSpinBox::sharedPainter();
3147 }
3192 }
3148 void PythonQtShell_QHexSpinBox::showEvent(QShowEvent* event)
3193 void PythonQtShell_QHexSpinBox::showEvent(QShowEvent* event)
3149 {
3194 {
3150 if (_wrapper) {
3195 if (_wrapper) {
3151 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
3196 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
3152 PyErr_Clear();
3197 PyErr_Clear();
3153 if (obj && !PythonQtSlotFunction_Check(obj)) {
3198 if (obj && !PythonQtSlotFunction_Check(obj)) {
3154 static const char* argumentList[] ={"" , "QShowEvent*"};
3199 static const char* argumentList[] ={"" , "QShowEvent*"};
3155 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3200 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3156 void* args[2] = {NULL, (void*)&event};
3201 void* args[2] = {NULL, (void*)&event};
3157 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3202 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3158 if (result) { Py_DECREF(result); }
3203 if (result) { Py_DECREF(result); }
3159 Py_DECREF(obj);
3204 Py_DECREF(obj);
3160 return;
3205 return;
3161 }
3206 }
3162 }
3207 }
3163 QHexSpinBox::showEvent(event);
3208 QHexSpinBox::showEvent(event);
3164 }
3209 }
3165 void PythonQtShell_QHexSpinBox::stepBy(int steps)
3210 void PythonQtShell_QHexSpinBox::stepBy(int steps)
3166 {
3211 {
3167 if (_wrapper) {
3212 if (_wrapper) {
3168 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepBy");
3213 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepBy");
3169 PyErr_Clear();
3214 PyErr_Clear();
3170 if (obj && !PythonQtSlotFunction_Check(obj)) {
3215 if (obj && !PythonQtSlotFunction_Check(obj)) {
3171 static const char* argumentList[] ={"" , "int"};
3216 static const char* argumentList[] ={"" , "int"};
3172 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3217 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3173 void* args[2] = {NULL, (void*)&steps};
3218 void* args[2] = {NULL, (void*)&steps};
3174 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3219 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3175 if (result) { Py_DECREF(result); }
3220 if (result) { Py_DECREF(result); }
3176 Py_DECREF(obj);
3221 Py_DECREF(obj);
3177 return;
3222 return;
3178 }
3223 }
3179 }
3224 }
3180 QHexSpinBox::stepBy(steps);
3225 QHexSpinBox::stepBy(steps);
3181 }
3226 }
3182 QAbstractSpinBox::StepEnabled PythonQtShell_QHexSpinBox::stepEnabled() const
3227 QAbstractSpinBox::StepEnabled PythonQtShell_QHexSpinBox::stepEnabled() const
3183 {
3228 {
3184 if (_wrapper) {
3229 if (_wrapper) {
3185 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepEnabled");
3230 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepEnabled");
3186 PyErr_Clear();
3231 PyErr_Clear();
3187 if (obj && !PythonQtSlotFunction_Check(obj)) {
3232 if (obj && !PythonQtSlotFunction_Check(obj)) {
3188 static const char* argumentList[] ={"QAbstractSpinBox::StepEnabled"};
3233 static const char* argumentList[] ={"QAbstractSpinBox::StepEnabled"};
3189 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3234 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3190 QAbstractSpinBox::StepEnabled returnValue;
3235 QAbstractSpinBox::StepEnabled returnValue;
3191 void* args[1] = {NULL};
3236 void* args[1] = {NULL};
3192 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3237 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3193 if (result) {
3238 if (result) {
3194 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3239 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3195 if (args[0]!=&returnValue) {
3240 if (args[0]!=&returnValue) {
3196 if (args[0]==NULL) {
3241 if (args[0]==NULL) {
3197 PythonQt::priv()->handleVirtualOverloadReturnError("stepEnabled", methodInfo, result);
3242 PythonQt::priv()->handleVirtualOverloadReturnError("stepEnabled", methodInfo, result);
3198 } else {
3243 } else {
3199 returnValue = *((QAbstractSpinBox::StepEnabled*)args[0]);
3244 returnValue = *((QAbstractSpinBox::StepEnabled*)args[0]);
3200 }
3245 }
3201 }
3246 }
3202 }
3247 }
3203 if (result) { Py_DECREF(result); }
3248 if (result) { Py_DECREF(result); }
3204 Py_DECREF(obj);
3249 Py_DECREF(obj);
3205 return returnValue;
3250 return returnValue;
3206 }
3251 }
3207 }
3252 }
3208 return QHexSpinBox::stepEnabled();
3253 return QHexSpinBox::stepEnabled();
3209 }
3254 }
3210 void PythonQtShell_QHexSpinBox::tabletEvent(QTabletEvent* arg__1)
3255 void PythonQtShell_QHexSpinBox::tabletEvent(QTabletEvent* arg__1)
3211 {
3256 {
3212 if (_wrapper) {
3257 if (_wrapper) {
3213 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
3258 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
3214 PyErr_Clear();
3259 PyErr_Clear();
3215 if (obj && !PythonQtSlotFunction_Check(obj)) {
3260 if (obj && !PythonQtSlotFunction_Check(obj)) {
3216 static const char* argumentList[] ={"" , "QTabletEvent*"};
3261 static const char* argumentList[] ={"" , "QTabletEvent*"};
3217 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3262 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3218 void* args[2] = {NULL, (void*)&arg__1};
3263 void* args[2] = {NULL, (void*)&arg__1};
3219 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3264 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3220 if (result) { Py_DECREF(result); }
3265 if (result) { Py_DECREF(result); }
3221 Py_DECREF(obj);
3266 Py_DECREF(obj);
3222 return;
3267 return;
3223 }
3268 }
3224 }
3269 }
3225 QHexSpinBox::tabletEvent(arg__1);
3270 QHexSpinBox::tabletEvent(arg__1);
3226 }
3271 }
3227 QString PythonQtShell_QHexSpinBox::textFromValue(int value) const
3272 QString PythonQtShell_QHexSpinBox::textFromValue(int value) const
3228 {
3273 {
3229 if (_wrapper) {
3274 if (_wrapper) {
3230 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "textFromValue");
3275 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "textFromValue");
3231 PyErr_Clear();
3276 PyErr_Clear();
3232 if (obj && !PythonQtSlotFunction_Check(obj)) {
3277 if (obj && !PythonQtSlotFunction_Check(obj)) {
3233 static const char* argumentList[] ={"QString" , "int"};
3278 static const char* argumentList[] ={"QString" , "int"};
3234 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3279 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3235 QString returnValue;
3280 QString returnValue;
3236 void* args[2] = {NULL, (void*)&value};
3281 void* args[2] = {NULL, (void*)&value};
3237 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3282 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3238 if (result) {
3283 if (result) {
3239 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3284 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3240 if (args[0]!=&returnValue) {
3285 if (args[0]!=&returnValue) {
3241 if (args[0]==NULL) {
3286 if (args[0]==NULL) {
3242 PythonQt::priv()->handleVirtualOverloadReturnError("textFromValue", methodInfo, result);
3287 PythonQt::priv()->handleVirtualOverloadReturnError("textFromValue", methodInfo, result);
3243 } else {
3288 } else {
3244 returnValue = *((QString*)args[0]);
3289 returnValue = *((QString*)args[0]);
3245 }
3290 }
3246 }
3291 }
3247 }
3292 }
3248 if (result) { Py_DECREF(result); }
3293 if (result) { Py_DECREF(result); }
3249 Py_DECREF(obj);
3294 Py_DECREF(obj);
3250 return returnValue;
3295 return returnValue;
3251 }
3296 }
3252 }
3297 }
3253 return QHexSpinBox::textFromValue(value);
3298 return QHexSpinBox::textFromValue(value);
3254 }
3299 }
3255 void PythonQtShell_QHexSpinBox::timerEvent(QTimerEvent* event)
3300 void PythonQtShell_QHexSpinBox::timerEvent(QTimerEvent* event)
3256 {
3301 {
3257 if (_wrapper) {
3302 if (_wrapper) {
3258 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
3303 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
3259 PyErr_Clear();
3304 PyErr_Clear();
3260 if (obj && !PythonQtSlotFunction_Check(obj)) {
3305 if (obj && !PythonQtSlotFunction_Check(obj)) {
3261 static const char* argumentList[] ={"" , "QTimerEvent*"};
3306 static const char* argumentList[] ={"" , "QTimerEvent*"};
3262 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3307 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3263 void* args[2] = {NULL, (void*)&event};
3308 void* args[2] = {NULL, (void*)&event};
3264 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3309 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3265 if (result) { Py_DECREF(result); }
3310 if (result) { Py_DECREF(result); }
3266 Py_DECREF(obj);
3311 Py_DECREF(obj);
3267 return;
3312 return;
3268 }
3313 }
3269 }
3314 }
3270 QHexSpinBox::timerEvent(event);
3315 QHexSpinBox::timerEvent(event);
3271 }
3316 }
3272 QValidator::State PythonQtShell_QHexSpinBox::validate(QString& input, int& pos) const
3317 QValidator::State PythonQtShell_QHexSpinBox::validate(QString& input, int& pos) const
3273 {
3318 {
3274 if (_wrapper) {
3319 if (_wrapper) {
3275 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "validate");
3320 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "validate");
3276 PyErr_Clear();
3321 PyErr_Clear();
3277 if (obj && !PythonQtSlotFunction_Check(obj)) {
3322 if (obj && !PythonQtSlotFunction_Check(obj)) {
3278 static const char* argumentList[] ={"QValidator::State" , "QString&" , "int&"};
3323 static const char* argumentList[] ={"QValidator::State" , "QString&" , "int&"};
3279 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3324 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3280 QValidator::State returnValue;
3325 QValidator::State returnValue;
3281 void* args[3] = {NULL, (void*)&input, (void*)&pos};
3326 void* args[3] = {NULL, (void*)&input, (void*)&pos};
3282 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3327 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3283 if (result) {
3328 if (result) {
3284 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3329 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3285 if (args[0]!=&returnValue) {
3330 if (args[0]!=&returnValue) {
3286 if (args[0]==NULL) {
3331 if (args[0]==NULL) {
3287 PythonQt::priv()->handleVirtualOverloadReturnError("validate", methodInfo, result);
3332 PythonQt::priv()->handleVirtualOverloadReturnError("validate", methodInfo, result);
3288 } else {
3333 } else {
3289 returnValue = *((QValidator::State*)args[0]);
3334 returnValue = *((QValidator::State*)args[0]);
3290 }
3335 }
3291 }
3336 }
3292 }
3337 }
3293 if (result) { Py_DECREF(result); }
3338 if (result) { Py_DECREF(result); }
3294 Py_DECREF(obj);
3339 Py_DECREF(obj);
3295 return returnValue;
3340 return returnValue;
3296 }
3341 }
3297 }
3342 }
3298 return QHexSpinBox::validate(input, pos);
3343 return QHexSpinBox::validate(input, pos);
3299 }
3344 }
3300 int PythonQtShell_QHexSpinBox::valueFromText(const QString& text) const
3345 int PythonQtShell_QHexSpinBox::valueFromText(const QString& text) const
3301 {
3346 {
3302 if (_wrapper) {
3347 if (_wrapper) {
3303 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "valueFromText");
3348 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "valueFromText");
3304 PyErr_Clear();
3349 PyErr_Clear();
3305 if (obj && !PythonQtSlotFunction_Check(obj)) {
3350 if (obj && !PythonQtSlotFunction_Check(obj)) {
3306 static const char* argumentList[] ={"int" , "const QString&"};
3351 static const char* argumentList[] ={"int" , "const QString&"};
3307 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3352 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3308 int returnValue;
3353 int returnValue;
3309 void* args[2] = {NULL, (void*)&text};
3354 void* args[2] = {NULL, (void*)&text};
3310 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3355 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3311 if (result) {
3356 if (result) {
3312 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3357 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3313 if (args[0]!=&returnValue) {
3358 if (args[0]!=&returnValue) {
3314 if (args[0]==NULL) {
3359 if (args[0]==NULL) {
3315 PythonQt::priv()->handleVirtualOverloadReturnError("valueFromText", methodInfo, result);
3360 PythonQt::priv()->handleVirtualOverloadReturnError("valueFromText", methodInfo, result);
3316 } else {
3361 } else {
3317 returnValue = *((int*)args[0]);
3362 returnValue = *((int*)args[0]);
3318 }
3363 }
3319 }
3364 }
3320 }
3365 }
3321 if (result) { Py_DECREF(result); }
3366 if (result) { Py_DECREF(result); }
3322 Py_DECREF(obj);
3367 Py_DECREF(obj);
3323 return returnValue;
3368 return returnValue;
3324 }
3369 }
3325 }
3370 }
3326 return QHexSpinBox::valueFromText(text);
3371 return QHexSpinBox::valueFromText(text);
3327 }
3372 }
3328 void PythonQtShell_QHexSpinBox::wheelEvent(QWheelEvent* event)
3373 void PythonQtShell_QHexSpinBox::wheelEvent(QWheelEvent* event)
3329 {
3374 {
3330 if (_wrapper) {
3375 if (_wrapper) {
3331 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
3376 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
3332 PyErr_Clear();
3377 PyErr_Clear();
3333 if (obj && !PythonQtSlotFunction_Check(obj)) {
3378 if (obj && !PythonQtSlotFunction_Check(obj)) {
3334 static const char* argumentList[] ={"" , "QWheelEvent*"};
3379 static const char* argumentList[] ={"" , "QWheelEvent*"};
3335 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3380 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3336 void* args[2] = {NULL, (void*)&event};
3381 void* args[2] = {NULL, (void*)&event};
3337 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3382 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3338 if (result) { Py_DECREF(result); }
3383 if (result) { Py_DECREF(result); }
3339 Py_DECREF(obj);
3384 Py_DECREF(obj);
3340 return;
3385 return;
3341 }
3386 }
3342 }
3387 }
3343 QHexSpinBox::wheelEvent(event);
3388 QHexSpinBox::wheelEvent(event);
3344 }
3389 }
3345 QHexSpinBox* PythonQtWrapper_QHexSpinBox::new_QHexSpinBox(QWidget* parent)
3390 QHexSpinBox* PythonQtWrapper_QHexSpinBox::new_QHexSpinBox(QWidget* parent)
3346 {
3391 {
3347 return new PythonQtShell_QHexSpinBox(parent); }
3392 return new PythonQtShell_QHexSpinBox(parent); }
3348
3393
3349 void PythonQtWrapper_QHexSpinBox::show(QHexSpinBox* theWrappedObject)
3394 void PythonQtWrapper_QHexSpinBox::show(QHexSpinBox* theWrappedObject)
3350 {
3395 {
3351 ( theWrappedObject->show());
3396 ( theWrappedObject->show());
3352 }
3397 }
3353
3398
3354 QString PythonQtWrapper_QHexSpinBox::textFromValue(QHexSpinBox* theWrappedObject, int value) const
3399 QString PythonQtWrapper_QHexSpinBox::textFromValue(QHexSpinBox* theWrappedObject, int value) const
3355 {
3400 {
3356 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_textFromValue(value));
3401 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_textFromValue(value));
3357 }
3402 }
3358
3403
3359 QValidator::State PythonQtWrapper_QHexSpinBox::validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const
3404 QValidator::State PythonQtWrapper_QHexSpinBox::validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const
3360 {
3405 {
3361 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_validate(input, pos));
3406 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_validate(input, pos));
3362 }
3407 }
3363
3408
3364 int PythonQtWrapper_QHexSpinBox::valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const
3409 int PythonQtWrapper_QHexSpinBox::valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const
3365 {
3410 {
3366 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_valueFromText(text));
3411 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_valueFromText(text));
3367 }
3412 }
3368
3413
3369
3414
3370
3415
3371 PythonQtShell_SocExplorerPlot::~PythonQtShell_SocExplorerPlot() {
3416 PythonQtShell_SocExplorerPlot::~PythonQtShell_SocExplorerPlot() {
3372 PythonQtPrivate* priv = PythonQt::priv();
3417 PythonQtPrivate* priv = PythonQt::priv();
3373 if (priv) { priv->shellClassDeleted(this); }
3418 if (priv) { priv->shellClassDeleted(this); }
3374 }
3419 }
3375 void PythonQtShell_SocExplorerPlot::actionEvent(QActionEvent* arg__1)
3420 void PythonQtShell_SocExplorerPlot::actionEvent(QActionEvent* arg__1)
3376 {
3421 {
3377 if (_wrapper) {
3422 if (_wrapper) {
3378 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
3423 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
3379 PyErr_Clear();
3424 PyErr_Clear();
3380 if (obj && !PythonQtSlotFunction_Check(obj)) {
3425 if (obj && !PythonQtSlotFunction_Check(obj)) {
3381 static const char* argumentList[] ={"" , "QActionEvent*"};
3426 static const char* argumentList[] ={"" , "QActionEvent*"};
3382 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3427 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3383 void* args[2] = {NULL, (void*)&arg__1};
3428 void* args[2] = {NULL, (void*)&arg__1};
3384 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3429 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3385 if (result) { Py_DECREF(result); }
3430 if (result) { Py_DECREF(result); }
3386 Py_DECREF(obj);
3431 Py_DECREF(obj);
3387 return;
3432 return;
3388 }
3433 }
3389 }
3434 }
3390 SocExplorerPlot::actionEvent(arg__1);
3435 SocExplorerPlot::actionEvent(arg__1);
3391 }
3436 }
3392 void PythonQtShell_SocExplorerPlot::changeEvent(QEvent* arg__1)
3437 void PythonQtShell_SocExplorerPlot::changeEvent(QEvent* arg__1)
3393 {
3438 {
3394 if (_wrapper) {
3439 if (_wrapper) {
3395 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
3440 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
3396 PyErr_Clear();
3441 PyErr_Clear();
3397 if (obj && !PythonQtSlotFunction_Check(obj)) {
3442 if (obj && !PythonQtSlotFunction_Check(obj)) {
3398 static const char* argumentList[] ={"" , "QEvent*"};
3443 static const char* argumentList[] ={"" , "QEvent*"};
3399 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3444 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3400 void* args[2] = {NULL, (void*)&arg__1};
3445 void* args[2] = {NULL, (void*)&arg__1};
3401 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3446 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3402 if (result) { Py_DECREF(result); }
3447 if (result) { Py_DECREF(result); }
3403 Py_DECREF(obj);
3448 Py_DECREF(obj);
3404 return;
3449 return;
3405 }
3450 }
3406 }
3451 }
3407 SocExplorerPlot::changeEvent(arg__1);
3452 SocExplorerPlot::changeEvent(arg__1);
3408 }
3453 }
3409 void PythonQtShell_SocExplorerPlot::childEvent(QChildEvent* arg__1)
3454 void PythonQtShell_SocExplorerPlot::childEvent(QChildEvent* arg__1)
3410 {
3455 {
3411 if (_wrapper) {
3456 if (_wrapper) {
3412 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
3457 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
3413 PyErr_Clear();
3458 PyErr_Clear();
3414 if (obj && !PythonQtSlotFunction_Check(obj)) {
3459 if (obj && !PythonQtSlotFunction_Check(obj)) {
3415 static const char* argumentList[] ={"" , "QChildEvent*"};
3460 static const char* argumentList[] ={"" , "QChildEvent*"};
3416 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3461 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3417 void* args[2] = {NULL, (void*)&arg__1};
3462 void* args[2] = {NULL, (void*)&arg__1};
3418 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3463 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3419 if (result) { Py_DECREF(result); }
3464 if (result) { Py_DECREF(result); }
3420 Py_DECREF(obj);
3465 Py_DECREF(obj);
3421 return;
3466 return;
3422 }
3467 }
3423 }
3468 }
3424 SocExplorerPlot::childEvent(arg__1);
3469 SocExplorerPlot::childEvent(arg__1);
3425 }
3470 }
3426 void PythonQtShell_SocExplorerPlot::closeEvent(QCloseEvent* arg__1)
3471 void PythonQtShell_SocExplorerPlot::closeEvent(QCloseEvent* arg__1)
3427 {
3472 {
3428 if (_wrapper) {
3473 if (_wrapper) {
3429 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
3474 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
3430 PyErr_Clear();
3475 PyErr_Clear();
3431 if (obj && !PythonQtSlotFunction_Check(obj)) {
3476 if (obj && !PythonQtSlotFunction_Check(obj)) {
3432 static const char* argumentList[] ={"" , "QCloseEvent*"};
3477 static const char* argumentList[] ={"" , "QCloseEvent*"};
3433 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3478 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3434 void* args[2] = {NULL, (void*)&arg__1};
3479 void* args[2] = {NULL, (void*)&arg__1};
3435 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3480 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3436 if (result) { Py_DECREF(result); }
3481 if (result) { Py_DECREF(result); }
3437 Py_DECREF(obj);
3482 Py_DECREF(obj);
3438 return;
3483 return;
3439 }
3484 }
3440 }
3485 }
3441 SocExplorerPlot::closeEvent(arg__1);
3486 SocExplorerPlot::closeEvent(arg__1);
3442 }
3487 }
3443 void PythonQtShell_SocExplorerPlot::contextMenuEvent(QContextMenuEvent* arg__1)
3488 void PythonQtShell_SocExplorerPlot::contextMenuEvent(QContextMenuEvent* arg__1)
3444 {
3489 {
3445 if (_wrapper) {
3490 if (_wrapper) {
3446 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
3491 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
3447 PyErr_Clear();
3492 PyErr_Clear();
3448 if (obj && !PythonQtSlotFunction_Check(obj)) {
3493 if (obj && !PythonQtSlotFunction_Check(obj)) {
3449 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
3494 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
3450 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3495 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3451 void* args[2] = {NULL, (void*)&arg__1};
3496 void* args[2] = {NULL, (void*)&arg__1};
3452 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3497 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3453 if (result) { Py_DECREF(result); }
3498 if (result) { Py_DECREF(result); }
3454 Py_DECREF(obj);
3499 Py_DECREF(obj);
3455 return;
3500 return;
3456 }
3501 }
3457 }
3502 }
3458 SocExplorerPlot::contextMenuEvent(arg__1);
3503 SocExplorerPlot::contextMenuEvent(arg__1);
3459 }
3504 }
3460 void PythonQtShell_SocExplorerPlot::customEvent(QEvent* arg__1)
3505 void PythonQtShell_SocExplorerPlot::customEvent(QEvent* arg__1)
3461 {
3506 {
3462 if (_wrapper) {
3507 if (_wrapper) {
3463 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
3508 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
3464 PyErr_Clear();
3509 PyErr_Clear();
3465 if (obj && !PythonQtSlotFunction_Check(obj)) {
3510 if (obj && !PythonQtSlotFunction_Check(obj)) {
3466 static const char* argumentList[] ={"" , "QEvent*"};
3511 static const char* argumentList[] ={"" , "QEvent*"};
3467 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3512 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3468 void* args[2] = {NULL, (void*)&arg__1};
3513 void* args[2] = {NULL, (void*)&arg__1};
3469 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3514 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3470 if (result) { Py_DECREF(result); }
3515 if (result) { Py_DECREF(result); }
3471 Py_DECREF(obj);
3516 Py_DECREF(obj);
3472 return;
3517 return;
3473 }
3518 }
3474 }
3519 }
3475 SocExplorerPlot::customEvent(arg__1);
3520 SocExplorerPlot::customEvent(arg__1);
3476 }
3521 }
3477 int PythonQtShell_SocExplorerPlot::devType() const
3522 int PythonQtShell_SocExplorerPlot::devType() const
3478 {
3523 {
3479 if (_wrapper) {
3524 if (_wrapper) {
3480 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
3525 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
3481 PyErr_Clear();
3526 PyErr_Clear();
3482 if (obj && !PythonQtSlotFunction_Check(obj)) {
3527 if (obj && !PythonQtSlotFunction_Check(obj)) {
3483 static const char* argumentList[] ={"int"};
3528 static const char* argumentList[] ={"int"};
3484 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3529 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3485 int returnValue;
3530 int returnValue;
3486 void* args[1] = {NULL};
3531 void* args[1] = {NULL};
3487 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3532 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3488 if (result) {
3533 if (result) {
3489 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3534 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3490 if (args[0]!=&returnValue) {
3535 if (args[0]!=&returnValue) {
3491 if (args[0]==NULL) {
3536 if (args[0]==NULL) {
3492 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
3537 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
3493 } else {
3538 } else {
3494 returnValue = *((int*)args[0]);
3539 returnValue = *((int*)args[0]);
3495 }
3540 }
3496 }
3541 }
3497 }
3542 }
3498 if (result) { Py_DECREF(result); }
3543 if (result) { Py_DECREF(result); }
3499 Py_DECREF(obj);
3544 Py_DECREF(obj);
3500 return returnValue;
3545 return returnValue;
3501 }
3546 }
3502 }
3547 }
3503 return SocExplorerPlot::devType();
3548 return SocExplorerPlot::devType();
3504 }
3549 }
3505 void PythonQtShell_SocExplorerPlot::dragEnterEvent(QDragEnterEvent* arg__1)
3550 void PythonQtShell_SocExplorerPlot::dragEnterEvent(QDragEnterEvent* arg__1)
3506 {
3551 {
3507 if (_wrapper) {
3552 if (_wrapper) {
3508 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
3553 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
3509 PyErr_Clear();
3554 PyErr_Clear();
3510 if (obj && !PythonQtSlotFunction_Check(obj)) {
3555 if (obj && !PythonQtSlotFunction_Check(obj)) {
3511 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
3556 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
3512 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3557 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3513 void* args[2] = {NULL, (void*)&arg__1};
3558 void* args[2] = {NULL, (void*)&arg__1};
3514 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3559 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3515 if (result) { Py_DECREF(result); }
3560 if (result) { Py_DECREF(result); }
3516 Py_DECREF(obj);
3561 Py_DECREF(obj);
3517 return;
3562 return;
3518 }
3563 }
3519 }
3564 }
3520 SocExplorerPlot::dragEnterEvent(arg__1);
3565 SocExplorerPlot::dragEnterEvent(arg__1);
3521 }
3566 }
3522 void PythonQtShell_SocExplorerPlot::dragLeaveEvent(QDragLeaveEvent* arg__1)
3567 void PythonQtShell_SocExplorerPlot::dragLeaveEvent(QDragLeaveEvent* arg__1)
3523 {
3568 {
3524 if (_wrapper) {
3569 if (_wrapper) {
3525 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
3570 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
3526 PyErr_Clear();
3571 PyErr_Clear();
3527 if (obj && !PythonQtSlotFunction_Check(obj)) {
3572 if (obj && !PythonQtSlotFunction_Check(obj)) {
3528 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
3573 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
3529 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3574 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3530 void* args[2] = {NULL, (void*)&arg__1};
3575 void* args[2] = {NULL, (void*)&arg__1};
3531 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3576 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3532 if (result) { Py_DECREF(result); }
3577 if (result) { Py_DECREF(result); }
3533 Py_DECREF(obj);
3578 Py_DECREF(obj);
3534 return;
3579 return;
3535 }
3580 }
3536 }
3581 }
3537 SocExplorerPlot::dragLeaveEvent(arg__1);
3582 SocExplorerPlot::dragLeaveEvent(arg__1);
3538 }
3583 }
3539 void PythonQtShell_SocExplorerPlot::dragMoveEvent(QDragMoveEvent* arg__1)
3584 void PythonQtShell_SocExplorerPlot::dragMoveEvent(QDragMoveEvent* arg__1)
3540 {
3585 {
3541 if (_wrapper) {
3586 if (_wrapper) {
3542 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
3587 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
3543 PyErr_Clear();
3588 PyErr_Clear();
3544 if (obj && !PythonQtSlotFunction_Check(obj)) {
3589 if (obj && !PythonQtSlotFunction_Check(obj)) {
3545 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
3590 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
3546 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3591 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3547 void* args[2] = {NULL, (void*)&arg__1};
3592 void* args[2] = {NULL, (void*)&arg__1};
3548 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3593 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3549 if (result) { Py_DECREF(result); }
3594 if (result) { Py_DECREF(result); }
3550 Py_DECREF(obj);
3595 Py_DECREF(obj);
3551 return;
3596 return;
3552 }
3597 }
3553 }
3598 }
3554 SocExplorerPlot::dragMoveEvent(arg__1);
3599 SocExplorerPlot::dragMoveEvent(arg__1);
3555 }
3600 }
3556 void PythonQtShell_SocExplorerPlot::dropEvent(QDropEvent* arg__1)
3601 void PythonQtShell_SocExplorerPlot::dropEvent(QDropEvent* arg__1)
3557 {
3602 {
3558 if (_wrapper) {
3603 if (_wrapper) {
3559 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
3604 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
3560 PyErr_Clear();
3605 PyErr_Clear();
3561 if (obj && !PythonQtSlotFunction_Check(obj)) {
3606 if (obj && !PythonQtSlotFunction_Check(obj)) {
3562 static const char* argumentList[] ={"" , "QDropEvent*"};
3607 static const char* argumentList[] ={"" , "QDropEvent*"};
3563 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3608 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3564 void* args[2] = {NULL, (void*)&arg__1};
3609 void* args[2] = {NULL, (void*)&arg__1};
3565 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3610 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3566 if (result) { Py_DECREF(result); }
3611 if (result) { Py_DECREF(result); }
3567 Py_DECREF(obj);
3612 Py_DECREF(obj);
3568 return;
3613 return;
3569 }
3614 }
3570 }
3615 }
3571 SocExplorerPlot::dropEvent(arg__1);
3616 SocExplorerPlot::dropEvent(arg__1);
3572 }
3617 }
3573 void PythonQtShell_SocExplorerPlot::enterEvent(QEvent* arg__1)
3618 void PythonQtShell_SocExplorerPlot::enterEvent(QEvent* arg__1)
3574 {
3619 {
3575 if (_wrapper) {
3620 if (_wrapper) {
3576 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
3621 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
3577 PyErr_Clear();
3622 PyErr_Clear();
3578 if (obj && !PythonQtSlotFunction_Check(obj)) {
3623 if (obj && !PythonQtSlotFunction_Check(obj)) {
3579 static const char* argumentList[] ={"" , "QEvent*"};
3624 static const char* argumentList[] ={"" , "QEvent*"};
3580 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3625 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3581 void* args[2] = {NULL, (void*)&arg__1};
3626 void* args[2] = {NULL, (void*)&arg__1};
3582 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3627 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3583 if (result) { Py_DECREF(result); }
3628 if (result) { Py_DECREF(result); }
3584 Py_DECREF(obj);
3629 Py_DECREF(obj);
3585 return;
3630 return;
3586 }
3631 }
3587 }
3632 }
3588 SocExplorerPlot::enterEvent(arg__1);
3633 SocExplorerPlot::enterEvent(arg__1);
3589 }
3634 }
3590 bool PythonQtShell_SocExplorerPlot::event(QEvent* arg__1)
3635 bool PythonQtShell_SocExplorerPlot::event(QEvent* arg__1)
3591 {
3636 {
3592 if (_wrapper) {
3637 if (_wrapper) {
3593 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
3638 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
3594 PyErr_Clear();
3639 PyErr_Clear();
3595 if (obj && !PythonQtSlotFunction_Check(obj)) {
3640 if (obj && !PythonQtSlotFunction_Check(obj)) {
3596 static const char* argumentList[] ={"bool" , "QEvent*"};
3641 static const char* argumentList[] ={"bool" , "QEvent*"};
3597 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3642 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3598 bool returnValue;
3643 bool returnValue;
3599 void* args[2] = {NULL, (void*)&arg__1};
3644 void* args[2] = {NULL, (void*)&arg__1};
3600 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3645 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3601 if (result) {
3646 if (result) {
3602 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3647 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3603 if (args[0]!=&returnValue) {
3648 if (args[0]!=&returnValue) {
3604 if (args[0]==NULL) {
3649 if (args[0]==NULL) {
3605 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
3650 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
3606 } else {
3651 } else {
3607 returnValue = *((bool*)args[0]);
3652 returnValue = *((bool*)args[0]);
3608 }
3653 }
3609 }
3654 }
3610 }
3655 }
3611 if (result) { Py_DECREF(result); }
3656 if (result) { Py_DECREF(result); }
3612 Py_DECREF(obj);
3657 Py_DECREF(obj);
3613 return returnValue;
3658 return returnValue;
3614 }
3659 }
3615 }
3660 }
3616 return SocExplorerPlot::event(arg__1);
3661 return SocExplorerPlot::event(arg__1);
3617 }
3662 }
3618 bool PythonQtShell_SocExplorerPlot::eventFilter(QObject* arg__1, QEvent* arg__2)
3663 bool PythonQtShell_SocExplorerPlot::eventFilter(QObject* arg__1, QEvent* arg__2)
3619 {
3664 {
3620 if (_wrapper) {
3665 if (_wrapper) {
3621 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
3666 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
3622 PyErr_Clear();
3667 PyErr_Clear();
3623 if (obj && !PythonQtSlotFunction_Check(obj)) {
3668 if (obj && !PythonQtSlotFunction_Check(obj)) {
3624 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
3669 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
3625 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3670 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3626 bool returnValue;
3671 bool returnValue;
3627 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
3672 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
3628 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3673 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3629 if (result) {
3674 if (result) {
3630 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3675 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3631 if (args[0]!=&returnValue) {
3676 if (args[0]!=&returnValue) {
3632 if (args[0]==NULL) {
3677 if (args[0]==NULL) {
3633 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
3678 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
3634 } else {
3679 } else {
3635 returnValue = *((bool*)args[0]);
3680 returnValue = *((bool*)args[0]);
3636 }
3681 }
3637 }
3682 }
3638 }
3683 }
3639 if (result) { Py_DECREF(result); }
3684 if (result) { Py_DECREF(result); }
3640 Py_DECREF(obj);
3685 Py_DECREF(obj);
3641 return returnValue;
3686 return returnValue;
3642 }
3687 }
3643 }
3688 }
3644 return SocExplorerPlot::eventFilter(arg__1, arg__2);
3689 return SocExplorerPlot::eventFilter(arg__1, arg__2);
3645 }
3690 }
3646 void PythonQtShell_SocExplorerPlot::focusInEvent(QFocusEvent* arg__1)
3691 void PythonQtShell_SocExplorerPlot::focusInEvent(QFocusEvent* arg__1)
3647 {
3692 {
3648 if (_wrapper) {
3693 if (_wrapper) {
3649 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
3694 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
3650 PyErr_Clear();
3695 PyErr_Clear();
3651 if (obj && !PythonQtSlotFunction_Check(obj)) {
3696 if (obj && !PythonQtSlotFunction_Check(obj)) {
3652 static const char* argumentList[] ={"" , "QFocusEvent*"};
3697 static const char* argumentList[] ={"" , "QFocusEvent*"};
3653 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3698 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3654 void* args[2] = {NULL, (void*)&arg__1};
3699 void* args[2] = {NULL, (void*)&arg__1};
3655 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3700 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3656 if (result) { Py_DECREF(result); }
3701 if (result) { Py_DECREF(result); }
3657 Py_DECREF(obj);
3702 Py_DECREF(obj);
3658 return;
3703 return;
3659 }
3704 }
3660 }
3705 }
3661 SocExplorerPlot::focusInEvent(arg__1);
3706 SocExplorerPlot::focusInEvent(arg__1);
3662 }
3707 }
3663 bool PythonQtShell_SocExplorerPlot::focusNextPrevChild(bool next)
3708 bool PythonQtShell_SocExplorerPlot::focusNextPrevChild(bool next)
3664 {
3709 {
3665 if (_wrapper) {
3710 if (_wrapper) {
3666 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
3711 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
3667 PyErr_Clear();
3712 PyErr_Clear();
3668 if (obj && !PythonQtSlotFunction_Check(obj)) {
3713 if (obj && !PythonQtSlotFunction_Check(obj)) {
3669 static const char* argumentList[] ={"bool" , "bool"};
3714 static const char* argumentList[] ={"bool" , "bool"};
3670 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3715 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3671 bool returnValue;
3716 bool returnValue;
3672 void* args[2] = {NULL, (void*)&next};
3717 void* args[2] = {NULL, (void*)&next};
3673 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3718 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3674 if (result) {
3719 if (result) {
3675 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3720 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3676 if (args[0]!=&returnValue) {
3721 if (args[0]!=&returnValue) {
3677 if (args[0]==NULL) {
3722 if (args[0]==NULL) {
3678 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
3723 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
3679 } else {
3724 } else {
3680 returnValue = *((bool*)args[0]);
3725 returnValue = *((bool*)args[0]);
3681 }
3726 }
3682 }
3727 }
3683 }
3728 }
3684 if (result) { Py_DECREF(result); }
3729 if (result) { Py_DECREF(result); }
3685 Py_DECREF(obj);
3730 Py_DECREF(obj);
3686 return returnValue;
3731 return returnValue;
3687 }
3732 }
3688 }
3733 }
3689 return SocExplorerPlot::focusNextPrevChild(next);
3734 return SocExplorerPlot::focusNextPrevChild(next);
3690 }
3735 }
3691 void PythonQtShell_SocExplorerPlot::focusOutEvent(QFocusEvent* arg__1)
3736 void PythonQtShell_SocExplorerPlot::focusOutEvent(QFocusEvent* arg__1)
3692 {
3737 {
3693 if (_wrapper) {
3738 if (_wrapper) {
3694 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
3739 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
3695 PyErr_Clear();
3740 PyErr_Clear();
3696 if (obj && !PythonQtSlotFunction_Check(obj)) {
3741 if (obj && !PythonQtSlotFunction_Check(obj)) {
3697 static const char* argumentList[] ={"" , "QFocusEvent*"};
3742 static const char* argumentList[] ={"" , "QFocusEvent*"};
3698 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3743 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3699 void* args[2] = {NULL, (void*)&arg__1};
3744 void* args[2] = {NULL, (void*)&arg__1};
3700 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3745 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3701 if (result) { Py_DECREF(result); }
3746 if (result) { Py_DECREF(result); }
3702 Py_DECREF(obj);
3747 Py_DECREF(obj);
3703 return;
3748 return;
3704 }
3749 }
3705 }
3750 }
3706 SocExplorerPlot::focusOutEvent(arg__1);
3751 SocExplorerPlot::focusOutEvent(arg__1);
3707 }
3752 }
3708 bool PythonQtShell_SocExplorerPlot::hasHeightForWidth() const
3753 bool PythonQtShell_SocExplorerPlot::hasHeightForWidth() const
3709 {
3754 {
3710 if (_wrapper) {
3755 if (_wrapper) {
3711 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
3756 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
3712 PyErr_Clear();
3757 PyErr_Clear();
3713 if (obj && !PythonQtSlotFunction_Check(obj)) {
3758 if (obj && !PythonQtSlotFunction_Check(obj)) {
3714 static const char* argumentList[] ={"bool"};
3759 static const char* argumentList[] ={"bool"};
3715 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3760 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3716 bool returnValue;
3761 bool returnValue;
3717 void* args[1] = {NULL};
3762 void* args[1] = {NULL};
3718 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3763 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3719 if (result) {
3764 if (result) {
3720 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3765 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3721 if (args[0]!=&returnValue) {
3766 if (args[0]!=&returnValue) {
3722 if (args[0]==NULL) {
3767 if (args[0]==NULL) {
3723 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
3768 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
3724 } else {
3769 } else {
3725 returnValue = *((bool*)args[0]);
3770 returnValue = *((bool*)args[0]);
3726 }
3771 }
3727 }
3772 }
3728 }
3773 }
3729 if (result) { Py_DECREF(result); }
3774 if (result) { Py_DECREF(result); }
3730 Py_DECREF(obj);
3775 Py_DECREF(obj);
3731 return returnValue;
3776 return returnValue;
3732 }
3777 }
3733 }
3778 }
3734 return SocExplorerPlot::hasHeightForWidth();
3779 return SocExplorerPlot::hasHeightForWidth();
3735 }
3780 }
3736 int PythonQtShell_SocExplorerPlot::heightForWidth(int arg__1) const
3781 int PythonQtShell_SocExplorerPlot::heightForWidth(int arg__1) const
3737 {
3782 {
3738 if (_wrapper) {
3783 if (_wrapper) {
3739 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
3784 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
3740 PyErr_Clear();
3785 PyErr_Clear();
3741 if (obj && !PythonQtSlotFunction_Check(obj)) {
3786 if (obj && !PythonQtSlotFunction_Check(obj)) {
3742 static const char* argumentList[] ={"int" , "int"};
3787 static const char* argumentList[] ={"int" , "int"};
3743 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3788 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3744 int returnValue;
3789 int returnValue;
3745 void* args[2] = {NULL, (void*)&arg__1};
3790 void* args[2] = {NULL, (void*)&arg__1};
3746 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3791 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3747 if (result) {
3792 if (result) {
3748 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3793 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3749 if (args[0]!=&returnValue) {
3794 if (args[0]!=&returnValue) {
3750 if (args[0]==NULL) {
3795 if (args[0]==NULL) {
3751 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
3796 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
3752 } else {
3797 } else {
3753 returnValue = *((int*)args[0]);
3798 returnValue = *((int*)args[0]);
3754 }
3799 }
3755 }
3800 }
3756 }
3801 }
3757 if (result) { Py_DECREF(result); }
3802 if (result) { Py_DECREF(result); }
3758 Py_DECREF(obj);
3803 Py_DECREF(obj);
3759 return returnValue;
3804 return returnValue;
3760 }
3805 }
3761 }
3806 }
3762 return SocExplorerPlot::heightForWidth(arg__1);
3807 return SocExplorerPlot::heightForWidth(arg__1);
3763 }
3808 }
3764 void PythonQtShell_SocExplorerPlot::hideEvent(QHideEvent* arg__1)
3809 void PythonQtShell_SocExplorerPlot::hideEvent(QHideEvent* arg__1)
3765 {
3810 {
3766 if (_wrapper) {
3811 if (_wrapper) {
3767 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
3812 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
3768 PyErr_Clear();
3813 PyErr_Clear();
3769 if (obj && !PythonQtSlotFunction_Check(obj)) {
3814 if (obj && !PythonQtSlotFunction_Check(obj)) {
3770 static const char* argumentList[] ={"" , "QHideEvent*"};
3815 static const char* argumentList[] ={"" , "QHideEvent*"};
3771 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3816 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3772 void* args[2] = {NULL, (void*)&arg__1};
3817 void* args[2] = {NULL, (void*)&arg__1};
3773 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3818 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3774 if (result) { Py_DECREF(result); }
3819 if (result) { Py_DECREF(result); }
3775 Py_DECREF(obj);
3820 Py_DECREF(obj);
3776 return;
3821 return;
3777 }
3822 }
3778 }
3823 }
3779 SocExplorerPlot::hideEvent(arg__1);
3824 SocExplorerPlot::hideEvent(arg__1);
3780 }
3825 }
3781 void PythonQtShell_SocExplorerPlot::initPainter(QPainter* painter) const
3826 void PythonQtShell_SocExplorerPlot::initPainter(QPainter* painter) const
3782 {
3827 {
3783 if (_wrapper) {
3828 if (_wrapper) {
3784 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
3829 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
3785 PyErr_Clear();
3830 PyErr_Clear();
3786 if (obj && !PythonQtSlotFunction_Check(obj)) {
3831 if (obj && !PythonQtSlotFunction_Check(obj)) {
3787 static const char* argumentList[] ={"" , "QPainter*"};
3832 static const char* argumentList[] ={"" , "QPainter*"};
3788 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3833 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3789 void* args[2] = {NULL, (void*)&painter};
3834 void* args[2] = {NULL, (void*)&painter};
3790 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3835 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3791 if (result) { Py_DECREF(result); }
3836 if (result) { Py_DECREF(result); }
3792 Py_DECREF(obj);
3837 Py_DECREF(obj);
3793 return;
3838 return;
3794 }
3839 }
3795 }
3840 }
3796 SocExplorerPlot::initPainter(painter);
3841 SocExplorerPlot::initPainter(painter);
3797 }
3842 }
3798 void PythonQtShell_SocExplorerPlot::inputMethodEvent(QInputMethodEvent* arg__1)
3843 void PythonQtShell_SocExplorerPlot::inputMethodEvent(QInputMethodEvent* arg__1)
3799 {
3844 {
3800 if (_wrapper) {
3845 if (_wrapper) {
3801 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
3846 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
3802 PyErr_Clear();
3847 PyErr_Clear();
3803 if (obj && !PythonQtSlotFunction_Check(obj)) {
3848 if (obj && !PythonQtSlotFunction_Check(obj)) {
3804 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
3849 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
3805 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3850 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3806 void* args[2] = {NULL, (void*)&arg__1};
3851 void* args[2] = {NULL, (void*)&arg__1};
3807 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3852 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3808 if (result) { Py_DECREF(result); }
3853 if (result) { Py_DECREF(result); }
3809 Py_DECREF(obj);
3854 Py_DECREF(obj);
3810 return;
3855 return;
3811 }
3856 }
3812 }
3857 }
3813 SocExplorerPlot::inputMethodEvent(arg__1);
3858 SocExplorerPlot::inputMethodEvent(arg__1);
3814 }
3859 }
3815 QVariant PythonQtShell_SocExplorerPlot::inputMethodQuery(Qt::InputMethodQuery arg__1) const
3860 QVariant PythonQtShell_SocExplorerPlot::inputMethodQuery(Qt::InputMethodQuery arg__1) const
3816 {
3861 {
3817 if (_wrapper) {
3862 if (_wrapper) {
3818 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
3863 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
3819 PyErr_Clear();
3864 PyErr_Clear();
3820 if (obj && !PythonQtSlotFunction_Check(obj)) {
3865 if (obj && !PythonQtSlotFunction_Check(obj)) {
3821 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
3866 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
3822 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3867 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3823 QVariant returnValue;
3868 QVariant returnValue;
3824 void* args[2] = {NULL, (void*)&arg__1};
3869 void* args[2] = {NULL, (void*)&arg__1};
3825 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3870 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3826 if (result) {
3871 if (result) {
3827 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3872 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3828 if (args[0]!=&returnValue) {
3873 if (args[0]!=&returnValue) {
3829 if (args[0]==NULL) {
3874 if (args[0]==NULL) {
3830 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
3875 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
3831 } else {
3876 } else {
3832 returnValue = *((QVariant*)args[0]);
3877 returnValue = *((QVariant*)args[0]);
3833 }
3878 }
3834 }
3879 }
3835 }
3880 }
3836 if (result) { Py_DECREF(result); }
3881 if (result) { Py_DECREF(result); }
3837 Py_DECREF(obj);
3882 Py_DECREF(obj);
3838 return returnValue;
3883 return returnValue;
3839 }
3884 }
3840 }
3885 }
3841 return SocExplorerPlot::inputMethodQuery(arg__1);
3886 return SocExplorerPlot::inputMethodQuery(arg__1);
3842 }
3887 }
3843 void PythonQtShell_SocExplorerPlot::keyPressEvent(QKeyEvent* arg__1)
3888 void PythonQtShell_SocExplorerPlot::keyPressEvent(QKeyEvent* arg__1)
3844 {
3889 {
3845 if (_wrapper) {
3890 if (_wrapper) {
3846 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
3891 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
3847 PyErr_Clear();
3892 PyErr_Clear();
3848 if (obj && !PythonQtSlotFunction_Check(obj)) {
3893 if (obj && !PythonQtSlotFunction_Check(obj)) {
3849 static const char* argumentList[] ={"" , "QKeyEvent*"};
3894 static const char* argumentList[] ={"" , "QKeyEvent*"};
3850 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3895 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3851 void* args[2] = {NULL, (void*)&arg__1};
3896 void* args[2] = {NULL, (void*)&arg__1};
3852 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3897 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3853 if (result) { Py_DECREF(result); }
3898 if (result) { Py_DECREF(result); }
3854 Py_DECREF(obj);
3899 Py_DECREF(obj);
3855 return;
3900 return;
3856 }
3901 }
3857 }
3902 }
3858 SocExplorerPlot::keyPressEvent(arg__1);
3903 SocExplorerPlot::keyPressEvent(arg__1);
3859 }
3904 }
3860 void PythonQtShell_SocExplorerPlot::keyReleaseEvent(QKeyEvent* arg__1)
3905 void PythonQtShell_SocExplorerPlot::keyReleaseEvent(QKeyEvent* arg__1)
3861 {
3906 {
3862 if (_wrapper) {
3907 if (_wrapper) {
3863 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
3908 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
3864 PyErr_Clear();
3909 PyErr_Clear();
3865 if (obj && !PythonQtSlotFunction_Check(obj)) {
3910 if (obj && !PythonQtSlotFunction_Check(obj)) {
3866 static const char* argumentList[] ={"" , "QKeyEvent*"};
3911 static const char* argumentList[] ={"" , "QKeyEvent*"};
3867 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3912 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3868 void* args[2] = {NULL, (void*)&arg__1};
3913 void* args[2] = {NULL, (void*)&arg__1};
3869 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3914 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3870 if (result) { Py_DECREF(result); }
3915 if (result) { Py_DECREF(result); }
3871 Py_DECREF(obj);
3916 Py_DECREF(obj);
3872 return;
3917 return;
3873 }
3918 }
3874 }
3919 }
3875 SocExplorerPlot::keyReleaseEvent(arg__1);
3920 SocExplorerPlot::keyReleaseEvent(arg__1);
3876 }
3921 }
3877 void PythonQtShell_SocExplorerPlot::leaveEvent(QEvent* arg__1)
3922 void PythonQtShell_SocExplorerPlot::leaveEvent(QEvent* arg__1)
3878 {
3923 {
3879 if (_wrapper) {
3924 if (_wrapper) {
3880 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
3925 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
3881 PyErr_Clear();
3926 PyErr_Clear();
3882 if (obj && !PythonQtSlotFunction_Check(obj)) {
3927 if (obj && !PythonQtSlotFunction_Check(obj)) {
3883 static const char* argumentList[] ={"" , "QEvent*"};
3928 static const char* argumentList[] ={"" , "QEvent*"};
3884 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3929 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3885 void* args[2] = {NULL, (void*)&arg__1};
3930 void* args[2] = {NULL, (void*)&arg__1};
3886 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3931 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3887 if (result) { Py_DECREF(result); }
3932 if (result) { Py_DECREF(result); }
3888 Py_DECREF(obj);
3933 Py_DECREF(obj);
3889 return;
3934 return;
3890 }
3935 }
3891 }
3936 }
3892 SocExplorerPlot::leaveEvent(arg__1);
3937 SocExplorerPlot::leaveEvent(arg__1);
3893 }
3938 }
3894 int PythonQtShell_SocExplorerPlot::metric(QPaintDevice::PaintDeviceMetric arg__1) const
3939 int PythonQtShell_SocExplorerPlot::metric(QPaintDevice::PaintDeviceMetric arg__1) const
3895 {
3940 {
3896 if (_wrapper) {
3941 if (_wrapper) {
3897 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
3942 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
3898 PyErr_Clear();
3943 PyErr_Clear();
3899 if (obj && !PythonQtSlotFunction_Check(obj)) {
3944 if (obj && !PythonQtSlotFunction_Check(obj)) {
3900 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
3945 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
3901 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3946 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3902 int returnValue;
3947 int returnValue;
3903 void* args[2] = {NULL, (void*)&arg__1};
3948 void* args[2] = {NULL, (void*)&arg__1};
3904 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3949 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3905 if (result) {
3950 if (result) {
3906 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3951 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3907 if (args[0]!=&returnValue) {
3952 if (args[0]!=&returnValue) {
3908 if (args[0]==NULL) {
3953 if (args[0]==NULL) {
3909 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
3954 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
3910 } else {
3955 } else {
3911 returnValue = *((int*)args[0]);
3956 returnValue = *((int*)args[0]);
3912 }
3957 }
3913 }
3958 }
3914 }
3959 }
3915 if (result) { Py_DECREF(result); }
3960 if (result) { Py_DECREF(result); }
3916 Py_DECREF(obj);
3961 Py_DECREF(obj);
3917 return returnValue;
3962 return returnValue;
3918 }
3963 }
3919 }
3964 }
3920 return SocExplorerPlot::metric(arg__1);
3965 return SocExplorerPlot::metric(arg__1);
3921 }
3966 }
3922 QSize PythonQtShell_SocExplorerPlot::minimumSizeHint() const
3967 QSize PythonQtShell_SocExplorerPlot::minimumSizeHint() const
3923 {
3968 {
3924 if (_wrapper) {
3969 if (_wrapper) {
3925 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
3970 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
3926 PyErr_Clear();
3971 PyErr_Clear();
3927 if (obj && !PythonQtSlotFunction_Check(obj)) {
3972 if (obj && !PythonQtSlotFunction_Check(obj)) {
3928 static const char* argumentList[] ={"QSize"};
3973 static const char* argumentList[] ={"QSize"};
3929 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3974 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3930 QSize returnValue;
3975 QSize returnValue;
3931 void* args[1] = {NULL};
3976 void* args[1] = {NULL};
3932 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3977 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3933 if (result) {
3978 if (result) {
3934 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3979 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3935 if (args[0]!=&returnValue) {
3980 if (args[0]!=&returnValue) {
3936 if (args[0]==NULL) {
3981 if (args[0]==NULL) {
3937 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
3982 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
3938 } else {
3983 } else {
3939 returnValue = *((QSize*)args[0]);
3984 returnValue = *((QSize*)args[0]);
3940 }
3985 }
3941 }
3986 }
3942 }
3987 }
3943 if (result) { Py_DECREF(result); }
3988 if (result) { Py_DECREF(result); }
3944 Py_DECREF(obj);
3989 Py_DECREF(obj);
3945 return returnValue;
3990 return returnValue;
3946 }
3991 }
3947 }
3992 }
3948 return SocExplorerPlot::minimumSizeHint();
3993 return SocExplorerPlot::minimumSizeHint();
3949 }
3994 }
3950 void PythonQtShell_SocExplorerPlot::mouseDoubleClickEvent(QMouseEvent* arg__1)
3995 void PythonQtShell_SocExplorerPlot::mouseDoubleClickEvent(QMouseEvent* arg__1)
3951 {
3996 {
3952 if (_wrapper) {
3997 if (_wrapper) {
3953 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
3998 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
3954 PyErr_Clear();
3999 PyErr_Clear();
3955 if (obj && !PythonQtSlotFunction_Check(obj)) {
4000 if (obj && !PythonQtSlotFunction_Check(obj)) {
3956 static const char* argumentList[] ={"" , "QMouseEvent*"};
4001 static const char* argumentList[] ={"" , "QMouseEvent*"};
3957 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4002 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3958 void* args[2] = {NULL, (void*)&arg__1};
4003 void* args[2] = {NULL, (void*)&arg__1};
3959 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4004 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3960 if (result) { Py_DECREF(result); }
4005 if (result) { Py_DECREF(result); }
3961 Py_DECREF(obj);
4006 Py_DECREF(obj);
3962 return;
4007 return;
3963 }
4008 }
3964 }
4009 }
3965 SocExplorerPlot::mouseDoubleClickEvent(arg__1);
4010 SocExplorerPlot::mouseDoubleClickEvent(arg__1);
3966 }
4011 }
3967 void PythonQtShell_SocExplorerPlot::mouseMoveEvent(QMouseEvent* arg__1)
4012 void PythonQtShell_SocExplorerPlot::mouseMoveEvent(QMouseEvent* arg__1)
3968 {
4013 {
3969 if (_wrapper) {
4014 if (_wrapper) {
3970 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
4015 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
3971 PyErr_Clear();
4016 PyErr_Clear();
3972 if (obj && !PythonQtSlotFunction_Check(obj)) {
4017 if (obj && !PythonQtSlotFunction_Check(obj)) {
3973 static const char* argumentList[] ={"" , "QMouseEvent*"};
4018 static const char* argumentList[] ={"" , "QMouseEvent*"};
3974 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4019 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3975 void* args[2] = {NULL, (void*)&arg__1};
4020 void* args[2] = {NULL, (void*)&arg__1};
3976 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4021 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3977 if (result) { Py_DECREF(result); }
4022 if (result) { Py_DECREF(result); }
3978 Py_DECREF(obj);
4023 Py_DECREF(obj);
3979 return;
4024 return;
3980 }
4025 }
3981 }
4026 }
3982 SocExplorerPlot::mouseMoveEvent(arg__1);
4027 SocExplorerPlot::mouseMoveEvent(arg__1);
3983 }
4028 }
3984 void PythonQtShell_SocExplorerPlot::mousePressEvent(QMouseEvent* arg__1)
4029 void PythonQtShell_SocExplorerPlot::mousePressEvent(QMouseEvent* arg__1)
3985 {
4030 {
3986 if (_wrapper) {
4031 if (_wrapper) {
3987 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
4032 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
3988 PyErr_Clear();
4033 PyErr_Clear();
3989 if (obj && !PythonQtSlotFunction_Check(obj)) {
4034 if (obj && !PythonQtSlotFunction_Check(obj)) {
3990 static const char* argumentList[] ={"" , "QMouseEvent*"};
4035 static const char* argumentList[] ={"" , "QMouseEvent*"};
3991 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4036 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3992 void* args[2] = {NULL, (void*)&arg__1};
4037 void* args[2] = {NULL, (void*)&arg__1};
3993 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4038 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3994 if (result) { Py_DECREF(result); }
4039 if (result) { Py_DECREF(result); }
3995 Py_DECREF(obj);
4040 Py_DECREF(obj);
3996 return;
4041 return;
3997 }
4042 }
3998 }
4043 }
3999 SocExplorerPlot::mousePressEvent(arg__1);
4044 SocExplorerPlot::mousePressEvent(arg__1);
4000 }
4045 }
4001 void PythonQtShell_SocExplorerPlot::mouseReleaseEvent(QMouseEvent* arg__1)
4046 void PythonQtShell_SocExplorerPlot::mouseReleaseEvent(QMouseEvent* arg__1)
4002 {
4047 {
4003 if (_wrapper) {
4048 if (_wrapper) {
4004 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
4049 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
4005 PyErr_Clear();
4050 PyErr_Clear();
4006 if (obj && !PythonQtSlotFunction_Check(obj)) {
4051 if (obj && !PythonQtSlotFunction_Check(obj)) {
4007 static const char* argumentList[] ={"" , "QMouseEvent*"};
4052 static const char* argumentList[] ={"" , "QMouseEvent*"};
4008 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4053 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4009 void* args[2] = {NULL, (void*)&arg__1};
4054 void* args[2] = {NULL, (void*)&arg__1};
4010 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4055 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4011 if (result) { Py_DECREF(result); }
4056 if (result) { Py_DECREF(result); }
4012 Py_DECREF(obj);
4057 Py_DECREF(obj);
4013 return;
4058 return;
4014 }
4059 }
4015 }
4060 }
4016 SocExplorerPlot::mouseReleaseEvent(arg__1);
4061 SocExplorerPlot::mouseReleaseEvent(arg__1);
4017 }
4062 }
4018 void PythonQtShell_SocExplorerPlot::moveEvent(QMoveEvent* arg__1)
4063 void PythonQtShell_SocExplorerPlot::moveEvent(QMoveEvent* arg__1)
4019 {
4064 {
4020 if (_wrapper) {
4065 if (_wrapper) {
4021 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
4066 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
4022 PyErr_Clear();
4067 PyErr_Clear();
4023 if (obj && !PythonQtSlotFunction_Check(obj)) {
4068 if (obj && !PythonQtSlotFunction_Check(obj)) {
4024 static const char* argumentList[] ={"" , "QMoveEvent*"};
4069 static const char* argumentList[] ={"" , "QMoveEvent*"};
4025 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4070 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4026 void* args[2] = {NULL, (void*)&arg__1};
4071 void* args[2] = {NULL, (void*)&arg__1};
4027 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4072 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4028 if (result) { Py_DECREF(result); }
4073 if (result) { Py_DECREF(result); }
4029 Py_DECREF(obj);
4074 Py_DECREF(obj);
4030 return;
4075 return;
4031 }
4076 }
4032 }
4077 }
4033 SocExplorerPlot::moveEvent(arg__1);
4078 SocExplorerPlot::moveEvent(arg__1);
4034 }
4079 }
4035 bool PythonQtShell_SocExplorerPlot::nativeEvent(const QByteArray& eventType, void* message, long* result)
4080 bool PythonQtShell_SocExplorerPlot::nativeEvent(const QByteArray& eventType, void* message, long* result)
4036 {
4081 {
4037 if (_wrapper) {
4082 if (_wrapper) {
4038 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
4083 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
4039 PyErr_Clear();
4084 PyErr_Clear();
4040 if (obj && !PythonQtSlotFunction_Check(obj)) {
4085 if (obj && !PythonQtSlotFunction_Check(obj)) {
4041 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
4086 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
4042 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
4087 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
4043 bool returnValue;
4088 bool returnValue;
4044 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
4089 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
4045 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4090 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4046 if (result) {
4091 if (result) {
4047 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4092 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4048 if (args[0]!=&returnValue) {
4093 if (args[0]!=&returnValue) {
4049 if (args[0]==NULL) {
4094 if (args[0]==NULL) {
4050 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
4095 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
4051 } else {
4096 } else {
4052 returnValue = *((bool*)args[0]);
4097 returnValue = *((bool*)args[0]);
4053 }
4098 }
4054 }
4099 }
4055 }
4100 }
4056 if (result) { Py_DECREF(result); }
4101 if (result) { Py_DECREF(result); }
4057 Py_DECREF(obj);
4102 Py_DECREF(obj);
4058 return returnValue;
4103 return returnValue;
4059 }
4104 }
4060 }
4105 }
4061 return SocExplorerPlot::nativeEvent(eventType, message, result);
4106 return SocExplorerPlot::nativeEvent(eventType, message, result);
4062 }
4107 }
4063 QPaintEngine* PythonQtShell_SocExplorerPlot::paintEngine() const
4108 QPaintEngine* PythonQtShell_SocExplorerPlot::paintEngine() const
4064 {
4109 {
4065 if (_wrapper) {
4110 if (_wrapper) {
4066 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
4111 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
4067 PyErr_Clear();
4112 PyErr_Clear();
4068 if (obj && !PythonQtSlotFunction_Check(obj)) {
4113 if (obj && !PythonQtSlotFunction_Check(obj)) {
4069 static const char* argumentList[] ={"QPaintEngine*"};
4114 static const char* argumentList[] ={"QPaintEngine*"};
4070 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4115 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4071 QPaintEngine* returnValue;
4116 QPaintEngine* returnValue;
4072 void* args[1] = {NULL};
4117 void* args[1] = {NULL};
4073 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4118 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4074 if (result) {
4119 if (result) {
4075 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4120 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4076 if (args[0]!=&returnValue) {
4121 if (args[0]!=&returnValue) {
4077 if (args[0]==NULL) {
4122 if (args[0]==NULL) {
4078 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
4123 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
4079 } else {
4124 } else {
4080 returnValue = *((QPaintEngine**)args[0]);
4125 returnValue = *((QPaintEngine**)args[0]);
4081 }
4126 }
4082 }
4127 }
4083 }
4128 }
4084 if (result) { Py_DECREF(result); }
4129 if (result) { Py_DECREF(result); }
4085 Py_DECREF(obj);
4130 Py_DECREF(obj);
4086 return returnValue;
4131 return returnValue;
4087 }
4132 }
4088 }
4133 }
4089 return SocExplorerPlot::paintEngine();
4134 return SocExplorerPlot::paintEngine();
4090 }
4135 }
4091 void PythonQtShell_SocExplorerPlot::paintEvent(QPaintEvent* arg__1)
4136 void PythonQtShell_SocExplorerPlot::paintEvent(QPaintEvent* arg__1)
4092 {
4137 {
4093 if (_wrapper) {
4138 if (_wrapper) {
4094 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
4139 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
4095 PyErr_Clear();
4140 PyErr_Clear();
4096 if (obj && !PythonQtSlotFunction_Check(obj)) {
4141 if (obj && !PythonQtSlotFunction_Check(obj)) {
4097 static const char* argumentList[] ={"" , "QPaintEvent*"};
4142 static const char* argumentList[] ={"" , "QPaintEvent*"};
4098 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4143 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4099 void* args[2] = {NULL, (void*)&arg__1};
4144 void* args[2] = {NULL, (void*)&arg__1};
4100 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4145 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4101 if (result) { Py_DECREF(result); }
4146 if (result) { Py_DECREF(result); }
4102 Py_DECREF(obj);
4147 Py_DECREF(obj);
4103 return;
4148 return;
4104 }
4149 }
4105 }
4150 }
4106 SocExplorerPlot::paintEvent(arg__1);
4151 SocExplorerPlot::paintEvent(arg__1);
4107 }
4152 }
4108 QPaintDevice* PythonQtShell_SocExplorerPlot::redirected(QPoint* offset) const
4153 QPaintDevice* PythonQtShell_SocExplorerPlot::redirected(QPoint* offset) const
4109 {
4154 {
4110 if (_wrapper) {
4155 if (_wrapper) {
4111 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
4156 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
4112 PyErr_Clear();
4157 PyErr_Clear();
4113 if (obj && !PythonQtSlotFunction_Check(obj)) {
4158 if (obj && !PythonQtSlotFunction_Check(obj)) {
4114 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
4159 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
4115 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4160 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4116 QPaintDevice* returnValue;
4161 QPaintDevice* returnValue;
4117 void* args[2] = {NULL, (void*)&offset};
4162 void* args[2] = {NULL, (void*)&offset};
4118 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4163 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4119 if (result) {
4164 if (result) {
4120 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4165 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4121 if (args[0]!=&returnValue) {
4166 if (args[0]!=&returnValue) {
4122 if (args[0]==NULL) {
4167 if (args[0]==NULL) {
4123 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
4168 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
4124 } else {
4169 } else {
4125 returnValue = *((QPaintDevice**)args[0]);
4170 returnValue = *((QPaintDevice**)args[0]);
4126 }
4171 }
4127 }
4172 }
4128 }
4173 }
4129 if (result) { Py_DECREF(result); }
4174 if (result) { Py_DECREF(result); }
4130 Py_DECREF(obj);
4175 Py_DECREF(obj);
4131 return returnValue;
4176 return returnValue;
4132 }
4177 }
4133 }
4178 }
4134 return SocExplorerPlot::redirected(offset);
4179 return SocExplorerPlot::redirected(offset);
4135 }
4180 }
4136 void PythonQtShell_SocExplorerPlot::resizeEvent(QResizeEvent* arg__1)
4181 void PythonQtShell_SocExplorerPlot::resizeEvent(QResizeEvent* arg__1)
4137 {
4182 {
4138 if (_wrapper) {
4183 if (_wrapper) {
4139 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
4184 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
4140 PyErr_Clear();
4185 PyErr_Clear();
4141 if (obj && !PythonQtSlotFunction_Check(obj)) {
4186 if (obj && !PythonQtSlotFunction_Check(obj)) {
4142 static const char* argumentList[] ={"" , "QResizeEvent*"};
4187 static const char* argumentList[] ={"" , "QResizeEvent*"};
4143 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4188 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4144 void* args[2] = {NULL, (void*)&arg__1};
4189 void* args[2] = {NULL, (void*)&arg__1};
4145 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4190 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4146 if (result) { Py_DECREF(result); }
4191 if (result) { Py_DECREF(result); }
4147 Py_DECREF(obj);
4192 Py_DECREF(obj);
4148 return;
4193 return;
4149 }
4194 }
4150 }
4195 }
4151 SocExplorerPlot::resizeEvent(arg__1);
4196 SocExplorerPlot::resizeEvent(arg__1);
4152 }
4197 }
4153 QPainter* PythonQtShell_SocExplorerPlot::sharedPainter() const
4198 QPainter* PythonQtShell_SocExplorerPlot::sharedPainter() const
4154 {
4199 {
4155 if (_wrapper) {
4200 if (_wrapper) {
4156 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
4201 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
4157 PyErr_Clear();
4202 PyErr_Clear();
4158 if (obj && !PythonQtSlotFunction_Check(obj)) {
4203 if (obj && !PythonQtSlotFunction_Check(obj)) {
4159 static const char* argumentList[] ={"QPainter*"};
4204 static const char* argumentList[] ={"QPainter*"};
4160 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4205 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4161 QPainter* returnValue;
4206 QPainter* returnValue;
4162 void* args[1] = {NULL};
4207 void* args[1] = {NULL};
4163 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4208 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4164 if (result) {
4209 if (result) {
4165 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4210 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4166 if (args[0]!=&returnValue) {
4211 if (args[0]!=&returnValue) {
4167 if (args[0]==NULL) {
4212 if (args[0]==NULL) {
4168 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
4213 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
4169 } else {
4214 } else {
4170 returnValue = *((QPainter**)args[0]);
4215 returnValue = *((QPainter**)args[0]);
4171 }
4216 }
4172 }
4217 }
4173 }
4218 }
4174 if (result) { Py_DECREF(result); }
4219 if (result) { Py_DECREF(result); }
4175 Py_DECREF(obj);
4220 Py_DECREF(obj);
4176 return returnValue;
4221 return returnValue;
4177 }
4222 }
4178 }
4223 }
4179 return SocExplorerPlot::sharedPainter();
4224 return SocExplorerPlot::sharedPainter();
4180 }
4225 }
4181 void PythonQtShell_SocExplorerPlot::showEvent(QShowEvent* arg__1)
4226 void PythonQtShell_SocExplorerPlot::showEvent(QShowEvent* arg__1)
4182 {
4227 {
4183 if (_wrapper) {
4228 if (_wrapper) {
4184 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
4229 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
4185 PyErr_Clear();
4230 PyErr_Clear();
4186 if (obj && !PythonQtSlotFunction_Check(obj)) {
4231 if (obj && !PythonQtSlotFunction_Check(obj)) {
4187 static const char* argumentList[] ={"" , "QShowEvent*"};
4232 static const char* argumentList[] ={"" , "QShowEvent*"};
4188 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4233 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4189 void* args[2] = {NULL, (void*)&arg__1};
4234 void* args[2] = {NULL, (void*)&arg__1};
4190 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4235 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4191 if (result) { Py_DECREF(result); }
4236 if (result) { Py_DECREF(result); }
4192 Py_DECREF(obj);
4237 Py_DECREF(obj);
4193 return;
4238 return;
4194 }
4239 }
4195 }
4240 }
4196 SocExplorerPlot::showEvent(arg__1);
4241 SocExplorerPlot::showEvent(arg__1);
4197 }
4242 }
4198 QSize PythonQtShell_SocExplorerPlot::sizeHint() const
4243 QSize PythonQtShell_SocExplorerPlot::sizeHint() const
4199 {
4244 {
4200 if (_wrapper) {
4245 if (_wrapper) {
4201 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
4246 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
4202 PyErr_Clear();
4247 PyErr_Clear();
4203 if (obj && !PythonQtSlotFunction_Check(obj)) {
4248 if (obj && !PythonQtSlotFunction_Check(obj)) {
4204 static const char* argumentList[] ={"QSize"};
4249 static const char* argumentList[] ={"QSize"};
4205 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4250 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4206 QSize returnValue;
4251 QSize returnValue;
4207 void* args[1] = {NULL};
4252 void* args[1] = {NULL};
4208 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4253 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4209 if (result) {
4254 if (result) {
4210 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4255 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4211 if (args[0]!=&returnValue) {
4256 if (args[0]!=&returnValue) {
4212 if (args[0]==NULL) {
4257 if (args[0]==NULL) {
4213 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
4258 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
4214 } else {
4259 } else {
4215 returnValue = *((QSize*)args[0]);
4260 returnValue = *((QSize*)args[0]);
4216 }
4261 }
4217 }
4262 }
4218 }
4263 }
4219 if (result) { Py_DECREF(result); }
4264 if (result) { Py_DECREF(result); }
4220 Py_DECREF(obj);
4265 Py_DECREF(obj);
4221 return returnValue;
4266 return returnValue;
4222 }
4267 }
4223 }
4268 }
4224 return SocExplorerPlot::sizeHint();
4269 return SocExplorerPlot::sizeHint();
4225 }
4270 }
4226 void PythonQtShell_SocExplorerPlot::tabletEvent(QTabletEvent* arg__1)
4271 void PythonQtShell_SocExplorerPlot::tabletEvent(QTabletEvent* arg__1)
4227 {
4272 {
4228 if (_wrapper) {
4273 if (_wrapper) {
4229 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
4274 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
4230 PyErr_Clear();
4275 PyErr_Clear();
4231 if (obj && !PythonQtSlotFunction_Check(obj)) {
4276 if (obj && !PythonQtSlotFunction_Check(obj)) {
4232 static const char* argumentList[] ={"" , "QTabletEvent*"};
4277 static const char* argumentList[] ={"" , "QTabletEvent*"};
4233 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4278 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4234 void* args[2] = {NULL, (void*)&arg__1};
4279 void* args[2] = {NULL, (void*)&arg__1};
4235 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4280 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4236 if (result) { Py_DECREF(result); }
4281 if (result) { Py_DECREF(result); }
4237 Py_DECREF(obj);
4282 Py_DECREF(obj);
4238 return;
4283 return;
4239 }
4284 }
4240 }
4285 }
4241 SocExplorerPlot::tabletEvent(arg__1);
4286 SocExplorerPlot::tabletEvent(arg__1);
4242 }
4287 }
4243 void PythonQtShell_SocExplorerPlot::timerEvent(QTimerEvent* arg__1)
4288 void PythonQtShell_SocExplorerPlot::timerEvent(QTimerEvent* arg__1)
4244 {
4289 {
4245 if (_wrapper) {
4290 if (_wrapper) {
4246 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
4291 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
4247 PyErr_Clear();
4292 PyErr_Clear();
4248 if (obj && !PythonQtSlotFunction_Check(obj)) {
4293 if (obj && !PythonQtSlotFunction_Check(obj)) {
4249 static const char* argumentList[] ={"" , "QTimerEvent*"};
4294 static const char* argumentList[] ={"" , "QTimerEvent*"};
4250 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4295 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4251 void* args[2] = {NULL, (void*)&arg__1};
4296 void* args[2] = {NULL, (void*)&arg__1};
4252 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4297 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4253 if (result) { Py_DECREF(result); }
4298 if (result) { Py_DECREF(result); }
4254 Py_DECREF(obj);
4299 Py_DECREF(obj);
4255 return;
4300 return;
4256 }
4301 }
4257 }
4302 }
4258 SocExplorerPlot::timerEvent(arg__1);
4303 SocExplorerPlot::timerEvent(arg__1);
4259 }
4304 }
4260 void PythonQtShell_SocExplorerPlot::wheelEvent(QWheelEvent* arg__1)
4305 void PythonQtShell_SocExplorerPlot::wheelEvent(QWheelEvent* arg__1)
4261 {
4306 {
4262 if (_wrapper) {
4307 if (_wrapper) {
4263 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
4308 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
4264 PyErr_Clear();
4309 PyErr_Clear();
4265 if (obj && !PythonQtSlotFunction_Check(obj)) {
4310 if (obj && !PythonQtSlotFunction_Check(obj)) {
4266 static const char* argumentList[] ={"" , "QWheelEvent*"};
4311 static const char* argumentList[] ={"" , "QWheelEvent*"};
4267 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4312 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4268 void* args[2] = {NULL, (void*)&arg__1};
4313 void* args[2] = {NULL, (void*)&arg__1};
4269 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4314 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4270 if (result) { Py_DECREF(result); }
4315 if (result) { Py_DECREF(result); }
4271 Py_DECREF(obj);
4316 Py_DECREF(obj);
4272 return;
4317 return;
4273 }
4318 }
4274 }
4319 }
4275 SocExplorerPlot::wheelEvent(arg__1);
4320 SocExplorerPlot::wheelEvent(arg__1);
4276 }
4321 }
4277 SocExplorerPlot* PythonQtWrapper_SocExplorerPlot::new_SocExplorerPlot(QWidget* parent)
4322 SocExplorerPlot* PythonQtWrapper_SocExplorerPlot::new_SocExplorerPlot(QWidget* parent)
4278 {
4323 {
4279 return new PythonQtShell_SocExplorerPlot(parent); }
4324 return new PythonQtShell_SocExplorerPlot(parent); }
4280
4325
4281 int PythonQtWrapper_SocExplorerPlot::addGraph(SocExplorerPlot* theWrappedObject)
4326 int PythonQtWrapper_SocExplorerPlot::addGraph(SocExplorerPlot* theWrappedObject)
4282 {
4327 {
4283 return ( theWrappedObject->addGraph());
4328 return ( theWrappedObject->addGraph());
4284 }
4329 }
4285
4330
4286 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4331 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4287 {
4332 {
4288 ( theWrappedObject->addGraphData(graphIndex, x, y));
4333 ( theWrappedObject->addGraphData(graphIndex, x, y));
4289 }
4334 }
4290
4335
4291 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y)
4336 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y)
4292 {
4337 {
4293 ( theWrappedObject->addGraphData(graphIndex, x, y));
4338 ( theWrappedObject->addGraphData(graphIndex, x, y));
4294 }
4339 }
4295
4340
4296 QPen PythonQtWrapper_SocExplorerPlot::getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex)
4341 QPen PythonQtWrapper_SocExplorerPlot::getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex)
4297 {
4342 {
4298 return ( theWrappedObject->getGraphPen(graphIndex));
4343 return ( theWrappedObject->getGraphPen(graphIndex));
4299 }
4344 }
4300
4345
4301 void PythonQtWrapper_SocExplorerPlot::keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4346 void PythonQtWrapper_SocExplorerPlot::keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4302 {
4347 {
4303 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyPressEvent(arg__1));
4348 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyPressEvent(arg__1));
4304 }
4349 }
4305
4350
4306 void PythonQtWrapper_SocExplorerPlot::keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4351 void PythonQtWrapper_SocExplorerPlot::keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4307 {
4352 {
4308 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyReleaseEvent(arg__1));
4353 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyReleaseEvent(arg__1));
4309 }
4354 }
4310
4355
4311 void PythonQtWrapper_SocExplorerPlot::mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4356 void PythonQtWrapper_SocExplorerPlot::mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4312 {
4357 {
4313 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseMoveEvent(arg__1));
4358 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseMoveEvent(arg__1));
4314 }
4359 }
4315
4360
4316 void PythonQtWrapper_SocExplorerPlot::mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4361 void PythonQtWrapper_SocExplorerPlot::mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4317 {
4362 {
4318 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mousePressEvent(arg__1));
4363 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mousePressEvent(arg__1));
4319 }
4364 }
4320
4365
4321 void PythonQtWrapper_SocExplorerPlot::mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4366 void PythonQtWrapper_SocExplorerPlot::mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4322 {
4367 {
4323 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseReleaseEvent(arg__1));
4368 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseReleaseEvent(arg__1));
4324 }
4369 }
4325
4370
4326 void PythonQtWrapper_SocExplorerPlot::rescaleAxis(SocExplorerPlot* theWrappedObject)
4371 void PythonQtWrapper_SocExplorerPlot::rescaleAxis(SocExplorerPlot* theWrappedObject)
4327 {
4372 {
4328 ( theWrappedObject->rescaleAxis());
4373 ( theWrappedObject->rescaleAxis());
4329 }
4374 }
4330
4375
4331 void PythonQtWrapper_SocExplorerPlot::setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable)
4376 void PythonQtWrapper_SocExplorerPlot::setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable)
4332 {
4377 {
4333 ( theWrappedObject->setAdaptativeSampling(graphIndex, enable));
4378 ( theWrappedObject->setAdaptativeSampling(graphIndex, enable));
4334 }
4379 }
4335
4380
4336 void PythonQtWrapper_SocExplorerPlot::setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4381 void PythonQtWrapper_SocExplorerPlot::setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4337 {
4382 {
4338 ( theWrappedObject->setGraphData(graphIndex, x, y));
4383 ( theWrappedObject->setGraphData(graphIndex, x, y));
4339 }
4384 }
4340
4385
4341 void PythonQtWrapper_SocExplorerPlot::setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle)
4386 void PythonQtWrapper_SocExplorerPlot::setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle)
4342 {
4387 {
4343 ( theWrappedObject->setGraphLineStyle(graphIndex, lineStyle));
4388 ( theWrappedObject->setGraphLineStyle(graphIndex, lineStyle));
4344 }
4389 }
4345
4390
4346 void PythonQtWrapper_SocExplorerPlot::setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name)
4391 void PythonQtWrapper_SocExplorerPlot::setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name)
4347 {
4392 {
4348 ( theWrappedObject->setGraphName(graphIndex, name));
4393 ( theWrappedObject->setGraphName(graphIndex, name));
4349 }
4394 }
4350
4395
4351 void PythonQtWrapper_SocExplorerPlot::setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen)
4396 void PythonQtWrapper_SocExplorerPlot::setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen)
4352 {
4397 {
4353 ( theWrappedObject->setGraphPen(graphIndex, pen));
4398 ( theWrappedObject->setGraphPen(graphIndex, pen));
4354 }
4399 }
4355
4400
4356 void PythonQtWrapper_SocExplorerPlot::setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle)
4401 void PythonQtWrapper_SocExplorerPlot::setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle)
4357 {
4402 {
4358 ( theWrappedObject->setGraphScatterStyle(graphIndex, scatterStyle));
4403 ( theWrappedObject->setGraphScatterStyle(graphIndex, scatterStyle));
4359 }
4404 }
4360
4405
4361 void PythonQtWrapper_SocExplorerPlot::setLegendFont(SocExplorerPlot* theWrappedObject, QFont font)
4406 void PythonQtWrapper_SocExplorerPlot::setLegendFont(SocExplorerPlot* theWrappedObject, QFont font)
4362 {
4407 {
4363 ( theWrappedObject->setLegendFont(font));
4408 ( theWrappedObject->setLegendFont(font));
4364 }
4409 }
4365
4410
4366 void PythonQtWrapper_SocExplorerPlot::setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font)
4411 void PythonQtWrapper_SocExplorerPlot::setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font)
4367 {
4412 {
4368 ( theWrappedObject->setLegendSelectedFont(font));
4413 ( theWrappedObject->setLegendSelectedFont(font));
4369 }
4414 }
4370
4415
4371 void PythonQtWrapper_SocExplorerPlot::setTitle(SocExplorerPlot* theWrappedObject, QString title)
4416 void PythonQtWrapper_SocExplorerPlot::setTitle(SocExplorerPlot* theWrappedObject, QString title)
4372 {
4417 {
4373 ( theWrappedObject->setTitle(title));
4418 ( theWrappedObject->setTitle(title));
4374 }
4419 }
4375
4420
4376 void PythonQtWrapper_SocExplorerPlot::setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4421 void PythonQtWrapper_SocExplorerPlot::setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4377 {
4422 {
4378 ( theWrappedObject->setXaxisLabel(label));
4423 ( theWrappedObject->setXaxisLabel(label));
4379 }
4424 }
4380
4425
4381 void PythonQtWrapper_SocExplorerPlot::setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4426 void PythonQtWrapper_SocExplorerPlot::setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4382 {
4427 {
4383 ( theWrappedObject->setXaxisRange(lower, upper));
4428 ( theWrappedObject->setXaxisRange(lower, upper));
4384 }
4429 }
4385
4430
4386 void PythonQtWrapper_SocExplorerPlot::setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4431 void PythonQtWrapper_SocExplorerPlot::setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4387 {
4432 {
4388 ( theWrappedObject->setYaxisLabel(label));
4433 ( theWrappedObject->setYaxisLabel(label));
4389 }
4434 }
4390
4435
4391 void PythonQtWrapper_SocExplorerPlot::setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4436 void PythonQtWrapper_SocExplorerPlot::setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4392 {
4437 {
4393 ( theWrappedObject->setYaxisRange(lower, upper));
4438 ( theWrappedObject->setYaxisRange(lower, upper));
4394 }
4439 }
4395
4440
4396 void PythonQtWrapper_SocExplorerPlot::show(SocExplorerPlot* theWrappedObject)
4441 void PythonQtWrapper_SocExplorerPlot::show(SocExplorerPlot* theWrappedObject)
4397 {
4442 {
4398 ( theWrappedObject->show());
4443 ( theWrappedObject->show());
4399 }
4444 }
4400
4445
4401 void PythonQtWrapper_SocExplorerPlot::wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1)
4446 void PythonQtWrapper_SocExplorerPlot::wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1)
4402 {
4447 {
4403 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_wheelEvent(arg__1));
4448 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_wheelEvent(arg__1));
4404 }
4449 }
4405
4450
4406
4451
4407
4452
4408 PythonQtShell_TCP_Terminal_Client::~PythonQtShell_TCP_Terminal_Client() {
4453 PythonQtShell_TCP_Terminal_Client::~PythonQtShell_TCP_Terminal_Client() {
4409 PythonQtPrivate* priv = PythonQt::priv();
4454 PythonQtPrivate* priv = PythonQt::priv();
4410 if (priv) { priv->shellClassDeleted(this); }
4455 if (priv) { priv->shellClassDeleted(this); }
4411 }
4456 }
4412 void PythonQtShell_TCP_Terminal_Client::childEvent(QChildEvent* arg__1)
4457 void PythonQtShell_TCP_Terminal_Client::childEvent(QChildEvent* arg__1)
4413 {
4458 {
4414 if (_wrapper) {
4459 if (_wrapper) {
4415 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
4460 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
4416 PyErr_Clear();
4461 PyErr_Clear();
4417 if (obj && !PythonQtSlotFunction_Check(obj)) {
4462 if (obj && !PythonQtSlotFunction_Check(obj)) {
4418 static const char* argumentList[] ={"" , "QChildEvent*"};
4463 static const char* argumentList[] ={"" , "QChildEvent*"};
4419 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4464 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4420 void* args[2] = {NULL, (void*)&arg__1};
4465 void* args[2] = {NULL, (void*)&arg__1};
4421 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4466 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4422 if (result) { Py_DECREF(result); }
4467 if (result) { Py_DECREF(result); }
4423 Py_DECREF(obj);
4468 Py_DECREF(obj);
4424 return;
4469 return;
4425 }
4470 }
4426 }
4471 }
4427 TCP_Terminal_Client::childEvent(arg__1);
4472 TCP_Terminal_Client::childEvent(arg__1);
4428 }
4473 }
4429 void PythonQtShell_TCP_Terminal_Client::customEvent(QEvent* arg__1)
4474 void PythonQtShell_TCP_Terminal_Client::customEvent(QEvent* arg__1)
4430 {
4475 {
4431 if (_wrapper) {
4476 if (_wrapper) {
4432 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
4477 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
4433 PyErr_Clear();
4478 PyErr_Clear();
4434 if (obj && !PythonQtSlotFunction_Check(obj)) {
4479 if (obj && !PythonQtSlotFunction_Check(obj)) {
4435 static const char* argumentList[] ={"" , "QEvent*"};
4480 static const char* argumentList[] ={"" , "QEvent*"};
4436 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4481 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4437 void* args[2] = {NULL, (void*)&arg__1};
4482 void* args[2] = {NULL, (void*)&arg__1};
4438 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4483 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4439 if (result) { Py_DECREF(result); }
4484 if (result) { Py_DECREF(result); }
4440 Py_DECREF(obj);
4485 Py_DECREF(obj);
4441 return;
4486 return;
4442 }
4487 }
4443 }
4488 }
4444 TCP_Terminal_Client::customEvent(arg__1);
4489 TCP_Terminal_Client::customEvent(arg__1);
4445 }
4490 }
4446 bool PythonQtShell_TCP_Terminal_Client::event(QEvent* arg__1)
4491 bool PythonQtShell_TCP_Terminal_Client::event(QEvent* arg__1)
4447 {
4492 {
4448 if (_wrapper) {
4493 if (_wrapper) {
4449 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
4494 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
4450 PyErr_Clear();
4495 PyErr_Clear();
4451 if (obj && !PythonQtSlotFunction_Check(obj)) {
4496 if (obj && !PythonQtSlotFunction_Check(obj)) {
4452 static const char* argumentList[] ={"bool" , "QEvent*"};
4497 static const char* argumentList[] ={"bool" , "QEvent*"};
4453 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4498 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4454 bool returnValue;
4499 bool returnValue;
4455 void* args[2] = {NULL, (void*)&arg__1};
4500 void* args[2] = {NULL, (void*)&arg__1};
4456 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4501 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4457 if (result) {
4502 if (result) {
4458 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4503 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4459 if (args[0]!=&returnValue) {
4504 if (args[0]!=&returnValue) {
4460 if (args[0]==NULL) {
4505 if (args[0]==NULL) {
4461 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
4506 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
4462 } else {
4507 } else {
4463 returnValue = *((bool*)args[0]);
4508 returnValue = *((bool*)args[0]);
4464 }
4509 }
4465 }
4510 }
4466 }
4511 }
4467 if (result) { Py_DECREF(result); }
4512 if (result) { Py_DECREF(result); }
4468 Py_DECREF(obj);
4513 Py_DECREF(obj);
4469 return returnValue;
4514 return returnValue;
4470 }
4515 }
4471 }
4516 }
4472 return TCP_Terminal_Client::event(arg__1);
4517 return TCP_Terminal_Client::event(arg__1);
4473 }
4518 }
4474 bool PythonQtShell_TCP_Terminal_Client::eventFilter(QObject* arg__1, QEvent* arg__2)
4519 bool PythonQtShell_TCP_Terminal_Client::eventFilter(QObject* arg__1, QEvent* arg__2)
4475 {
4520 {
4476 if (_wrapper) {
4521 if (_wrapper) {
4477 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
4522 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
4478 PyErr_Clear();
4523 PyErr_Clear();
4479 if (obj && !PythonQtSlotFunction_Check(obj)) {
4524 if (obj && !PythonQtSlotFunction_Check(obj)) {
4480 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4525 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4481 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4526 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4482 bool returnValue;
4527 bool returnValue;
4483 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
4528 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
4484 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4529 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4485 if (result) {
4530 if (result) {
4486 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4531 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4487 if (args[0]!=&returnValue) {
4532 if (args[0]!=&returnValue) {
4488 if (args[0]==NULL) {
4533 if (args[0]==NULL) {
4489 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
4534 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
4490 } else {
4535 } else {
4491 returnValue = *((bool*)args[0]);
4536 returnValue = *((bool*)args[0]);
4492 }
4537 }
4493 }
4538 }
4494 }
4539 }
4495 if (result) { Py_DECREF(result); }
4540 if (result) { Py_DECREF(result); }
4496 Py_DECREF(obj);
4541 Py_DECREF(obj);
4497 return returnValue;
4542 return returnValue;
4498 }
4543 }
4499 }
4544 }
4500 return TCP_Terminal_Client::eventFilter(arg__1, arg__2);
4545 return TCP_Terminal_Client::eventFilter(arg__1, arg__2);
4501 }
4546 }
4502 void PythonQtShell_TCP_Terminal_Client::timerEvent(QTimerEvent* arg__1)
4547 void PythonQtShell_TCP_Terminal_Client::timerEvent(QTimerEvent* arg__1)
4503 {
4548 {
4504 if (_wrapper) {
4549 if (_wrapper) {
4505 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
4550 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
4506 PyErr_Clear();
4551 PyErr_Clear();
4507 if (obj && !PythonQtSlotFunction_Check(obj)) {
4552 if (obj && !PythonQtSlotFunction_Check(obj)) {
4508 static const char* argumentList[] ={"" , "QTimerEvent*"};
4553 static const char* argumentList[] ={"" , "QTimerEvent*"};
4509 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4554 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4510 void* args[2] = {NULL, (void*)&arg__1};
4555 void* args[2] = {NULL, (void*)&arg__1};
4511 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4556 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4512 if (result) { Py_DECREF(result); }
4557 if (result) { Py_DECREF(result); }
4513 Py_DECREF(obj);
4558 Py_DECREF(obj);
4514 return;
4559 return;
4515 }
4560 }
4516 }
4561 }
4517 TCP_Terminal_Client::timerEvent(arg__1);
4562 TCP_Terminal_Client::timerEvent(arg__1);
4518 }
4563 }
4519 TCP_Terminal_Client* PythonQtWrapper_TCP_Terminal_Client::new_TCP_Terminal_Client(QObject* parent)
4564 TCP_Terminal_Client* PythonQtWrapper_TCP_Terminal_Client::new_TCP_Terminal_Client(QObject* parent)
4520 {
4565 {
4521 return new PythonQtShell_TCP_Terminal_Client(parent); }
4566 return new PythonQtShell_TCP_Terminal_Client(parent); }
4522
4567
4523 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject)
4568 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject)
4524 {
4569 {
4525 ( theWrappedObject->connectToServer());
4570 ( theWrappedObject->connectToServer());
4526 }
4571 }
4527
4572
4528 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port)
4573 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port)
4529 {
4574 {
4530 ( theWrappedObject->connectToServer(IP, port));
4575 ( theWrappedObject->connectToServer(IP, port));
4531 }
4576 }
4532
4577
4533 bool PythonQtWrapper_TCP_Terminal_Client::isConnected(TCP_Terminal_Client* theWrappedObject)
4578 bool PythonQtWrapper_TCP_Terminal_Client::isConnected(TCP_Terminal_Client* theWrappedObject)
4534 {
4579 {
4535 return ( theWrappedObject->isConnected());
4580 return ( theWrappedObject->isConnected());
4536 }
4581 }
4537
4582
4538 void PythonQtWrapper_TCP_Terminal_Client::sendText(TCP_Terminal_Client* theWrappedObject, const QString& text)
4583 void PythonQtWrapper_TCP_Terminal_Client::sendText(TCP_Terminal_Client* theWrappedObject, const QString& text)
4539 {
4584 {
4540 ( theWrappedObject->sendText(text));
4585 ( theWrappedObject->sendText(text));
4541 }
4586 }
4542
4587
4543 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject)
4588 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject)
4544 {
4589 {
4545 ( theWrappedObject->startServer());
4590 ( theWrappedObject->startServer());
4546 }
4591 }
4547
4592
4548 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject, int port)
4593 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject, int port)
4549 {
4594 {
4550 ( theWrappedObject->startServer(port));
4595 ( theWrappedObject->startServer(port));
4551 }
4596 }
4552
4597
4553
4598
4554
4599
4555 XByteArray* PythonQtWrapper_XByteArray::new_XByteArray()
4600 XByteArray* PythonQtWrapper_XByteArray::new_XByteArray()
4556 {
4601 {
4557 return new XByteArray(); }
4602 return new XByteArray(); }
4558
4603
4559 int PythonQtWrapper_XByteArray::addressOffset(XByteArray* theWrappedObject)
4604 int PythonQtWrapper_XByteArray::addressOffset(XByteArray* theWrappedObject)
4560 {
4605 {
4561 return ( theWrappedObject->addressOffset());
4606 return ( theWrappedObject->addressOffset());
4562 }
4607 }
4563
4608
4564 int PythonQtWrapper_XByteArray::addressWidth(XByteArray* theWrappedObject)
4609 int PythonQtWrapper_XByteArray::addressWidth(XByteArray* theWrappedObject)
4565 {
4610 {
4566 return ( theWrappedObject->addressWidth());
4611 return ( theWrappedObject->addressWidth());
4567 }
4612 }
4568
4613
4569 QChar PythonQtWrapper_XByteArray::asciiChar(XByteArray* theWrappedObject, int index)
4614 QChar PythonQtWrapper_XByteArray::asciiChar(XByteArray* theWrappedObject, int index)
4570 {
4615 {
4571 return ( theWrappedObject->asciiChar(index));
4616 return ( theWrappedObject->asciiChar(index));
4572 }
4617 }
4573
4618
4574 QByteArray* PythonQtWrapper_XByteArray::data(XByteArray* theWrappedObject)
4619 QByteArray* PythonQtWrapper_XByteArray::data(XByteArray* theWrappedObject)
4575 {
4620 {
4576 return &( theWrappedObject->data());
4621 return &( theWrappedObject->data());
4577 }
4622 }
4578
4623
4579 bool PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i)
4624 bool PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i)
4580 {
4625 {
4581 return ( theWrappedObject->dataChanged(i));
4626 return ( theWrappedObject->dataChanged(i));
4582 }
4627 }
4583
4628
4584 QByteArray PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i, int len)
4629 QByteArray PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i, int len)
4585 {
4630 {
4586 return ( theWrappedObject->dataChanged(i, len));
4631 return ( theWrappedObject->dataChanged(i, len));
4587 }
4632 }
4588
4633
4589 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, char ch)
4634 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, char ch)
4590 {
4635 {
4591 return &( theWrappedObject->insert(i, ch));
4636 return &( theWrappedObject->insert(i, ch));
4592 }
4637 }
4593
4638
4594 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, const QByteArray& ba)
4639 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, const QByteArray& ba)
4595 {
4640 {
4596 return &( theWrappedObject->insert(i, ba));
4641 return &( theWrappedObject->insert(i, ba));
4597 }
4642 }
4598
4643
4599 int PythonQtWrapper_XByteArray::realAddressNumbers(XByteArray* theWrappedObject)
4644 int PythonQtWrapper_XByteArray::realAddressNumbers(XByteArray* theWrappedObject)
4600 {
4645 {
4601 return ( theWrappedObject->realAddressNumbers());
4646 return ( theWrappedObject->realAddressNumbers());
4602 }
4647 }
4603
4648
4604 QByteArray* PythonQtWrapper_XByteArray::remove(XByteArray* theWrappedObject, int pos, int len)
4649 QByteArray* PythonQtWrapper_XByteArray::remove(XByteArray* theWrappedObject, int pos, int len)
4605 {
4650 {
4606 return &( theWrappedObject->remove(pos, len));
4651 return &( theWrappedObject->remove(pos, len));
4607 }
4652 }
4608
4653
4609 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, char ch)
4654 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, char ch)
4610 {
4655 {
4611 return &( theWrappedObject->replace(index, ch));
4656 return &( theWrappedObject->replace(index, ch));
4612 }
4657 }
4613
4658
4614 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, const QByteArray& ba)
4659 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, const QByteArray& ba)
4615 {
4660 {
4616 return &( theWrappedObject->replace(index, ba));
4661 return &( theWrappedObject->replace(index, ba));
4617 }
4662 }
4618
4663
4619 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba)
4664 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba)
4620 {
4665 {
4621 return &( theWrappedObject->replace(index, length, ba));
4666 return &( theWrappedObject->replace(index, length, ba));
4622 }
4667 }
4623
4668
4624 void PythonQtWrapper_XByteArray::setAddressOffset(XByteArray* theWrappedObject, int offset)
4669 void PythonQtWrapper_XByteArray::setAddressOffset(XByteArray* theWrappedObject, int offset)
4625 {
4670 {
4626 ( theWrappedObject->setAddressOffset(offset));
4671 ( theWrappedObject->setAddressOffset(offset));
4627 }
4672 }
4628
4673
4629 void PythonQtWrapper_XByteArray::setAddressWidth(XByteArray* theWrappedObject, int width)
4674 void PythonQtWrapper_XByteArray::setAddressWidth(XByteArray* theWrappedObject, int width)
4630 {
4675 {
4631 ( theWrappedObject->setAddressWidth(width));
4676 ( theWrappedObject->setAddressWidth(width));
4632 }
4677 }
4633
4678
4634 void PythonQtWrapper_XByteArray::setData(XByteArray* theWrappedObject, QByteArray data)
4679 void PythonQtWrapper_XByteArray::setData(XByteArray* theWrappedObject, QByteArray data)
4635 {
4680 {
4636 ( theWrappedObject->setData(data));
4681 ( theWrappedObject->setData(data));
4637 }
4682 }
4638
4683
4639 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, bool state)
4684 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, bool state)
4640 {
4685 {
4641 ( theWrappedObject->setDataChanged(i, state));
4686 ( theWrappedObject->setDataChanged(i, state));
4642 }
4687 }
4643
4688
4644 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state)
4689 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state)
4645 {
4690 {
4646 ( theWrappedObject->setDataChanged(i, state));
4691 ( theWrappedObject->setDataChanged(i, state));
4647 }
4692 }
4648
4693
4649 int PythonQtWrapper_XByteArray::size(XByteArray* theWrappedObject)
4694 int PythonQtWrapper_XByteArray::size(XByteArray* theWrappedObject)
4650 {
4695 {
4651 return ( theWrappedObject->size());
4696 return ( theWrappedObject->size());
4652 }
4697 }
4653
4698
4654 QString PythonQtWrapper_XByteArray::toRedableString(XByteArray* theWrappedObject, int start, int end)
4699 QString PythonQtWrapper_XByteArray::toRedableString(XByteArray* theWrappedObject, int start, int end)
4655 {
4700 {
4656 return ( theWrappedObject->toRedableString(start, end));
4701 return ( theWrappedObject->toRedableString(start, end));
4657 }
4702 }
4658
4703
4659
4704
4660
4705
4661 PythonQtShell_abstractExecFile::~PythonQtShell_abstractExecFile() {
4706 PythonQtShell_abstractExecFile::~PythonQtShell_abstractExecFile() {
4662 PythonQtPrivate* priv = PythonQt::priv();
4707 PythonQtPrivate* priv = PythonQt::priv();
4663 if (priv) { priv->shellClassDeleted(this); }
4708 if (priv) { priv->shellClassDeleted(this); }
4664 }
4709 }
4665 void PythonQtShell_abstractExecFile::childEvent(QChildEvent* arg__1)
4710 void PythonQtShell_abstractExecFile::childEvent(QChildEvent* arg__1)
4666 {
4711 {
4667 if (_wrapper) {
4712 if (_wrapper) {
4668 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
4713 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
4669 PyErr_Clear();
4714 PyErr_Clear();
4670 if (obj && !PythonQtSlotFunction_Check(obj)) {
4715 if (obj && !PythonQtSlotFunction_Check(obj)) {
4671 static const char* argumentList[] ={"" , "QChildEvent*"};
4716 static const char* argumentList[] ={"" , "QChildEvent*"};
4672 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4717 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4673 void* args[2] = {NULL, (void*)&arg__1};
4718 void* args[2] = {NULL, (void*)&arg__1};
4674 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4719 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4675 if (result) { Py_DECREF(result); }
4720 if (result) { Py_DECREF(result); }
4676 Py_DECREF(obj);
4721 Py_DECREF(obj);
4677 return;
4722 return;
4678 }
4723 }
4679 }
4724 }
4680 abstractExecFile::childEvent(arg__1);
4725 abstractExecFile::childEvent(arg__1);
4681 }
4726 }
4682 int PythonQtShell_abstractExecFile::closeFile()
4727 int PythonQtShell_abstractExecFile::closeFile()
4683 {
4728 {
4684 if (_wrapper) {
4729 if (_wrapper) {
4685 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
4730 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
4686 PyErr_Clear();
4731 PyErr_Clear();
4687 if (obj && !PythonQtSlotFunction_Check(obj)) {
4732 if (obj && !PythonQtSlotFunction_Check(obj)) {
4688 static const char* argumentList[] ={"int"};
4733 static const char* argumentList[] ={"int"};
4689 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4734 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4690 int returnValue;
4735 int returnValue;
4691 void* args[1] = {NULL};
4736 void* args[1] = {NULL};
4692 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4737 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4693 if (result) {
4738 if (result) {
4694 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4739 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4695 if (args[0]!=&returnValue) {
4740 if (args[0]!=&returnValue) {
4696 if (args[0]==NULL) {
4741 if (args[0]==NULL) {
4697 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
4742 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
4698 } else {
4743 } else {
4699 returnValue = *((int*)args[0]);
4744 returnValue = *((int*)args[0]);
4700 }
4745 }
4701 }
4746 }
4702 }
4747 }
4703 if (result) { Py_DECREF(result); }
4748 if (result) { Py_DECREF(result); }
4704 Py_DECREF(obj);
4749 Py_DECREF(obj);
4705 return returnValue;
4750 return returnValue;
4706 }
4751 }
4707 }
4752 }
4708 return int();
4753 return int();
4709 }
4754 }
4710 void PythonQtShell_abstractExecFile::customEvent(QEvent* arg__1)
4755 void PythonQtShell_abstractExecFile::customEvent(QEvent* arg__1)
4711 {
4756 {
4712 if (_wrapper) {
4757 if (_wrapper) {
4713 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
4758 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
4714 PyErr_Clear();
4759 PyErr_Clear();
4715 if (obj && !PythonQtSlotFunction_Check(obj)) {
4760 if (obj && !PythonQtSlotFunction_Check(obj)) {
4716 static const char* argumentList[] ={"" , "QEvent*"};
4761 static const char* argumentList[] ={"" , "QEvent*"};
4717 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4762 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4718 void* args[2] = {NULL, (void*)&arg__1};
4763 void* args[2] = {NULL, (void*)&arg__1};
4719 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4764 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4720 if (result) { Py_DECREF(result); }
4765 if (result) { Py_DECREF(result); }
4721 Py_DECREF(obj);
4766 Py_DECREF(obj);
4722 return;
4767 return;
4723 }
4768 }
4724 }
4769 }
4725 abstractExecFile::customEvent(arg__1);
4770 abstractExecFile::customEvent(arg__1);
4726 }
4771 }
4727 bool PythonQtShell_abstractExecFile::event(QEvent* arg__1)
4772 bool PythonQtShell_abstractExecFile::event(QEvent* arg__1)
4728 {
4773 {
4729 if (_wrapper) {
4774 if (_wrapper) {
4730 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
4775 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
4731 PyErr_Clear();
4776 PyErr_Clear();
4732 if (obj && !PythonQtSlotFunction_Check(obj)) {
4777 if (obj && !PythonQtSlotFunction_Check(obj)) {
4733 static const char* argumentList[] ={"bool" , "QEvent*"};
4778 static const char* argumentList[] ={"bool" , "QEvent*"};
4734 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4779 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4735 bool returnValue;
4780 bool returnValue;
4736 void* args[2] = {NULL, (void*)&arg__1};
4781 void* args[2] = {NULL, (void*)&arg__1};
4737 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4782 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4738 if (result) {
4783 if (result) {
4739 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4784 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4740 if (args[0]!=&returnValue) {
4785 if (args[0]!=&returnValue) {
4741 if (args[0]==NULL) {
4786 if (args[0]==NULL) {
4742 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
4787 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
4743 } else {
4788 } else {
4744 returnValue = *((bool*)args[0]);
4789 returnValue = *((bool*)args[0]);
4745 }
4790 }
4746 }
4791 }
4747 }
4792 }
4748 if (result) { Py_DECREF(result); }
4793 if (result) { Py_DECREF(result); }
4749 Py_DECREF(obj);
4794 Py_DECREF(obj);
4750 return returnValue;
4795 return returnValue;
4751 }
4796 }
4752 }
4797 }
4753 return abstractExecFile::event(arg__1);
4798 return abstractExecFile::event(arg__1);
4754 }
4799 }
4755 bool PythonQtShell_abstractExecFile::eventFilter(QObject* arg__1, QEvent* arg__2)
4800 bool PythonQtShell_abstractExecFile::eventFilter(QObject* arg__1, QEvent* arg__2)
4756 {
4801 {
4757 if (_wrapper) {
4802 if (_wrapper) {
4758 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
4803 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
4759 PyErr_Clear();
4804 PyErr_Clear();
4760 if (obj && !PythonQtSlotFunction_Check(obj)) {
4805 if (obj && !PythonQtSlotFunction_Check(obj)) {
4761 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4806 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4762 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4807 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4763 bool returnValue;
4808 bool returnValue;
4764 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
4809 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
4765 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4810 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4766 if (result) {
4811 if (result) {
4767 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4812 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4768 if (args[0]!=&returnValue) {
4813 if (args[0]!=&returnValue) {
4769 if (args[0]==NULL) {
4814 if (args[0]==NULL) {
4770 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
4815 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
4771 } else {
4816 } else {
4772 returnValue = *((bool*)args[0]);
4817 returnValue = *((bool*)args[0]);
4773 }
4818 }
4774 }
4819 }
4775 }
4820 }
4776 if (result) { Py_DECREF(result); }
4821 if (result) { Py_DECREF(result); }
4777 Py_DECREF(obj);
4822 Py_DECREF(obj);
4778 return returnValue;
4823 return returnValue;
4779 }
4824 }
4780 }
4825 }
4781 return abstractExecFile::eventFilter(arg__1, arg__2);
4826 return abstractExecFile::eventFilter(arg__1, arg__2);
4782 }
4827 }
4783 QList<codeFragment* > PythonQtShell_abstractExecFile::getFragments()
4828 QList<codeFragment* > PythonQtShell_abstractExecFile::getFragments()
4784 {
4829 {
4785 if (_wrapper) {
4830 if (_wrapper) {
4786 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
4831 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
4787 PyErr_Clear();
4832 PyErr_Clear();
4788 if (obj && !PythonQtSlotFunction_Check(obj)) {
4833 if (obj && !PythonQtSlotFunction_Check(obj)) {
4789 static const char* argumentList[] ={"QList<codeFragment* >"};
4834 static const char* argumentList[] ={"QList<codeFragment* >"};
4790 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4835 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4791 QList<codeFragment* > returnValue;
4836 QList<codeFragment* > returnValue;
4792 void* args[1] = {NULL};
4837 void* args[1] = {NULL};
4793 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4838 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4794 if (result) {
4839 if (result) {
4795 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4840 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4796 if (args[0]!=&returnValue) {
4841 if (args[0]!=&returnValue) {
4797 if (args[0]==NULL) {
4842 if (args[0]==NULL) {
4798 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
4843 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
4799 } else {
4844 } else {
4800 returnValue = *((QList<codeFragment* >*)args[0]);
4845 returnValue = *((QList<codeFragment* >*)args[0]);
4801 }
4846 }
4802 }
4847 }
4803 }
4848 }
4804 if (result) { Py_DECREF(result); }
4849 if (result) { Py_DECREF(result); }
4805 Py_DECREF(obj);
4850 Py_DECREF(obj);
4806 return returnValue;
4851 return returnValue;
4807 }
4852 }
4808 }
4853 }
4809 return QList<codeFragment* >();
4854 return QList<codeFragment* >();
4810 }
4855 }
4811 bool PythonQtShell_abstractExecFile::isopened()
4856 bool PythonQtShell_abstractExecFile::isopened()
4812 {
4857 {
4813 if (_wrapper) {
4858 if (_wrapper) {
4814 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
4859 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
4815 PyErr_Clear();
4860 PyErr_Clear();
4816 if (obj && !PythonQtSlotFunction_Check(obj)) {
4861 if (obj && !PythonQtSlotFunction_Check(obj)) {
4817 static const char* argumentList[] ={"bool"};
4862 static const char* argumentList[] ={"bool"};
4818 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4863 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4819 bool returnValue;
4864 bool returnValue;
4820 void* args[1] = {NULL};
4865 void* args[1] = {NULL};
4821 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4866 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4822 if (result) {
4867 if (result) {
4823 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4868 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4824 if (args[0]!=&returnValue) {
4869 if (args[0]!=&returnValue) {
4825 if (args[0]==NULL) {
4870 if (args[0]==NULL) {
4826 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
4871 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
4827 } else {
4872 } else {
4828 returnValue = *((bool*)args[0]);
4873 returnValue = *((bool*)args[0]);
4829 }
4874 }
4830 }
4875 }
4831 }
4876 }
4832 if (result) { Py_DECREF(result); }
4877 if (result) { Py_DECREF(result); }
4833 Py_DECREF(obj);
4878 Py_DECREF(obj);
4834 return returnValue;
4879 return returnValue;
4835 }
4880 }
4836 }
4881 }
4837 return bool();
4882 return bool();
4838 }
4883 }
4839 bool PythonQtShell_abstractExecFile::openFile(const QString& File)
4884 bool PythonQtShell_abstractExecFile::openFile(const QString& File)
4840 {
4885 {
4841 if (_wrapper) {
4886 if (_wrapper) {
4842 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
4887 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
4843 PyErr_Clear();
4888 PyErr_Clear();
4844 if (obj && !PythonQtSlotFunction_Check(obj)) {
4889 if (obj && !PythonQtSlotFunction_Check(obj)) {
4845 static const char* argumentList[] ={"bool" , "const QString&"};
4890 static const char* argumentList[] ={"bool" , "const QString&"};
4846 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4891 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4847 bool returnValue;
4892 bool returnValue;
4848 void* args[2] = {NULL, (void*)&File};
4893 void* args[2] = {NULL, (void*)&File};
4849 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4894 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4850 if (result) {
4895 if (result) {
4851 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4896 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4852 if (args[0]!=&returnValue) {
4897 if (args[0]!=&returnValue) {
4853 if (args[0]==NULL) {
4898 if (args[0]==NULL) {
4854 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
4899 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
4855 } else {
4900 } else {
4856 returnValue = *((bool*)args[0]);
4901 returnValue = *((bool*)args[0]);
4857 }
4902 }
4858 }
4903 }
4859 }
4904 }
4860 if (result) { Py_DECREF(result); }
4905 if (result) { Py_DECREF(result); }
4861 Py_DECREF(obj);
4906 Py_DECREF(obj);
4862 return returnValue;
4907 return returnValue;
4863 }
4908 }
4864 }
4909 }
4865 return bool();
4910 return bool();
4866 }
4911 }
4867 void PythonQtShell_abstractExecFile::timerEvent(QTimerEvent* arg__1)
4912 void PythonQtShell_abstractExecFile::timerEvent(QTimerEvent* arg__1)
4868 {
4913 {
4869 if (_wrapper) {
4914 if (_wrapper) {
4870 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
4915 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
4871 PyErr_Clear();
4916 PyErr_Clear();
4872 if (obj && !PythonQtSlotFunction_Check(obj)) {
4917 if (obj && !PythonQtSlotFunction_Check(obj)) {
4873 static const char* argumentList[] ={"" , "QTimerEvent*"};
4918 static const char* argumentList[] ={"" , "QTimerEvent*"};
4874 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4919 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4875 void* args[2] = {NULL, (void*)&arg__1};
4920 void* args[2] = {NULL, (void*)&arg__1};
4876 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4921 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4877 if (result) { Py_DECREF(result); }
4922 if (result) { Py_DECREF(result); }
4878 Py_DECREF(obj);
4923 Py_DECREF(obj);
4879 return;
4924 return;
4880 }
4925 }
4881 }
4926 }
4882 abstractExecFile::timerEvent(arg__1);
4927 abstractExecFile::timerEvent(arg__1);
4883 }
4928 }
4884 abstractExecFile* PythonQtWrapper_abstractExecFile::new_abstractExecFile()
4929 abstractExecFile* PythonQtWrapper_abstractExecFile::new_abstractExecFile()
4885 {
4930 {
4886 return new PythonQtShell_abstractExecFile(); }
4931 return new PythonQtShell_abstractExecFile(); }
4887
4932
4888
4933
4889
4934
4890 PythonQtShell_codeFragment::~PythonQtShell_codeFragment() {
4935 PythonQtShell_codeFragment::~PythonQtShell_codeFragment() {
4891 PythonQtPrivate* priv = PythonQt::priv();
4936 PythonQtPrivate* priv = PythonQt::priv();
4892 if (priv) { priv->shellClassDeleted(this); }
4937 if (priv) { priv->shellClassDeleted(this); }
4893 }
4938 }
4894 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment()
4939 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment()
4895 {
4940 {
4896 return new PythonQtShell_codeFragment(); }
4941 return new PythonQtShell_codeFragment(); }
4897
4942
4898 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment(char* data, unsigned int size, unsigned int address)
4943 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment(char* data, unsigned int size, unsigned int address)
4899 {
4944 {
4900 return new PythonQtShell_codeFragment(data, size, address); }
4945 return new PythonQtShell_codeFragment(data, size, address); }
4901
4946
4902
4947
4903
4948
4904 PythonQtShell_elfFileWidget::~PythonQtShell_elfFileWidget() {
4949 PythonQtShell_elfFileWidget::~PythonQtShell_elfFileWidget() {
4905 PythonQtPrivate* priv = PythonQt::priv();
4950 PythonQtPrivate* priv = PythonQt::priv();
4906 if (priv) { priv->shellClassDeleted(this); }
4951 if (priv) { priv->shellClassDeleted(this); }
4907 }
4952 }
4908 void PythonQtShell_elfFileWidget::actionEvent(QActionEvent* arg__1)
4953 void PythonQtShell_elfFileWidget::actionEvent(QActionEvent* arg__1)
4909 {
4954 {
4910 if (_wrapper) {
4955 if (_wrapper) {
4911 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
4956 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
4912 PyErr_Clear();
4957 PyErr_Clear();
4913 if (obj && !PythonQtSlotFunction_Check(obj)) {
4958 if (obj && !PythonQtSlotFunction_Check(obj)) {
4914 static const char* argumentList[] ={"" , "QActionEvent*"};
4959 static const char* argumentList[] ={"" , "QActionEvent*"};
4915 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4960 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4916 void* args[2] = {NULL, (void*)&arg__1};
4961 void* args[2] = {NULL, (void*)&arg__1};
4917 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4962 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4918 if (result) { Py_DECREF(result); }
4963 if (result) { Py_DECREF(result); }
4919 Py_DECREF(obj);
4964 Py_DECREF(obj);
4920 return;
4965 return;
4921 }
4966 }
4922 }
4967 }
4923 elfFileWidget::actionEvent(arg__1);
4968 elfFileWidget::actionEvent(arg__1);
4924 }
4969 }
4925 void PythonQtShell_elfFileWidget::changeEvent(QEvent* arg__1)
4970 void PythonQtShell_elfFileWidget::changeEvent(QEvent* arg__1)
4926 {
4971 {
4927 if (_wrapper) {
4972 if (_wrapper) {
4928 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
4973 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
4929 PyErr_Clear();
4974 PyErr_Clear();
4930 if (obj && !PythonQtSlotFunction_Check(obj)) {
4975 if (obj && !PythonQtSlotFunction_Check(obj)) {
4931 static const char* argumentList[] ={"" , "QEvent*"};
4976 static const char* argumentList[] ={"" , "QEvent*"};
4932 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4977 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4933 void* args[2] = {NULL, (void*)&arg__1};
4978 void* args[2] = {NULL, (void*)&arg__1};
4934 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4979 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4935 if (result) { Py_DECREF(result); }
4980 if (result) { Py_DECREF(result); }
4936 Py_DECREF(obj);
4981 Py_DECREF(obj);
4937 return;
4982 return;
4938 }
4983 }
4939 }
4984 }
4940 elfFileWidget::changeEvent(arg__1);
4985 elfFileWidget::changeEvent(arg__1);
4941 }
4986 }
4942 void PythonQtShell_elfFileWidget::childEvent(QChildEvent* arg__1)
4987 void PythonQtShell_elfFileWidget::childEvent(QChildEvent* arg__1)
4943 {
4988 {
4944 if (_wrapper) {
4989 if (_wrapper) {
4945 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
4990 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
4946 PyErr_Clear();
4991 PyErr_Clear();
4947 if (obj && !PythonQtSlotFunction_Check(obj)) {
4992 if (obj && !PythonQtSlotFunction_Check(obj)) {
4948 static const char* argumentList[] ={"" , "QChildEvent*"};
4993 static const char* argumentList[] ={"" , "QChildEvent*"};
4949 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4994 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4950 void* args[2] = {NULL, (void*)&arg__1};
4995 void* args[2] = {NULL, (void*)&arg__1};
4951 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4996 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4952 if (result) { Py_DECREF(result); }
4997 if (result) { Py_DECREF(result); }
4953 Py_DECREF(obj);
4998 Py_DECREF(obj);
4954 return;
4999 return;
4955 }
5000 }
4956 }
5001 }
4957 elfFileWidget::childEvent(arg__1);
5002 elfFileWidget::childEvent(arg__1);
4958 }
5003 }
4959 void PythonQtShell_elfFileWidget::closeEvent(QCloseEvent* arg__1)
5004 void PythonQtShell_elfFileWidget::closeEvent(QCloseEvent* arg__1)
4960 {
5005 {
4961 if (_wrapper) {
5006 if (_wrapper) {
4962 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
5007 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
4963 PyErr_Clear();
5008 PyErr_Clear();
4964 if (obj && !PythonQtSlotFunction_Check(obj)) {
5009 if (obj && !PythonQtSlotFunction_Check(obj)) {
4965 static const char* argumentList[] ={"" , "QCloseEvent*"};
5010 static const char* argumentList[] ={"" , "QCloseEvent*"};
4966 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5011 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4967 void* args[2] = {NULL, (void*)&arg__1};
5012 void* args[2] = {NULL, (void*)&arg__1};
4968 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5013 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4969 if (result) { Py_DECREF(result); }
5014 if (result) { Py_DECREF(result); }
4970 Py_DECREF(obj);
5015 Py_DECREF(obj);
4971 return;
5016 return;
4972 }
5017 }
4973 }
5018 }
4974 elfFileWidget::closeEvent(arg__1);
5019 elfFileWidget::closeEvent(arg__1);
4975 }
5020 }
4976 void PythonQtShell_elfFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
5021 void PythonQtShell_elfFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
4977 {
5022 {
4978 if (_wrapper) {
5023 if (_wrapper) {
4979 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
5024 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
4980 PyErr_Clear();
5025 PyErr_Clear();
4981 if (obj && !PythonQtSlotFunction_Check(obj)) {
5026 if (obj && !PythonQtSlotFunction_Check(obj)) {
4982 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
5027 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
4983 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5028 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4984 void* args[2] = {NULL, (void*)&arg__1};
5029 void* args[2] = {NULL, (void*)&arg__1};
4985 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5030 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4986 if (result) { Py_DECREF(result); }
5031 if (result) { Py_DECREF(result); }
4987 Py_DECREF(obj);
5032 Py_DECREF(obj);
4988 return;
5033 return;
4989 }
5034 }
4990 }
5035 }
4991 elfFileWidget::contextMenuEvent(arg__1);
5036 elfFileWidget::contextMenuEvent(arg__1);
4992 }
5037 }
4993 void PythonQtShell_elfFileWidget::customEvent(QEvent* arg__1)
5038 void PythonQtShell_elfFileWidget::customEvent(QEvent* arg__1)
4994 {
5039 {
4995 if (_wrapper) {
5040 if (_wrapper) {
4996 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
5041 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
4997 PyErr_Clear();
5042 PyErr_Clear();
4998 if (obj && !PythonQtSlotFunction_Check(obj)) {
5043 if (obj && !PythonQtSlotFunction_Check(obj)) {
4999 static const char* argumentList[] ={"" , "QEvent*"};
5044 static const char* argumentList[] ={"" , "QEvent*"};
5000 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5045 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5001 void* args[2] = {NULL, (void*)&arg__1};
5046 void* args[2] = {NULL, (void*)&arg__1};
5002 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5047 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5003 if (result) { Py_DECREF(result); }
5048 if (result) { Py_DECREF(result); }
5004 Py_DECREF(obj);
5049 Py_DECREF(obj);
5005 return;
5050 return;
5006 }
5051 }
5007 }
5052 }
5008 elfFileWidget::customEvent(arg__1);
5053 elfFileWidget::customEvent(arg__1);
5009 }
5054 }
5010 int PythonQtShell_elfFileWidget::devType() const
5055 int PythonQtShell_elfFileWidget::devType() const
5011 {
5056 {
5012 if (_wrapper) {
5057 if (_wrapper) {
5013 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
5058 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
5014 PyErr_Clear();
5059 PyErr_Clear();
5015 if (obj && !PythonQtSlotFunction_Check(obj)) {
5060 if (obj && !PythonQtSlotFunction_Check(obj)) {
5016 static const char* argumentList[] ={"int"};
5061 static const char* argumentList[] ={"int"};
5017 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5062 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5018 int returnValue;
5063 int returnValue;
5019 void* args[1] = {NULL};
5064 void* args[1] = {NULL};
5020 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5065 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5021 if (result) {
5066 if (result) {
5022 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5067 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5023 if (args[0]!=&returnValue) {
5068 if (args[0]!=&returnValue) {
5024 if (args[0]==NULL) {
5069 if (args[0]==NULL) {
5025 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
5070 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
5026 } else {
5071 } else {
5027 returnValue = *((int*)args[0]);
5072 returnValue = *((int*)args[0]);
5028 }
5073 }
5029 }
5074 }
5030 }
5075 }
5031 if (result) { Py_DECREF(result); }
5076 if (result) { Py_DECREF(result); }
5032 Py_DECREF(obj);
5077 Py_DECREF(obj);
5033 return returnValue;
5078 return returnValue;
5034 }
5079 }
5035 }
5080 }
5036 return elfFileWidget::devType();
5081 return elfFileWidget::devType();
5037 }
5082 }
5038 void PythonQtShell_elfFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
5083 void PythonQtShell_elfFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
5039 {
5084 {
5040 if (_wrapper) {
5085 if (_wrapper) {
5041 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
5086 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
5042 PyErr_Clear();
5087 PyErr_Clear();
5043 if (obj && !PythonQtSlotFunction_Check(obj)) {
5088 if (obj && !PythonQtSlotFunction_Check(obj)) {
5044 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
5089 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
5045 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5090 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5046 void* args[2] = {NULL, (void*)&arg__1};
5091 void* args[2] = {NULL, (void*)&arg__1};
5047 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5092 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5048 if (result) { Py_DECREF(result); }
5093 if (result) { Py_DECREF(result); }
5049 Py_DECREF(obj);
5094 Py_DECREF(obj);
5050 return;
5095 return;
5051 }
5096 }
5052 }
5097 }
5053 elfFileWidget::dragEnterEvent(arg__1);
5098 elfFileWidget::dragEnterEvent(arg__1);
5054 }
5099 }
5055 void PythonQtShell_elfFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
5100 void PythonQtShell_elfFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
5056 {
5101 {
5057 if (_wrapper) {
5102 if (_wrapper) {
5058 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
5103 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
5059 PyErr_Clear();
5104 PyErr_Clear();
5060 if (obj && !PythonQtSlotFunction_Check(obj)) {
5105 if (obj && !PythonQtSlotFunction_Check(obj)) {
5061 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
5106 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
5062 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5107 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5063 void* args[2] = {NULL, (void*)&arg__1};
5108 void* args[2] = {NULL, (void*)&arg__1};
5064 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5109 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5065 if (result) { Py_DECREF(result); }
5110 if (result) { Py_DECREF(result); }
5066 Py_DECREF(obj);
5111 Py_DECREF(obj);
5067 return;
5112 return;
5068 }
5113 }
5069 }
5114 }
5070 elfFileWidget::dragLeaveEvent(arg__1);
5115 elfFileWidget::dragLeaveEvent(arg__1);
5071 }
5116 }
5072 void PythonQtShell_elfFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
5117 void PythonQtShell_elfFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
5073 {
5118 {
5074 if (_wrapper) {
5119 if (_wrapper) {
5075 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
5120 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
5076 PyErr_Clear();
5121 PyErr_Clear();
5077 if (obj && !PythonQtSlotFunction_Check(obj)) {
5122 if (obj && !PythonQtSlotFunction_Check(obj)) {
5078 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
5123 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
5079 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5124 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5080 void* args[2] = {NULL, (void*)&arg__1};
5125 void* args[2] = {NULL, (void*)&arg__1};
5081 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5126 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5082 if (result) { Py_DECREF(result); }
5127 if (result) { Py_DECREF(result); }
5083 Py_DECREF(obj);
5128 Py_DECREF(obj);
5084 return;
5129 return;
5085 }
5130 }
5086 }
5131 }
5087 elfFileWidget::dragMoveEvent(arg__1);
5132 elfFileWidget::dragMoveEvent(arg__1);
5088 }
5133 }
5089 void PythonQtShell_elfFileWidget::dropEvent(QDropEvent* arg__1)
5134 void PythonQtShell_elfFileWidget::dropEvent(QDropEvent* arg__1)
5090 {
5135 {
5091 if (_wrapper) {
5136 if (_wrapper) {
5092 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
5137 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
5093 PyErr_Clear();
5138 PyErr_Clear();
5094 if (obj && !PythonQtSlotFunction_Check(obj)) {
5139 if (obj && !PythonQtSlotFunction_Check(obj)) {
5095 static const char* argumentList[] ={"" , "QDropEvent*"};
5140 static const char* argumentList[] ={"" , "QDropEvent*"};
5096 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5141 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5097 void* args[2] = {NULL, (void*)&arg__1};
5142 void* args[2] = {NULL, (void*)&arg__1};
5098 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5143 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5099 if (result) { Py_DECREF(result); }
5144 if (result) { Py_DECREF(result); }
5100 Py_DECREF(obj);
5145 Py_DECREF(obj);
5101 return;
5146 return;
5102 }
5147 }
5103 }
5148 }
5104 elfFileWidget::dropEvent(arg__1);
5149 elfFileWidget::dropEvent(arg__1);
5105 }
5150 }
5106 void PythonQtShell_elfFileWidget::enterEvent(QEvent* arg__1)
5151 void PythonQtShell_elfFileWidget::enterEvent(QEvent* arg__1)
5107 {
5152 {
5108 if (_wrapper) {
5153 if (_wrapper) {
5109 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
5154 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
5110 PyErr_Clear();
5155 PyErr_Clear();
5111 if (obj && !PythonQtSlotFunction_Check(obj)) {
5156 if (obj && !PythonQtSlotFunction_Check(obj)) {
5112 static const char* argumentList[] ={"" , "QEvent*"};
5157 static const char* argumentList[] ={"" , "QEvent*"};
5113 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5158 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5114 void* args[2] = {NULL, (void*)&arg__1};
5159 void* args[2] = {NULL, (void*)&arg__1};
5115 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5160 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5116 if (result) { Py_DECREF(result); }
5161 if (result) { Py_DECREF(result); }
5117 Py_DECREF(obj);
5162 Py_DECREF(obj);
5118 return;
5163 return;
5119 }
5164 }
5120 }
5165 }
5121 elfFileWidget::enterEvent(arg__1);
5166 elfFileWidget::enterEvent(arg__1);
5122 }
5167 }
5123 bool PythonQtShell_elfFileWidget::event(QEvent* arg__1)
5168 bool PythonQtShell_elfFileWidget::event(QEvent* arg__1)
5124 {
5169 {
5125 if (_wrapper) {
5170 if (_wrapper) {
5126 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
5171 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
5127 PyErr_Clear();
5172 PyErr_Clear();
5128 if (obj && !PythonQtSlotFunction_Check(obj)) {
5173 if (obj && !PythonQtSlotFunction_Check(obj)) {
5129 static const char* argumentList[] ={"bool" , "QEvent*"};
5174 static const char* argumentList[] ={"bool" , "QEvent*"};
5130 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5175 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5131 bool returnValue;
5176 bool returnValue;
5132 void* args[2] = {NULL, (void*)&arg__1};
5177 void* args[2] = {NULL, (void*)&arg__1};
5133 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5178 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5134 if (result) {
5179 if (result) {
5135 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5180 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5136 if (args[0]!=&returnValue) {
5181 if (args[0]!=&returnValue) {
5137 if (args[0]==NULL) {
5182 if (args[0]==NULL) {
5138 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
5183 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
5139 } else {
5184 } else {
5140 returnValue = *((bool*)args[0]);
5185 returnValue = *((bool*)args[0]);
5141 }
5186 }
5142 }
5187 }
5143 }
5188 }
5144 if (result) { Py_DECREF(result); }
5189 if (result) { Py_DECREF(result); }
5145 Py_DECREF(obj);
5190 Py_DECREF(obj);
5146 return returnValue;
5191 return returnValue;
5147 }
5192 }
5148 }
5193 }
5149 return elfFileWidget::event(arg__1);
5194 return elfFileWidget::event(arg__1);
5150 }
5195 }
5151 bool PythonQtShell_elfFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
5196 bool PythonQtShell_elfFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
5152 {
5197 {
5153 if (_wrapper) {
5198 if (_wrapper) {
5154 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
5199 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
5155 PyErr_Clear();
5200 PyErr_Clear();
5156 if (obj && !PythonQtSlotFunction_Check(obj)) {
5201 if (obj && !PythonQtSlotFunction_Check(obj)) {
5157 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5202 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5158 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5203 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5159 bool returnValue;
5204 bool returnValue;
5160 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
5205 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
5161 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5206 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5162 if (result) {
5207 if (result) {
5163 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5208 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5164 if (args[0]!=&returnValue) {
5209 if (args[0]!=&returnValue) {
5165 if (args[0]==NULL) {
5210 if (args[0]==NULL) {
5166 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
5211 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
5167 } else {
5212 } else {
5168 returnValue = *((bool*)args[0]);
5213 returnValue = *((bool*)args[0]);
5169 }
5214 }
5170 }
5215 }
5171 }
5216 }
5172 if (result) { Py_DECREF(result); }
5217 if (result) { Py_DECREF(result); }
5173 Py_DECREF(obj);
5218 Py_DECREF(obj);
5174 return returnValue;
5219 return returnValue;
5175 }
5220 }
5176 }
5221 }
5177 return elfFileWidget::eventFilter(arg__1, arg__2);
5222 return elfFileWidget::eventFilter(arg__1, arg__2);
5178 }
5223 }
5179 void PythonQtShell_elfFileWidget::focusInEvent(QFocusEvent* arg__1)
5224 void PythonQtShell_elfFileWidget::focusInEvent(QFocusEvent* arg__1)
5180 {
5225 {
5181 if (_wrapper) {
5226 if (_wrapper) {
5182 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
5227 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
5183 PyErr_Clear();
5228 PyErr_Clear();
5184 if (obj && !PythonQtSlotFunction_Check(obj)) {
5229 if (obj && !PythonQtSlotFunction_Check(obj)) {
5185 static const char* argumentList[] ={"" , "QFocusEvent*"};
5230 static const char* argumentList[] ={"" , "QFocusEvent*"};
5186 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5231 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5187 void* args[2] = {NULL, (void*)&arg__1};
5232 void* args[2] = {NULL, (void*)&arg__1};
5188 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5233 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5189 if (result) { Py_DECREF(result); }
5234 if (result) { Py_DECREF(result); }
5190 Py_DECREF(obj);
5235 Py_DECREF(obj);
5191 return;
5236 return;
5192 }
5237 }
5193 }
5238 }
5194 elfFileWidget::focusInEvent(arg__1);
5239 elfFileWidget::focusInEvent(arg__1);
5195 }
5240 }
5196 bool PythonQtShell_elfFileWidget::focusNextPrevChild(bool next)
5241 bool PythonQtShell_elfFileWidget::focusNextPrevChild(bool next)
5197 {
5242 {
5198 if (_wrapper) {
5243 if (_wrapper) {
5199 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
5244 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
5200 PyErr_Clear();
5245 PyErr_Clear();
5201 if (obj && !PythonQtSlotFunction_Check(obj)) {
5246 if (obj && !PythonQtSlotFunction_Check(obj)) {
5202 static const char* argumentList[] ={"bool" , "bool"};
5247 static const char* argumentList[] ={"bool" , "bool"};
5203 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5248 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5204 bool returnValue;
5249 bool returnValue;
5205 void* args[2] = {NULL, (void*)&next};
5250 void* args[2] = {NULL, (void*)&next};
5206 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5251 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5207 if (result) {
5252 if (result) {
5208 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5253 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5209 if (args[0]!=&returnValue) {
5254 if (args[0]!=&returnValue) {
5210 if (args[0]==NULL) {
5255 if (args[0]==NULL) {
5211 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
5256 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
5212 } else {
5257 } else {
5213 returnValue = *((bool*)args[0]);
5258 returnValue = *((bool*)args[0]);
5214 }
5259 }
5215 }
5260 }
5216 }
5261 }
5217 if (result) { Py_DECREF(result); }
5262 if (result) { Py_DECREF(result); }
5218 Py_DECREF(obj);
5263 Py_DECREF(obj);
5219 return returnValue;
5264 return returnValue;
5220 }
5265 }
5221 }
5266 }
5222 return elfFileWidget::focusNextPrevChild(next);
5267 return elfFileWidget::focusNextPrevChild(next);
5223 }
5268 }
5224 void PythonQtShell_elfFileWidget::focusOutEvent(QFocusEvent* arg__1)
5269 void PythonQtShell_elfFileWidget::focusOutEvent(QFocusEvent* arg__1)
5225 {
5270 {
5226 if (_wrapper) {
5271 if (_wrapper) {
5227 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
5272 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
5228 PyErr_Clear();
5273 PyErr_Clear();
5229 if (obj && !PythonQtSlotFunction_Check(obj)) {
5274 if (obj && !PythonQtSlotFunction_Check(obj)) {
5230 static const char* argumentList[] ={"" , "QFocusEvent*"};
5275 static const char* argumentList[] ={"" , "QFocusEvent*"};
5231 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5276 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5232 void* args[2] = {NULL, (void*)&arg__1};
5277 void* args[2] = {NULL, (void*)&arg__1};
5233 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5278 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5234 if (result) { Py_DECREF(result); }
5279 if (result) { Py_DECREF(result); }
5235 Py_DECREF(obj);
5280 Py_DECREF(obj);
5236 return;
5281 return;
5237 }
5282 }
5238 }
5283 }
5239 elfFileWidget::focusOutEvent(arg__1);
5284 elfFileWidget::focusOutEvent(arg__1);
5240 }
5285 }
5241 bool PythonQtShell_elfFileWidget::hasHeightForWidth() const
5286 bool PythonQtShell_elfFileWidget::hasHeightForWidth() const
5242 {
5287 {
5243 if (_wrapper) {
5288 if (_wrapper) {
5244 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
5289 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
5245 PyErr_Clear();
5290 PyErr_Clear();
5246 if (obj && !PythonQtSlotFunction_Check(obj)) {
5291 if (obj && !PythonQtSlotFunction_Check(obj)) {
5247 static const char* argumentList[] ={"bool"};
5292 static const char* argumentList[] ={"bool"};
5248 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5293 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5249 bool returnValue;
5294 bool returnValue;
5250 void* args[1] = {NULL};
5295 void* args[1] = {NULL};
5251 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5296 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5252 if (result) {
5297 if (result) {
5253 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5298 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5254 if (args[0]!=&returnValue) {
5299 if (args[0]!=&returnValue) {
5255 if (args[0]==NULL) {
5300 if (args[0]==NULL) {
5256 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
5301 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
5257 } else {
5302 } else {
5258 returnValue = *((bool*)args[0]);
5303 returnValue = *((bool*)args[0]);
5259 }
5304 }
5260 }
5305 }
5261 }
5306 }
5262 if (result) { Py_DECREF(result); }
5307 if (result) { Py_DECREF(result); }
5263 Py_DECREF(obj);
5308 Py_DECREF(obj);
5264 return returnValue;
5309 return returnValue;
5265 }
5310 }
5266 }
5311 }
5267 return elfFileWidget::hasHeightForWidth();
5312 return elfFileWidget::hasHeightForWidth();
5268 }
5313 }
5269 int PythonQtShell_elfFileWidget::heightForWidth(int arg__1) const
5314 int PythonQtShell_elfFileWidget::heightForWidth(int arg__1) const
5270 {
5315 {
5271 if (_wrapper) {
5316 if (_wrapper) {
5272 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
5317 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
5273 PyErr_Clear();
5318 PyErr_Clear();
5274 if (obj && !PythonQtSlotFunction_Check(obj)) {
5319 if (obj && !PythonQtSlotFunction_Check(obj)) {
5275 static const char* argumentList[] ={"int" , "int"};
5320 static const char* argumentList[] ={"int" , "int"};
5276 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5321 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5277 int returnValue;
5322 int returnValue;
5278 void* args[2] = {NULL, (void*)&arg__1};
5323 void* args[2] = {NULL, (void*)&arg__1};
5279 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5324 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5280 if (result) {
5325 if (result) {
5281 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5326 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5282 if (args[0]!=&returnValue) {
5327 if (args[0]!=&returnValue) {
5283 if (args[0]==NULL) {
5328 if (args[0]==NULL) {
5284 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
5329 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
5285 } else {
5330 } else {
5286 returnValue = *((int*)args[0]);
5331 returnValue = *((int*)args[0]);
5287 }
5332 }
5288 }
5333 }
5289 }
5334 }
5290 if (result) { Py_DECREF(result); }
5335 if (result) { Py_DECREF(result); }
5291 Py_DECREF(obj);
5336 Py_DECREF(obj);
5292 return returnValue;
5337 return returnValue;
5293 }
5338 }
5294 }
5339 }
5295 return elfFileWidget::heightForWidth(arg__1);
5340 return elfFileWidget::heightForWidth(arg__1);
5296 }
5341 }
5297 void PythonQtShell_elfFileWidget::hideEvent(QHideEvent* arg__1)
5342 void PythonQtShell_elfFileWidget::hideEvent(QHideEvent* arg__1)
5298 {
5343 {
5299 if (_wrapper) {
5344 if (_wrapper) {
5300 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
5345 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
5301 PyErr_Clear();
5346 PyErr_Clear();
5302 if (obj && !PythonQtSlotFunction_Check(obj)) {
5347 if (obj && !PythonQtSlotFunction_Check(obj)) {
5303 static const char* argumentList[] ={"" , "QHideEvent*"};
5348 static const char* argumentList[] ={"" , "QHideEvent*"};
5304 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5349 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5305 void* args[2] = {NULL, (void*)&arg__1};
5350 void* args[2] = {NULL, (void*)&arg__1};
5306 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5351 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5307 if (result) { Py_DECREF(result); }
5352 if (result) { Py_DECREF(result); }
5308 Py_DECREF(obj);
5353 Py_DECREF(obj);
5309 return;
5354 return;
5310 }
5355 }
5311 }
5356 }
5312 elfFileWidget::hideEvent(arg__1);
5357 elfFileWidget::hideEvent(arg__1);
5313 }
5358 }
5314 void PythonQtShell_elfFileWidget::initPainter(QPainter* painter) const
5359 void PythonQtShell_elfFileWidget::initPainter(QPainter* painter) const
5315 {
5360 {
5316 if (_wrapper) {
5361 if (_wrapper) {
5317 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
5362 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
5318 PyErr_Clear();
5363 PyErr_Clear();
5319 if (obj && !PythonQtSlotFunction_Check(obj)) {
5364 if (obj && !PythonQtSlotFunction_Check(obj)) {
5320 static const char* argumentList[] ={"" , "QPainter*"};
5365 static const char* argumentList[] ={"" , "QPainter*"};
5321 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5366 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5322 void* args[2] = {NULL, (void*)&painter};
5367 void* args[2] = {NULL, (void*)&painter};
5323 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5368 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5324 if (result) { Py_DECREF(result); }
5369 if (result) { Py_DECREF(result); }
5325 Py_DECREF(obj);
5370 Py_DECREF(obj);
5326 return;
5371 return;
5327 }
5372 }
5328 }
5373 }
5329 elfFileWidget::initPainter(painter);
5374 elfFileWidget::initPainter(painter);
5330 }
5375 }
5331 void PythonQtShell_elfFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
5376 void PythonQtShell_elfFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
5332 {
5377 {
5333 if (_wrapper) {
5378 if (_wrapper) {
5334 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
5379 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
5335 PyErr_Clear();
5380 PyErr_Clear();
5336 if (obj && !PythonQtSlotFunction_Check(obj)) {
5381 if (obj && !PythonQtSlotFunction_Check(obj)) {
5337 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
5382 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
5338 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5383 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5339 void* args[2] = {NULL, (void*)&arg__1};
5384 void* args[2] = {NULL, (void*)&arg__1};
5340 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5385 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5341 if (result) { Py_DECREF(result); }
5386 if (result) { Py_DECREF(result); }
5342 Py_DECREF(obj);
5387 Py_DECREF(obj);
5343 return;
5388 return;
5344 }
5389 }
5345 }
5390 }
5346 elfFileWidget::inputMethodEvent(arg__1);
5391 elfFileWidget::inputMethodEvent(arg__1);
5347 }
5392 }
5348 QVariant PythonQtShell_elfFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
5393 QVariant PythonQtShell_elfFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
5349 {
5394 {
5350 if (_wrapper) {
5395 if (_wrapper) {
5351 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
5396 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
5352 PyErr_Clear();
5397 PyErr_Clear();
5353 if (obj && !PythonQtSlotFunction_Check(obj)) {
5398 if (obj && !PythonQtSlotFunction_Check(obj)) {
5354 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
5399 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
5355 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5400 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5356 QVariant returnValue;
5401 QVariant returnValue;
5357 void* args[2] = {NULL, (void*)&arg__1};
5402 void* args[2] = {NULL, (void*)&arg__1};
5358 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5403 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5359 if (result) {
5404 if (result) {
5360 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5405 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5361 if (args[0]!=&returnValue) {
5406 if (args[0]!=&returnValue) {
5362 if (args[0]==NULL) {
5407 if (args[0]==NULL) {
5363 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
5408 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
5364 } else {
5409 } else {
5365 returnValue = *((QVariant*)args[0]);
5410 returnValue = *((QVariant*)args[0]);
5366 }
5411 }
5367 }
5412 }
5368 }
5413 }
5369 if (result) { Py_DECREF(result); }
5414 if (result) { Py_DECREF(result); }
5370 Py_DECREF(obj);
5415 Py_DECREF(obj);
5371 return returnValue;
5416 return returnValue;
5372 }
5417 }
5373 }
5418 }
5374 return elfFileWidget::inputMethodQuery(arg__1);
5419 return elfFileWidget::inputMethodQuery(arg__1);
5375 }
5420 }
5376 void PythonQtShell_elfFileWidget::keyPressEvent(QKeyEvent* arg__1)
5421 void PythonQtShell_elfFileWidget::keyPressEvent(QKeyEvent* arg__1)
5377 {
5422 {
5378 if (_wrapper) {
5423 if (_wrapper) {
5379 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
5424 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
5380 PyErr_Clear();
5425 PyErr_Clear();
5381 if (obj && !PythonQtSlotFunction_Check(obj)) {
5426 if (obj && !PythonQtSlotFunction_Check(obj)) {
5382 static const char* argumentList[] ={"" , "QKeyEvent*"};
5427 static const char* argumentList[] ={"" , "QKeyEvent*"};
5383 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5428 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5384 void* args[2] = {NULL, (void*)&arg__1};
5429 void* args[2] = {NULL, (void*)&arg__1};
5385 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5430 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5386 if (result) { Py_DECREF(result); }
5431 if (result) { Py_DECREF(result); }
5387 Py_DECREF(obj);
5432 Py_DECREF(obj);
5388 return;
5433 return;
5389 }
5434 }
5390 }
5435 }
5391 elfFileWidget::keyPressEvent(arg__1);
5436 elfFileWidget::keyPressEvent(arg__1);
5392 }
5437 }
5393 void PythonQtShell_elfFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
5438 void PythonQtShell_elfFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
5394 {
5439 {
5395 if (_wrapper) {
5440 if (_wrapper) {
5396 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
5441 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
5397 PyErr_Clear();
5442 PyErr_Clear();
5398 if (obj && !PythonQtSlotFunction_Check(obj)) {
5443 if (obj && !PythonQtSlotFunction_Check(obj)) {
5399 static const char* argumentList[] ={"" , "QKeyEvent*"};
5444 static const char* argumentList[] ={"" , "QKeyEvent*"};
5400 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5445 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5401 void* args[2] = {NULL, (void*)&arg__1};
5446 void* args[2] = {NULL, (void*)&arg__1};
5402 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5447 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5403 if (result) { Py_DECREF(result); }
5448 if (result) { Py_DECREF(result); }
5404 Py_DECREF(obj);
5449 Py_DECREF(obj);
5405 return;
5450 return;
5406 }
5451 }
5407 }
5452 }
5408 elfFileWidget::keyReleaseEvent(arg__1);
5453 elfFileWidget::keyReleaseEvent(arg__1);
5409 }
5454 }
5410 void PythonQtShell_elfFileWidget::leaveEvent(QEvent* arg__1)
5455 void PythonQtShell_elfFileWidget::leaveEvent(QEvent* arg__1)
5411 {
5456 {
5412 if (_wrapper) {
5457 if (_wrapper) {
5413 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
5458 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
5414 PyErr_Clear();
5459 PyErr_Clear();
5415 if (obj && !PythonQtSlotFunction_Check(obj)) {
5460 if (obj && !PythonQtSlotFunction_Check(obj)) {
5416 static const char* argumentList[] ={"" , "QEvent*"};
5461 static const char* argumentList[] ={"" , "QEvent*"};
5417 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5462 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5418 void* args[2] = {NULL, (void*)&arg__1};
5463 void* args[2] = {NULL, (void*)&arg__1};
5419 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5464 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5420 if (result) { Py_DECREF(result); }
5465 if (result) { Py_DECREF(result); }
5421 Py_DECREF(obj);
5466 Py_DECREF(obj);
5422 return;
5467 return;
5423 }
5468 }
5424 }
5469 }
5425 elfFileWidget::leaveEvent(arg__1);
5470 elfFileWidget::leaveEvent(arg__1);
5426 }
5471 }
5427 int PythonQtShell_elfFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
5472 int PythonQtShell_elfFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
5428 {
5473 {
5429 if (_wrapper) {
5474 if (_wrapper) {
5430 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
5475 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
5431 PyErr_Clear();
5476 PyErr_Clear();
5432 if (obj && !PythonQtSlotFunction_Check(obj)) {
5477 if (obj && !PythonQtSlotFunction_Check(obj)) {
5433 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
5478 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
5434 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5479 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5435 int returnValue;
5480 int returnValue;
5436 void* args[2] = {NULL, (void*)&arg__1};
5481 void* args[2] = {NULL, (void*)&arg__1};
5437 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5482 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5438 if (result) {
5483 if (result) {
5439 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5484 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5440 if (args[0]!=&returnValue) {
5485 if (args[0]!=&returnValue) {
5441 if (args[0]==NULL) {
5486 if (args[0]==NULL) {
5442 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
5487 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
5443 } else {
5488 } else {
5444 returnValue = *((int*)args[0]);
5489 returnValue = *((int*)args[0]);
5445 }
5490 }
5446 }
5491 }
5447 }
5492 }
5448 if (result) { Py_DECREF(result); }
5493 if (result) { Py_DECREF(result); }
5449 Py_DECREF(obj);
5494 Py_DECREF(obj);
5450 return returnValue;
5495 return returnValue;
5451 }
5496 }
5452 }
5497 }
5453 return elfFileWidget::metric(arg__1);
5498 return elfFileWidget::metric(arg__1);
5454 }
5499 }
5455 QSize PythonQtShell_elfFileWidget::minimumSizeHint() const
5500 QSize PythonQtShell_elfFileWidget::minimumSizeHint() const
5456 {
5501 {
5457 if (_wrapper) {
5502 if (_wrapper) {
5458 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
5503 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
5459 PyErr_Clear();
5504 PyErr_Clear();
5460 if (obj && !PythonQtSlotFunction_Check(obj)) {
5505 if (obj && !PythonQtSlotFunction_Check(obj)) {
5461 static const char* argumentList[] ={"QSize"};
5506 static const char* argumentList[] ={"QSize"};
5462 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5507 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5463 QSize returnValue;
5508 QSize returnValue;
5464 void* args[1] = {NULL};
5509 void* args[1] = {NULL};
5465 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5510 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5466 if (result) {
5511 if (result) {
5467 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5512 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5468 if (args[0]!=&returnValue) {
5513 if (args[0]!=&returnValue) {
5469 if (args[0]==NULL) {
5514 if (args[0]==NULL) {
5470 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
5515 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
5471 } else {
5516 } else {
5472 returnValue = *((QSize*)args[0]);
5517 returnValue = *((QSize*)args[0]);
5473 }
5518 }
5474 }
5519 }
5475 }
5520 }
5476 if (result) { Py_DECREF(result); }
5521 if (result) { Py_DECREF(result); }
5477 Py_DECREF(obj);
5522 Py_DECREF(obj);
5478 return returnValue;
5523 return returnValue;
5479 }
5524 }
5480 }
5525 }
5481 return elfFileWidget::minimumSizeHint();
5526 return elfFileWidget::minimumSizeHint();
5482 }
5527 }
5483 void PythonQtShell_elfFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
5528 void PythonQtShell_elfFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
5484 {
5529 {
5485 if (_wrapper) {
5530 if (_wrapper) {
5486 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
5531 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
5487 PyErr_Clear();
5532 PyErr_Clear();
5488 if (obj && !PythonQtSlotFunction_Check(obj)) {
5533 if (obj && !PythonQtSlotFunction_Check(obj)) {
5489 static const char* argumentList[] ={"" , "QMouseEvent*"};
5534 static const char* argumentList[] ={"" , "QMouseEvent*"};
5490 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5535 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5491 void* args[2] = {NULL, (void*)&arg__1};
5536 void* args[2] = {NULL, (void*)&arg__1};
5492 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5537 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5493 if (result) { Py_DECREF(result); }
5538 if (result) { Py_DECREF(result); }
5494 Py_DECREF(obj);
5539 Py_DECREF(obj);
5495 return;
5540 return;
5496 }
5541 }
5497 }
5542 }
5498 elfFileWidget::mouseDoubleClickEvent(arg__1);
5543 elfFileWidget::mouseDoubleClickEvent(arg__1);
5499 }
5544 }
5500 void PythonQtShell_elfFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
5545 void PythonQtShell_elfFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
5501 {
5546 {
5502 if (_wrapper) {
5547 if (_wrapper) {
5503 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
5548 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
5504 PyErr_Clear();
5549 PyErr_Clear();
5505 if (obj && !PythonQtSlotFunction_Check(obj)) {
5550 if (obj && !PythonQtSlotFunction_Check(obj)) {
5506 static const char* argumentList[] ={"" , "QMouseEvent*"};
5551 static const char* argumentList[] ={"" , "QMouseEvent*"};
5507 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5552 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5508 void* args[2] = {NULL, (void*)&arg__1};
5553 void* args[2] = {NULL, (void*)&arg__1};
5509 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5554 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5510 if (result) { Py_DECREF(result); }
5555 if (result) { Py_DECREF(result); }
5511 Py_DECREF(obj);
5556 Py_DECREF(obj);
5512 return;
5557 return;
5513 }
5558 }
5514 }
5559 }
5515 elfFileWidget::mouseMoveEvent(arg__1);
5560 elfFileWidget::mouseMoveEvent(arg__1);
5516 }
5561 }
5517 void PythonQtShell_elfFileWidget::mousePressEvent(QMouseEvent* arg__1)
5562 void PythonQtShell_elfFileWidget::mousePressEvent(QMouseEvent* arg__1)
5518 {
5563 {
5519 if (_wrapper) {
5564 if (_wrapper) {
5520 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
5565 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
5521 PyErr_Clear();
5566 PyErr_Clear();
5522 if (obj && !PythonQtSlotFunction_Check(obj)) {
5567 if (obj && !PythonQtSlotFunction_Check(obj)) {
5523 static const char* argumentList[] ={"" , "QMouseEvent*"};
5568 static const char* argumentList[] ={"" , "QMouseEvent*"};
5524 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5569 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5525 void* args[2] = {NULL, (void*)&arg__1};
5570 void* args[2] = {NULL, (void*)&arg__1};
5526 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5571 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5527 if (result) { Py_DECREF(result); }
5572 if (result) { Py_DECREF(result); }
5528 Py_DECREF(obj);
5573 Py_DECREF(obj);
5529 return;
5574 return;
5530 }
5575 }
5531 }
5576 }
5532 elfFileWidget::mousePressEvent(arg__1);
5577 elfFileWidget::mousePressEvent(arg__1);
5533 }
5578 }
5534 void PythonQtShell_elfFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
5579 void PythonQtShell_elfFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
5535 {
5580 {
5536 if (_wrapper) {
5581 if (_wrapper) {
5537 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
5582 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
5538 PyErr_Clear();
5583 PyErr_Clear();
5539 if (obj && !PythonQtSlotFunction_Check(obj)) {
5584 if (obj && !PythonQtSlotFunction_Check(obj)) {
5540 static const char* argumentList[] ={"" , "QMouseEvent*"};
5585 static const char* argumentList[] ={"" , "QMouseEvent*"};
5541 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5586 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5542 void* args[2] = {NULL, (void*)&arg__1};
5587 void* args[2] = {NULL, (void*)&arg__1};
5543 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5588 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5544 if (result) { Py_DECREF(result); }
5589 if (result) { Py_DECREF(result); }
5545 Py_DECREF(obj);
5590 Py_DECREF(obj);
5546 return;
5591 return;
5547 }
5592 }
5548 }
5593 }
5549 elfFileWidget::mouseReleaseEvent(arg__1);
5594 elfFileWidget::mouseReleaseEvent(arg__1);
5550 }
5595 }
5551 void PythonQtShell_elfFileWidget::moveEvent(QMoveEvent* arg__1)
5596 void PythonQtShell_elfFileWidget::moveEvent(QMoveEvent* arg__1)
5552 {
5597 {
5553 if (_wrapper) {
5598 if (_wrapper) {
5554 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
5599 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
5555 PyErr_Clear();
5600 PyErr_Clear();
5556 if (obj && !PythonQtSlotFunction_Check(obj)) {
5601 if (obj && !PythonQtSlotFunction_Check(obj)) {
5557 static const char* argumentList[] ={"" , "QMoveEvent*"};
5602 static const char* argumentList[] ={"" , "QMoveEvent*"};
5558 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5603 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5559 void* args[2] = {NULL, (void*)&arg__1};
5604 void* args[2] = {NULL, (void*)&arg__1};
5560 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5605 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5561 if (result) { Py_DECREF(result); }
5606 if (result) { Py_DECREF(result); }
5562 Py_DECREF(obj);
5607 Py_DECREF(obj);
5563 return;
5608 return;
5564 }
5609 }
5565 }
5610 }
5566 elfFileWidget::moveEvent(arg__1);
5611 elfFileWidget::moveEvent(arg__1);
5567 }
5612 }
5568 bool PythonQtShell_elfFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result)
5613 bool PythonQtShell_elfFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result)
5569 {
5614 {
5570 if (_wrapper) {
5615 if (_wrapper) {
5571 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
5616 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
5572 PyErr_Clear();
5617 PyErr_Clear();
5573 if (obj && !PythonQtSlotFunction_Check(obj)) {
5618 if (obj && !PythonQtSlotFunction_Check(obj)) {
5574 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
5619 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
5575 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
5620 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
5576 bool returnValue;
5621 bool returnValue;
5577 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
5622 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
5578 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5623 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5579 if (result) {
5624 if (result) {
5580 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5625 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5581 if (args[0]!=&returnValue) {
5626 if (args[0]!=&returnValue) {
5582 if (args[0]==NULL) {
5627 if (args[0]==NULL) {
5583 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
5628 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
5584 } else {
5629 } else {
5585 returnValue = *((bool*)args[0]);
5630 returnValue = *((bool*)args[0]);
5586 }
5631 }
5587 }
5632 }
5588 }
5633 }
5589 if (result) { Py_DECREF(result); }
5634 if (result) { Py_DECREF(result); }
5590 Py_DECREF(obj);
5635 Py_DECREF(obj);
5591 return returnValue;
5636 return returnValue;
5592 }
5637 }
5593 }
5638 }
5594 return elfFileWidget::nativeEvent(eventType, message, result);
5639 return elfFileWidget::nativeEvent(eventType, message, result);
5595 }
5640 }
5596 QPaintEngine* PythonQtShell_elfFileWidget::paintEngine() const
5641 QPaintEngine* PythonQtShell_elfFileWidget::paintEngine() const
5597 {
5642 {
5598 if (_wrapper) {
5643 if (_wrapper) {
5599 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
5644 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
5600 PyErr_Clear();
5645 PyErr_Clear();
5601 if (obj && !PythonQtSlotFunction_Check(obj)) {
5646 if (obj && !PythonQtSlotFunction_Check(obj)) {
5602 static const char* argumentList[] ={"QPaintEngine*"};
5647 static const char* argumentList[] ={"QPaintEngine*"};
5603 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5648 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5604 QPaintEngine* returnValue;
5649 QPaintEngine* returnValue;
5605 void* args[1] = {NULL};
5650 void* args[1] = {NULL};
5606 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5651 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5607 if (result) {
5652 if (result) {
5608 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5653 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5609 if (args[0]!=&returnValue) {
5654 if (args[0]!=&returnValue) {
5610 if (args[0]==NULL) {
5655 if (args[0]==NULL) {
5611 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
5656 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
5612 } else {
5657 } else {
5613 returnValue = *((QPaintEngine**)args[0]);
5658 returnValue = *((QPaintEngine**)args[0]);
5614 }
5659 }
5615 }
5660 }
5616 }
5661 }
5617 if (result) { Py_DECREF(result); }
5662 if (result) { Py_DECREF(result); }
5618 Py_DECREF(obj);
5663 Py_DECREF(obj);
5619 return returnValue;
5664 return returnValue;
5620 }
5665 }
5621 }
5666 }
5622 return elfFileWidget::paintEngine();
5667 return elfFileWidget::paintEngine();
5623 }
5668 }
5624 void PythonQtShell_elfFileWidget::paintEvent(QPaintEvent* arg__1)
5669 void PythonQtShell_elfFileWidget::paintEvent(QPaintEvent* arg__1)
5625 {
5670 {
5626 if (_wrapper) {
5671 if (_wrapper) {
5627 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
5672 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
5628 PyErr_Clear();
5673 PyErr_Clear();
5629 if (obj && !PythonQtSlotFunction_Check(obj)) {
5674 if (obj && !PythonQtSlotFunction_Check(obj)) {
5630 static const char* argumentList[] ={"" , "QPaintEvent*"};
5675 static const char* argumentList[] ={"" , "QPaintEvent*"};
5631 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5676 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5632 void* args[2] = {NULL, (void*)&arg__1};
5677 void* args[2] = {NULL, (void*)&arg__1};
5633 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5678 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5634 if (result) { Py_DECREF(result); }
5679 if (result) { Py_DECREF(result); }
5635 Py_DECREF(obj);
5680 Py_DECREF(obj);
5636 return;
5681 return;
5637 }
5682 }
5638 }
5683 }
5639 elfFileWidget::paintEvent(arg__1);
5684 elfFileWidget::paintEvent(arg__1);
5640 }
5685 }
5641 QPaintDevice* PythonQtShell_elfFileWidget::redirected(QPoint* offset) const
5686 QPaintDevice* PythonQtShell_elfFileWidget::redirected(QPoint* offset) const
5642 {
5687 {
5643 if (_wrapper) {
5688 if (_wrapper) {
5644 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
5689 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
5645 PyErr_Clear();
5690 PyErr_Clear();
5646 if (obj && !PythonQtSlotFunction_Check(obj)) {
5691 if (obj && !PythonQtSlotFunction_Check(obj)) {
5647 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
5692 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
5648 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5693 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5649 QPaintDevice* returnValue;
5694 QPaintDevice* returnValue;
5650 void* args[2] = {NULL, (void*)&offset};
5695 void* args[2] = {NULL, (void*)&offset};
5651 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5696 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5652 if (result) {
5697 if (result) {
5653 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5698 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5654 if (args[0]!=&returnValue) {
5699 if (args[0]!=&returnValue) {
5655 if (args[0]==NULL) {
5700 if (args[0]==NULL) {
5656 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
5701 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
5657 } else {
5702 } else {
5658 returnValue = *((QPaintDevice**)args[0]);
5703 returnValue = *((QPaintDevice**)args[0]);
5659 }
5704 }
5660 }
5705 }
5661 }
5706 }
5662 if (result) { Py_DECREF(result); }
5707 if (result) { Py_DECREF(result); }
5663 Py_DECREF(obj);
5708 Py_DECREF(obj);
5664 return returnValue;
5709 return returnValue;
5665 }
5710 }
5666 }
5711 }
5667 return elfFileWidget::redirected(offset);
5712 return elfFileWidget::redirected(offset);
5668 }
5713 }
5669 void PythonQtShell_elfFileWidget::resizeEvent(QResizeEvent* arg__1)
5714 void PythonQtShell_elfFileWidget::resizeEvent(QResizeEvent* arg__1)
5670 {
5715 {
5671 if (_wrapper) {
5716 if (_wrapper) {
5672 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
5717 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
5673 PyErr_Clear();
5718 PyErr_Clear();
5674 if (obj && !PythonQtSlotFunction_Check(obj)) {
5719 if (obj && !PythonQtSlotFunction_Check(obj)) {
5675 static const char* argumentList[] ={"" , "QResizeEvent*"};
5720 static const char* argumentList[] ={"" , "QResizeEvent*"};
5676 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5721 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5677 void* args[2] = {NULL, (void*)&arg__1};
5722 void* args[2] = {NULL, (void*)&arg__1};
5678 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5723 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5679 if (result) { Py_DECREF(result); }
5724 if (result) { Py_DECREF(result); }
5680 Py_DECREF(obj);
5725 Py_DECREF(obj);
5681 return;
5726 return;
5682 }
5727 }
5683 }
5728 }
5684 elfFileWidget::resizeEvent(arg__1);
5729 elfFileWidget::resizeEvent(arg__1);
5685 }
5730 }
5686 QPainter* PythonQtShell_elfFileWidget::sharedPainter() const
5731 QPainter* PythonQtShell_elfFileWidget::sharedPainter() const
5687 {
5732 {
5688 if (_wrapper) {
5733 if (_wrapper) {
5689 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
5734 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
5690 PyErr_Clear();
5735 PyErr_Clear();
5691 if (obj && !PythonQtSlotFunction_Check(obj)) {
5736 if (obj && !PythonQtSlotFunction_Check(obj)) {
5692 static const char* argumentList[] ={"QPainter*"};
5737 static const char* argumentList[] ={"QPainter*"};
5693 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5738 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5694 QPainter* returnValue;
5739 QPainter* returnValue;
5695 void* args[1] = {NULL};
5740 void* args[1] = {NULL};
5696 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5741 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5697 if (result) {
5742 if (result) {
5698 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5743 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5699 if (args[0]!=&returnValue) {
5744 if (args[0]!=&returnValue) {
5700 if (args[0]==NULL) {
5745 if (args[0]==NULL) {
5701 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
5746 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
5702 } else {
5747 } else {
5703 returnValue = *((QPainter**)args[0]);
5748 returnValue = *((QPainter**)args[0]);
5704 }
5749 }
5705 }
5750 }
5706 }
5751 }
5707 if (result) { Py_DECREF(result); }
5752 if (result) { Py_DECREF(result); }
5708 Py_DECREF(obj);
5753 Py_DECREF(obj);
5709 return returnValue;
5754 return returnValue;
5710 }
5755 }
5711 }
5756 }
5712 return elfFileWidget::sharedPainter();
5757 return elfFileWidget::sharedPainter();
5713 }
5758 }
5714 void PythonQtShell_elfFileWidget::showEvent(QShowEvent* arg__1)
5759 void PythonQtShell_elfFileWidget::showEvent(QShowEvent* arg__1)
5715 {
5760 {
5716 if (_wrapper) {
5761 if (_wrapper) {
5717 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
5762 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
5718 PyErr_Clear();
5763 PyErr_Clear();
5719 if (obj && !PythonQtSlotFunction_Check(obj)) {
5764 if (obj && !PythonQtSlotFunction_Check(obj)) {
5720 static const char* argumentList[] ={"" , "QShowEvent*"};
5765 static const char* argumentList[] ={"" , "QShowEvent*"};
5721 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5766 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5722 void* args[2] = {NULL, (void*)&arg__1};
5767 void* args[2] = {NULL, (void*)&arg__1};
5723 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5768 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5724 if (result) { Py_DECREF(result); }
5769 if (result) { Py_DECREF(result); }
5725 Py_DECREF(obj);
5770 Py_DECREF(obj);
5726 return;
5771 return;
5727 }
5772 }
5728 }
5773 }
5729 elfFileWidget::showEvent(arg__1);
5774 elfFileWidget::showEvent(arg__1);
5730 }
5775 }
5731 QSize PythonQtShell_elfFileWidget::sizeHint() const
5776 QSize PythonQtShell_elfFileWidget::sizeHint() const
5732 {
5777 {
5733 if (_wrapper) {
5778 if (_wrapper) {
5734 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
5779 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
5735 PyErr_Clear();
5780 PyErr_Clear();
5736 if (obj && !PythonQtSlotFunction_Check(obj)) {
5781 if (obj && !PythonQtSlotFunction_Check(obj)) {
5737 static const char* argumentList[] ={"QSize"};
5782 static const char* argumentList[] ={"QSize"};
5738 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5783 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5739 QSize returnValue;
5784 QSize returnValue;
5740 void* args[1] = {NULL};
5785 void* args[1] = {NULL};
5741 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5786 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5742 if (result) {
5787 if (result) {
5743 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5788 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5744 if (args[0]!=&returnValue) {
5789 if (args[0]!=&returnValue) {
5745 if (args[0]==NULL) {
5790 if (args[0]==NULL) {
5746 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
5791 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
5747 } else {
5792 } else {
5748 returnValue = *((QSize*)args[0]);
5793 returnValue = *((QSize*)args[0]);
5749 }
5794 }
5750 }
5795 }
5751 }
5796 }
5752 if (result) { Py_DECREF(result); }
5797 if (result) { Py_DECREF(result); }
5753 Py_DECREF(obj);
5798 Py_DECREF(obj);
5754 return returnValue;
5799 return returnValue;
5755 }
5800 }
5756 }
5801 }
5757 return elfFileWidget::sizeHint();
5802 return elfFileWidget::sizeHint();
5758 }
5803 }
5759 void PythonQtShell_elfFileWidget::tabletEvent(QTabletEvent* arg__1)
5804 void PythonQtShell_elfFileWidget::tabletEvent(QTabletEvent* arg__1)
5760 {
5805 {
5761 if (_wrapper) {
5806 if (_wrapper) {
5762 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
5807 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
5763 PyErr_Clear();
5808 PyErr_Clear();
5764 if (obj && !PythonQtSlotFunction_Check(obj)) {
5809 if (obj && !PythonQtSlotFunction_Check(obj)) {
5765 static const char* argumentList[] ={"" , "QTabletEvent*"};
5810 static const char* argumentList[] ={"" , "QTabletEvent*"};
5766 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5811 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5767 void* args[2] = {NULL, (void*)&arg__1};
5812 void* args[2] = {NULL, (void*)&arg__1};
5768 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5813 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5769 if (result) { Py_DECREF(result); }
5814 if (result) { Py_DECREF(result); }
5770 Py_DECREF(obj);
5815 Py_DECREF(obj);
5771 return;
5816 return;
5772 }
5817 }
5773 }
5818 }
5774 elfFileWidget::tabletEvent(arg__1);
5819 elfFileWidget::tabletEvent(arg__1);
5775 }
5820 }
5776 void PythonQtShell_elfFileWidget::timerEvent(QTimerEvent* arg__1)
5821 void PythonQtShell_elfFileWidget::timerEvent(QTimerEvent* arg__1)
5777 {
5822 {
5778 if (_wrapper) {
5823 if (_wrapper) {
5779 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
5824 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
5780 PyErr_Clear();
5825 PyErr_Clear();
5781 if (obj && !PythonQtSlotFunction_Check(obj)) {
5826 if (obj && !PythonQtSlotFunction_Check(obj)) {
5782 static const char* argumentList[] ={"" , "QTimerEvent*"};
5827 static const char* argumentList[] ={"" , "QTimerEvent*"};
5783 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5828 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5784 void* args[2] = {NULL, (void*)&arg__1};
5829 void* args[2] = {NULL, (void*)&arg__1};
5785 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5830 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5786 if (result) { Py_DECREF(result); }
5831 if (result) { Py_DECREF(result); }
5787 Py_DECREF(obj);
5832 Py_DECREF(obj);
5788 return;
5833 return;
5789 }
5834 }
5790 }
5835 }
5791 elfFileWidget::timerEvent(arg__1);
5836 elfFileWidget::timerEvent(arg__1);
5792 }
5837 }
5793 void PythonQtShell_elfFileWidget::wheelEvent(QWheelEvent* arg__1)
5838 void PythonQtShell_elfFileWidget::wheelEvent(QWheelEvent* arg__1)
5794 {
5839 {
5795 if (_wrapper) {
5840 if (_wrapper) {
5796 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
5841 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
5797 PyErr_Clear();
5842 PyErr_Clear();
5798 if (obj && !PythonQtSlotFunction_Check(obj)) {
5843 if (obj && !PythonQtSlotFunction_Check(obj)) {
5799 static const char* argumentList[] ={"" , "QWheelEvent*"};
5844 static const char* argumentList[] ={"" , "QWheelEvent*"};
5800 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5845 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5801 void* args[2] = {NULL, (void*)&arg__1};
5846 void* args[2] = {NULL, (void*)&arg__1};
5802 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5847 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5803 if (result) { Py_DECREF(result); }
5848 if (result) { Py_DECREF(result); }
5804 Py_DECREF(obj);
5849 Py_DECREF(obj);
5805 return;
5850 return;
5806 }
5851 }
5807 }
5852 }
5808 elfFileWidget::wheelEvent(arg__1);
5853 elfFileWidget::wheelEvent(arg__1);
5809 }
5854 }
5810 elfFileWidget* PythonQtWrapper_elfFileWidget::new_elfFileWidget(QWidget* parent)
5855 elfFileWidget* PythonQtWrapper_elfFileWidget::new_elfFileWidget(QWidget* parent)
5811 {
5856 {
5812 return new PythonQtShell_elfFileWidget(parent); }
5857 return new PythonQtShell_elfFileWidget(parent); }
5813
5858
5814
5859
5815
5860
5816 PythonQtShell_elfInfoWdgt::~PythonQtShell_elfInfoWdgt() {
5861 PythonQtShell_elfInfoWdgt::~PythonQtShell_elfInfoWdgt() {
5817 PythonQtPrivate* priv = PythonQt::priv();
5862 PythonQtPrivate* priv = PythonQt::priv();
5818 if (priv) { priv->shellClassDeleted(this); }
5863 if (priv) { priv->shellClassDeleted(this); }
5819 }
5864 }
5820 void PythonQtShell_elfInfoWdgt::actionEvent(QActionEvent* arg__1)
5865 void PythonQtShell_elfInfoWdgt::actionEvent(QActionEvent* arg__1)
5821 {
5866 {
5822 if (_wrapper) {
5867 if (_wrapper) {
5823 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
5868 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
5824 PyErr_Clear();
5869 PyErr_Clear();
5825 if (obj && !PythonQtSlotFunction_Check(obj)) {
5870 if (obj && !PythonQtSlotFunction_Check(obj)) {
5826 static const char* argumentList[] ={"" , "QActionEvent*"};
5871 static const char* argumentList[] ={"" , "QActionEvent*"};
5827 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5872 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5828 void* args[2] = {NULL, (void*)&arg__1};
5873 void* args[2] = {NULL, (void*)&arg__1};
5829 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5874 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5830 if (result) { Py_DECREF(result); }
5875 if (result) { Py_DECREF(result); }
5831 Py_DECREF(obj);
5876 Py_DECREF(obj);
5832 return;
5877 return;
5833 }
5878 }
5834 }
5879 }
5835 elfInfoWdgt::actionEvent(arg__1);
5880 elfInfoWdgt::actionEvent(arg__1);
5836 }
5881 }
5837 void PythonQtShell_elfInfoWdgt::changeEvent(QEvent* arg__1)
5882 void PythonQtShell_elfInfoWdgt::changeEvent(QEvent* arg__1)
5838 {
5883 {
5839 if (_wrapper) {
5884 if (_wrapper) {
5840 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
5885 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
5841 PyErr_Clear();
5886 PyErr_Clear();
5842 if (obj && !PythonQtSlotFunction_Check(obj)) {
5887 if (obj && !PythonQtSlotFunction_Check(obj)) {
5843 static const char* argumentList[] ={"" , "QEvent*"};
5888 static const char* argumentList[] ={"" , "QEvent*"};
5844 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5889 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5845 void* args[2] = {NULL, (void*)&arg__1};
5890 void* args[2] = {NULL, (void*)&arg__1};
5846 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5891 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5847 if (result) { Py_DECREF(result); }
5892 if (result) { Py_DECREF(result); }
5848 Py_DECREF(obj);
5893 Py_DECREF(obj);
5849 return;
5894 return;
5850 }
5895 }
5851 }
5896 }
5852 elfInfoWdgt::changeEvent(arg__1);
5897 elfInfoWdgt::changeEvent(arg__1);
5853 }
5898 }
5854 void PythonQtShell_elfInfoWdgt::childEvent(QChildEvent* arg__1)
5899 void PythonQtShell_elfInfoWdgt::childEvent(QChildEvent* arg__1)
5855 {
5900 {
5856 if (_wrapper) {
5901 if (_wrapper) {
5857 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
5902 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
5858 PyErr_Clear();
5903 PyErr_Clear();
5859 if (obj && !PythonQtSlotFunction_Check(obj)) {
5904 if (obj && !PythonQtSlotFunction_Check(obj)) {
5860 static const char* argumentList[] ={"" , "QChildEvent*"};
5905 static const char* argumentList[] ={"" , "QChildEvent*"};
5861 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5906 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5862 void* args[2] = {NULL, (void*)&arg__1};
5907 void* args[2] = {NULL, (void*)&arg__1};
5863 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5908 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5864 if (result) { Py_DECREF(result); }
5909 if (result) { Py_DECREF(result); }
5865 Py_DECREF(obj);
5910 Py_DECREF(obj);
5866 return;
5911 return;
5867 }
5912 }
5868 }
5913 }
5869 elfInfoWdgt::childEvent(arg__1);
5914 elfInfoWdgt::childEvent(arg__1);
5870 }
5915 }
5871 void PythonQtShell_elfInfoWdgt::closeEvent(QCloseEvent* arg__1)
5916 void PythonQtShell_elfInfoWdgt::closeEvent(QCloseEvent* arg__1)
5872 {
5917 {
5873 if (_wrapper) {
5918 if (_wrapper) {
5874 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
5919 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
5875 PyErr_Clear();
5920 PyErr_Clear();
5876 if (obj && !PythonQtSlotFunction_Check(obj)) {
5921 if (obj && !PythonQtSlotFunction_Check(obj)) {
5877 static const char* argumentList[] ={"" , "QCloseEvent*"};
5922 static const char* argumentList[] ={"" , "QCloseEvent*"};
5878 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5923 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5879 void* args[2] = {NULL, (void*)&arg__1};
5924 void* args[2] = {NULL, (void*)&arg__1};
5880 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5925 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5881 if (result) { Py_DECREF(result); }
5926 if (result) { Py_DECREF(result); }
5882 Py_DECREF(obj);
5927 Py_DECREF(obj);
5883 return;
5928 return;
5884 }
5929 }
5885 }
5930 }
5886 elfInfoWdgt::closeEvent(arg__1);
5931 elfInfoWdgt::closeEvent(arg__1);
5887 }
5932 }
5888 void PythonQtShell_elfInfoWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
5933 void PythonQtShell_elfInfoWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
5889 {
5934 {
5890 if (_wrapper) {
5935 if (_wrapper) {
5891 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
5936 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
5892 PyErr_Clear();
5937 PyErr_Clear();
5893 if (obj && !PythonQtSlotFunction_Check(obj)) {
5938 if (obj && !PythonQtSlotFunction_Check(obj)) {
5894 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
5939 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
5895 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5940 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5896 void* args[2] = {NULL, (void*)&arg__1};
5941 void* args[2] = {NULL, (void*)&arg__1};
5897 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5942 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5898 if (result) { Py_DECREF(result); }
5943 if (result) { Py_DECREF(result); }
5899 Py_DECREF(obj);
5944 Py_DECREF(obj);
5900 return;
5945 return;
5901 }
5946 }
5902 }
5947 }
5903 elfInfoWdgt::contextMenuEvent(arg__1);
5948 elfInfoWdgt::contextMenuEvent(arg__1);
5904 }
5949 }
5905 void PythonQtShell_elfInfoWdgt::customEvent(QEvent* arg__1)
5950 void PythonQtShell_elfInfoWdgt::customEvent(QEvent* arg__1)
5906 {
5951 {
5907 if (_wrapper) {
5952 if (_wrapper) {
5908 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
5953 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
5909 PyErr_Clear();
5954 PyErr_Clear();
5910 if (obj && !PythonQtSlotFunction_Check(obj)) {
5955 if (obj && !PythonQtSlotFunction_Check(obj)) {
5911 static const char* argumentList[] ={"" , "QEvent*"};
5956 static const char* argumentList[] ={"" , "QEvent*"};
5912 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5957 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5913 void* args[2] = {NULL, (void*)&arg__1};
5958 void* args[2] = {NULL, (void*)&arg__1};
5914 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5959 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5915 if (result) { Py_DECREF(result); }
5960 if (result) { Py_DECREF(result); }
5916 Py_DECREF(obj);
5961 Py_DECREF(obj);
5917 return;
5962 return;
5918 }
5963 }
5919 }
5964 }
5920 elfInfoWdgt::customEvent(arg__1);
5965 elfInfoWdgt::customEvent(arg__1);
5921 }
5966 }
5922 int PythonQtShell_elfInfoWdgt::devType() const
5967 int PythonQtShell_elfInfoWdgt::devType() const
5923 {
5968 {
5924 if (_wrapper) {
5969 if (_wrapper) {
5925 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
5970 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
5926 PyErr_Clear();
5971 PyErr_Clear();
5927 if (obj && !PythonQtSlotFunction_Check(obj)) {
5972 if (obj && !PythonQtSlotFunction_Check(obj)) {
5928 static const char* argumentList[] ={"int"};
5973 static const char* argumentList[] ={"int"};
5929 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5974 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5930 int returnValue;
5975 int returnValue;
5931 void* args[1] = {NULL};
5976 void* args[1] = {NULL};
5932 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5977 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5933 if (result) {
5978 if (result) {
5934 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5979 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5935 if (args[0]!=&returnValue) {
5980 if (args[0]!=&returnValue) {
5936 if (args[0]==NULL) {
5981 if (args[0]==NULL) {
5937 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
5982 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
5938 } else {
5983 } else {
5939 returnValue = *((int*)args[0]);
5984 returnValue = *((int*)args[0]);
5940 }
5985 }
5941 }
5986 }
5942 }
5987 }
5943 if (result) { Py_DECREF(result); }
5988 if (result) { Py_DECREF(result); }
5944 Py_DECREF(obj);
5989 Py_DECREF(obj);
5945 return returnValue;
5990 return returnValue;
5946 }
5991 }
5947 }
5992 }
5948 return elfInfoWdgt::devType();
5993 return elfInfoWdgt::devType();
5949 }
5994 }
5950 void PythonQtShell_elfInfoWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
5995 void PythonQtShell_elfInfoWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
5951 {
5996 {
5952 if (_wrapper) {
5997 if (_wrapper) {
5953 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
5998 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
5954 PyErr_Clear();
5999 PyErr_Clear();
5955 if (obj && !PythonQtSlotFunction_Check(obj)) {
6000 if (obj && !PythonQtSlotFunction_Check(obj)) {
5956 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
6001 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
5957 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6002 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5958 void* args[2] = {NULL, (void*)&arg__1};
6003 void* args[2] = {NULL, (void*)&arg__1};
5959 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6004 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5960 if (result) { Py_DECREF(result); }
6005 if (result) { Py_DECREF(result); }
5961 Py_DECREF(obj);
6006 Py_DECREF(obj);
5962 return;
6007 return;
5963 }
6008 }
5964 }
6009 }
5965 elfInfoWdgt::dragEnterEvent(arg__1);
6010 elfInfoWdgt::dragEnterEvent(arg__1);
5966 }
6011 }
5967 void PythonQtShell_elfInfoWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
6012 void PythonQtShell_elfInfoWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
5968 {
6013 {
5969 if (_wrapper) {
6014 if (_wrapper) {
5970 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
6015 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
5971 PyErr_Clear();
6016 PyErr_Clear();
5972 if (obj && !PythonQtSlotFunction_Check(obj)) {
6017 if (obj && !PythonQtSlotFunction_Check(obj)) {
5973 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
6018 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
5974 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6019 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5975 void* args[2] = {NULL, (void*)&arg__1};
6020 void* args[2] = {NULL, (void*)&arg__1};
5976 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6021 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5977 if (result) { Py_DECREF(result); }
6022 if (result) { Py_DECREF(result); }
5978 Py_DECREF(obj);
6023 Py_DECREF(obj);
5979 return;
6024 return;
5980 }
6025 }
5981 }
6026 }
5982 elfInfoWdgt::dragLeaveEvent(arg__1);
6027 elfInfoWdgt::dragLeaveEvent(arg__1);
5983 }
6028 }
5984 void PythonQtShell_elfInfoWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
6029 void PythonQtShell_elfInfoWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
5985 {
6030 {
5986 if (_wrapper) {
6031 if (_wrapper) {
5987 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
6032 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
5988 PyErr_Clear();
6033 PyErr_Clear();
5989 if (obj && !PythonQtSlotFunction_Check(obj)) {
6034 if (obj && !PythonQtSlotFunction_Check(obj)) {
5990 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
6035 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
5991 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6036 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5992 void* args[2] = {NULL, (void*)&arg__1};
6037 void* args[2] = {NULL, (void*)&arg__1};
5993 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6038 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5994 if (result) { Py_DECREF(result); }
6039 if (result) { Py_DECREF(result); }
5995 Py_DECREF(obj);
6040 Py_DECREF(obj);
5996 return;
6041 return;
5997 }
6042 }
5998 }
6043 }
5999 elfInfoWdgt::dragMoveEvent(arg__1);
6044 elfInfoWdgt::dragMoveEvent(arg__1);
6000 }
6045 }
6001 void PythonQtShell_elfInfoWdgt::dropEvent(QDropEvent* arg__1)
6046 void PythonQtShell_elfInfoWdgt::dropEvent(QDropEvent* arg__1)
6002 {
6047 {
6003 if (_wrapper) {
6048 if (_wrapper) {
6004 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
6049 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
6005 PyErr_Clear();
6050 PyErr_Clear();
6006 if (obj && !PythonQtSlotFunction_Check(obj)) {
6051 if (obj && !PythonQtSlotFunction_Check(obj)) {
6007 static const char* argumentList[] ={"" , "QDropEvent*"};
6052 static const char* argumentList[] ={"" , "QDropEvent*"};
6008 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6053 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6009 void* args[2] = {NULL, (void*)&arg__1};
6054 void* args[2] = {NULL, (void*)&arg__1};
6010 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6055 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6011 if (result) { Py_DECREF(result); }
6056 if (result) { Py_DECREF(result); }
6012 Py_DECREF(obj);
6057 Py_DECREF(obj);
6013 return;
6058 return;
6014 }
6059 }
6015 }
6060 }
6016 elfInfoWdgt::dropEvent(arg__1);
6061 elfInfoWdgt::dropEvent(arg__1);
6017 }
6062 }
6018 void PythonQtShell_elfInfoWdgt::enterEvent(QEvent* arg__1)
6063 void PythonQtShell_elfInfoWdgt::enterEvent(QEvent* arg__1)
6019 {
6064 {
6020 if (_wrapper) {
6065 if (_wrapper) {
6021 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
6066 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
6022 PyErr_Clear();
6067 PyErr_Clear();
6023 if (obj && !PythonQtSlotFunction_Check(obj)) {
6068 if (obj && !PythonQtSlotFunction_Check(obj)) {
6024 static const char* argumentList[] ={"" , "QEvent*"};
6069 static const char* argumentList[] ={"" , "QEvent*"};
6025 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6070 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6026 void* args[2] = {NULL, (void*)&arg__1};
6071 void* args[2] = {NULL, (void*)&arg__1};
6027 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6072 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6028 if (result) { Py_DECREF(result); }
6073 if (result) { Py_DECREF(result); }
6029 Py_DECREF(obj);
6074 Py_DECREF(obj);
6030 return;
6075 return;
6031 }
6076 }
6032 }
6077 }
6033 elfInfoWdgt::enterEvent(arg__1);
6078 elfInfoWdgt::enterEvent(arg__1);
6034 }
6079 }
6035 bool PythonQtShell_elfInfoWdgt::event(QEvent* arg__1)
6080 bool PythonQtShell_elfInfoWdgt::event(QEvent* arg__1)
6036 {
6081 {
6037 if (_wrapper) {
6082 if (_wrapper) {
6038 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
6083 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
6039 PyErr_Clear();
6084 PyErr_Clear();
6040 if (obj && !PythonQtSlotFunction_Check(obj)) {
6085 if (obj && !PythonQtSlotFunction_Check(obj)) {
6041 static const char* argumentList[] ={"bool" , "QEvent*"};
6086 static const char* argumentList[] ={"bool" , "QEvent*"};
6042 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6087 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6043 bool returnValue;
6088 bool returnValue;
6044 void* args[2] = {NULL, (void*)&arg__1};
6089 void* args[2] = {NULL, (void*)&arg__1};
6045 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6090 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6046 if (result) {
6091 if (result) {
6047 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6092 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6048 if (args[0]!=&returnValue) {
6093 if (args[0]!=&returnValue) {
6049 if (args[0]==NULL) {
6094 if (args[0]==NULL) {
6050 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
6095 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
6051 } else {
6096 } else {
6052 returnValue = *((bool*)args[0]);
6097 returnValue = *((bool*)args[0]);
6053 }
6098 }
6054 }
6099 }
6055 }
6100 }
6056 if (result) { Py_DECREF(result); }
6101 if (result) { Py_DECREF(result); }
6057 Py_DECREF(obj);
6102 Py_DECREF(obj);
6058 return returnValue;
6103 return returnValue;
6059 }
6104 }
6060 }
6105 }
6061 return elfInfoWdgt::event(arg__1);
6106 return elfInfoWdgt::event(arg__1);
6062 }
6107 }
6063 bool PythonQtShell_elfInfoWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
6108 bool PythonQtShell_elfInfoWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
6064 {
6109 {
6065 if (_wrapper) {
6110 if (_wrapper) {
6066 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
6111 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
6067 PyErr_Clear();
6112 PyErr_Clear();
6068 if (obj && !PythonQtSlotFunction_Check(obj)) {
6113 if (obj && !PythonQtSlotFunction_Check(obj)) {
6069 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
6114 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
6070 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
6115 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
6071 bool returnValue;
6116 bool returnValue;
6072 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
6117 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
6073 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6118 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6074 if (result) {
6119 if (result) {
6075 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6120 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6076 if (args[0]!=&returnValue) {
6121 if (args[0]!=&returnValue) {
6077 if (args[0]==NULL) {
6122 if (args[0]==NULL) {
6078 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
6123 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
6079 } else {
6124 } else {
6080 returnValue = *((bool*)args[0]);
6125 returnValue = *((bool*)args[0]);
6081 }
6126 }
6082 }
6127 }
6083 }
6128 }
6084 if (result) { Py_DECREF(result); }
6129 if (result) { Py_DECREF(result); }
6085 Py_DECREF(obj);
6130 Py_DECREF(obj);
6086 return returnValue;
6131 return returnValue;
6087 }
6132 }
6088 }
6133 }
6089 return elfInfoWdgt::eventFilter(arg__1, arg__2);
6134 return elfInfoWdgt::eventFilter(arg__1, arg__2);
6090 }
6135 }
6091 void PythonQtShell_elfInfoWdgt::focusInEvent(QFocusEvent* arg__1)
6136 void PythonQtShell_elfInfoWdgt::focusInEvent(QFocusEvent* arg__1)
6092 {
6137 {
6093 if (_wrapper) {
6138 if (_wrapper) {
6094 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
6139 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
6095 PyErr_Clear();
6140 PyErr_Clear();
6096 if (obj && !PythonQtSlotFunction_Check(obj)) {
6141 if (obj && !PythonQtSlotFunction_Check(obj)) {
6097 static const char* argumentList[] ={"" , "QFocusEvent*"};
6142 static const char* argumentList[] ={"" , "QFocusEvent*"};
6098 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6143 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6099 void* args[2] = {NULL, (void*)&arg__1};
6144 void* args[2] = {NULL, (void*)&arg__1};
6100 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6145 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6101 if (result) { Py_DECREF(result); }
6146 if (result) { Py_DECREF(result); }
6102 Py_DECREF(obj);
6147 Py_DECREF(obj);
6103 return;
6148 return;
6104 }
6149 }
6105 }
6150 }
6106 elfInfoWdgt::focusInEvent(arg__1);
6151 elfInfoWdgt::focusInEvent(arg__1);
6107 }
6152 }
6108 bool PythonQtShell_elfInfoWdgt::focusNextPrevChild(bool next)
6153 bool PythonQtShell_elfInfoWdgt::focusNextPrevChild(bool next)
6109 {
6154 {
6110 if (_wrapper) {
6155 if (_wrapper) {
6111 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
6156 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
6112 PyErr_Clear();
6157 PyErr_Clear();
6113 if (obj && !PythonQtSlotFunction_Check(obj)) {
6158 if (obj && !PythonQtSlotFunction_Check(obj)) {
6114 static const char* argumentList[] ={"bool" , "bool"};
6159 static const char* argumentList[] ={"bool" , "bool"};
6115 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6160 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6116 bool returnValue;
6161 bool returnValue;
6117 void* args[2] = {NULL, (void*)&next};
6162 void* args[2] = {NULL, (void*)&next};
6118 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6163 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6119 if (result) {
6164 if (result) {
6120 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6165 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6121 if (args[0]!=&returnValue) {
6166 if (args[0]!=&returnValue) {
6122 if (args[0]==NULL) {
6167 if (args[0]==NULL) {
6123 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
6168 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
6124 } else {
6169 } else {
6125 returnValue = *((bool*)args[0]);
6170 returnValue = *((bool*)args[0]);
6126 }
6171 }
6127 }
6172 }
6128 }
6173 }
6129 if (result) { Py_DECREF(result); }
6174 if (result) { Py_DECREF(result); }
6130 Py_DECREF(obj);
6175 Py_DECREF(obj);
6131 return returnValue;
6176 return returnValue;
6132 }
6177 }
6133 }
6178 }
6134 return elfInfoWdgt::focusNextPrevChild(next);
6179 return elfInfoWdgt::focusNextPrevChild(next);
6135 }
6180 }
6136 void PythonQtShell_elfInfoWdgt::focusOutEvent(QFocusEvent* arg__1)
6181 void PythonQtShell_elfInfoWdgt::focusOutEvent(QFocusEvent* arg__1)
6137 {
6182 {
6138 if (_wrapper) {
6183 if (_wrapper) {
6139 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
6184 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
6140 PyErr_Clear();
6185 PyErr_Clear();
6141 if (obj && !PythonQtSlotFunction_Check(obj)) {
6186 if (obj && !PythonQtSlotFunction_Check(obj)) {
6142 static const char* argumentList[] ={"" , "QFocusEvent*"};
6187 static const char* argumentList[] ={"" , "QFocusEvent*"};
6143 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6188 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6144 void* args[2] = {NULL, (void*)&arg__1};
6189 void* args[2] = {NULL, (void*)&arg__1};
6145 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6190 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6146 if (result) { Py_DECREF(result); }
6191 if (result) { Py_DECREF(result); }
6147 Py_DECREF(obj);
6192 Py_DECREF(obj);
6148 return;
6193 return;
6149 }
6194 }
6150 }
6195 }
6151 elfInfoWdgt::focusOutEvent(arg__1);
6196 elfInfoWdgt::focusOutEvent(arg__1);
6152 }
6197 }
6153 bool PythonQtShell_elfInfoWdgt::hasHeightForWidth() const
6198 bool PythonQtShell_elfInfoWdgt::hasHeightForWidth() const
6154 {
6199 {
6155 if (_wrapper) {
6200 if (_wrapper) {
6156 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
6201 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
6157 PyErr_Clear();
6202 PyErr_Clear();
6158 if (obj && !PythonQtSlotFunction_Check(obj)) {
6203 if (obj && !PythonQtSlotFunction_Check(obj)) {
6159 static const char* argumentList[] ={"bool"};
6204 static const char* argumentList[] ={"bool"};
6160 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6205 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6161 bool returnValue;
6206 bool returnValue;
6162 void* args[1] = {NULL};
6207 void* args[1] = {NULL};
6163 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6208 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6164 if (result) {
6209 if (result) {
6165 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6210 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6166 if (args[0]!=&returnValue) {
6211 if (args[0]!=&returnValue) {
6167 if (args[0]==NULL) {
6212 if (args[0]==NULL) {
6168 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
6213 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
6169 } else {
6214 } else {
6170 returnValue = *((bool*)args[0]);
6215 returnValue = *((bool*)args[0]);
6171 }
6216 }
6172 }
6217 }
6173 }
6218 }
6174 if (result) { Py_DECREF(result); }
6219 if (result) { Py_DECREF(result); }
6175 Py_DECREF(obj);
6220 Py_DECREF(obj);
6176 return returnValue;
6221 return returnValue;
6177 }
6222 }
6178 }
6223 }
6179 return elfInfoWdgt::hasHeightForWidth();
6224 return elfInfoWdgt::hasHeightForWidth();
6180 }
6225 }
6181 int PythonQtShell_elfInfoWdgt::heightForWidth(int arg__1) const
6226 int PythonQtShell_elfInfoWdgt::heightForWidth(int arg__1) const
6182 {
6227 {
6183 if (_wrapper) {
6228 if (_wrapper) {
6184 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
6229 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
6185 PyErr_Clear();
6230 PyErr_Clear();
6186 if (obj && !PythonQtSlotFunction_Check(obj)) {
6231 if (obj && !PythonQtSlotFunction_Check(obj)) {
6187 static const char* argumentList[] ={"int" , "int"};
6232 static const char* argumentList[] ={"int" , "int"};
6188 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6233 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6189 int returnValue;
6234 int returnValue;
6190 void* args[2] = {NULL, (void*)&arg__1};
6235 void* args[2] = {NULL, (void*)&arg__1};
6191 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6236 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6192 if (result) {
6237 if (result) {
6193 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6238 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6194 if (args[0]!=&returnValue) {
6239 if (args[0]!=&returnValue) {
6195 if (args[0]==NULL) {
6240 if (args[0]==NULL) {
6196 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
6241 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
6197 } else {
6242 } else {
6198 returnValue = *((int*)args[0]);
6243 returnValue = *((int*)args[0]);
6199 }
6244 }
6200 }
6245 }
6201 }
6246 }
6202 if (result) { Py_DECREF(result); }
6247 if (result) { Py_DECREF(result); }
6203 Py_DECREF(obj);
6248 Py_DECREF(obj);
6204 return returnValue;
6249 return returnValue;
6205 }
6250 }
6206 }
6251 }
6207 return elfInfoWdgt::heightForWidth(arg__1);
6252 return elfInfoWdgt::heightForWidth(arg__1);
6208 }
6253 }
6209 void PythonQtShell_elfInfoWdgt::hideEvent(QHideEvent* arg__1)
6254 void PythonQtShell_elfInfoWdgt::hideEvent(QHideEvent* arg__1)
6210 {
6255 {
6211 if (_wrapper) {
6256 if (_wrapper) {
6212 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
6257 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
6213 PyErr_Clear();
6258 PyErr_Clear();
6214 if (obj && !PythonQtSlotFunction_Check(obj)) {
6259 if (obj && !PythonQtSlotFunction_Check(obj)) {
6215 static const char* argumentList[] ={"" , "QHideEvent*"};
6260 static const char* argumentList[] ={"" , "QHideEvent*"};
6216 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6261 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6217 void* args[2] = {NULL, (void*)&arg__1};
6262 void* args[2] = {NULL, (void*)&arg__1};
6218 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6263 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6219 if (result) { Py_DECREF(result); }
6264 if (result) { Py_DECREF(result); }
6220 Py_DECREF(obj);
6265 Py_DECREF(obj);
6221 return;
6266 return;
6222 }
6267 }
6223 }
6268 }
6224 elfInfoWdgt::hideEvent(arg__1);
6269 elfInfoWdgt::hideEvent(arg__1);
6225 }
6270 }
6226 void PythonQtShell_elfInfoWdgt::initPainter(QPainter* painter) const
6271 void PythonQtShell_elfInfoWdgt::initPainter(QPainter* painter) const
6227 {
6272 {
6228 if (_wrapper) {
6273 if (_wrapper) {
6229 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
6274 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
6230 PyErr_Clear();
6275 PyErr_Clear();
6231 if (obj && !PythonQtSlotFunction_Check(obj)) {
6276 if (obj && !PythonQtSlotFunction_Check(obj)) {
6232 static const char* argumentList[] ={"" , "QPainter*"};
6277 static const char* argumentList[] ={"" , "QPainter*"};
6233 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6278 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6234 void* args[2] = {NULL, (void*)&painter};
6279 void* args[2] = {NULL, (void*)&painter};
6235 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6280 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6236 if (result) { Py_DECREF(result); }
6281 if (result) { Py_DECREF(result); }
6237 Py_DECREF(obj);
6282 Py_DECREF(obj);
6238 return;
6283 return;
6239 }
6284 }
6240 }
6285 }
6241 elfInfoWdgt::initPainter(painter);
6286 elfInfoWdgt::initPainter(painter);
6242 }
6287 }
6243 void PythonQtShell_elfInfoWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
6288 void PythonQtShell_elfInfoWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
6244 {
6289 {
6245 if (_wrapper) {
6290 if (_wrapper) {
6246 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
6291 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
6247 PyErr_Clear();
6292 PyErr_Clear();
6248 if (obj && !PythonQtSlotFunction_Check(obj)) {
6293 if (obj && !PythonQtSlotFunction_Check(obj)) {
6249 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
6294 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
6250 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6295 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6251 void* args[2] = {NULL, (void*)&arg__1};
6296 void* args[2] = {NULL, (void*)&arg__1};
6252 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6297 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6253 if (result) { Py_DECREF(result); }
6298 if (result) { Py_DECREF(result); }
6254 Py_DECREF(obj);
6299 Py_DECREF(obj);
6255 return;
6300 return;
6256 }
6301 }
6257 }
6302 }
6258 elfInfoWdgt::inputMethodEvent(arg__1);
6303 elfInfoWdgt::inputMethodEvent(arg__1);
6259 }
6304 }
6260 QVariant PythonQtShell_elfInfoWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
6305 QVariant PythonQtShell_elfInfoWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
6261 {
6306 {
6262 if (_wrapper) {
6307 if (_wrapper) {
6263 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
6308 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
6264 PyErr_Clear();
6309 PyErr_Clear();
6265 if (obj && !PythonQtSlotFunction_Check(obj)) {
6310 if (obj && !PythonQtSlotFunction_Check(obj)) {
6266 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
6311 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
6267 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6312 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6268 QVariant returnValue;
6313 QVariant returnValue;
6269 void* args[2] = {NULL, (void*)&arg__1};
6314 void* args[2] = {NULL, (void*)&arg__1};
6270 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6315 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6271 if (result) {
6316 if (result) {
6272 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6317 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6273 if (args[0]!=&returnValue) {
6318 if (args[0]!=&returnValue) {
6274 if (args[0]==NULL) {
6319 if (args[0]==NULL) {
6275 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
6320 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
6276 } else {
6321 } else {
6277 returnValue = *((QVariant*)args[0]);
6322 returnValue = *((QVariant*)args[0]);
6278 }
6323 }
6279 }
6324 }
6280 }
6325 }
6281 if (result) { Py_DECREF(result); }
6326 if (result) { Py_DECREF(result); }
6282 Py_DECREF(obj);
6327 Py_DECREF(obj);
6283 return returnValue;
6328 return returnValue;
6284 }
6329 }
6285 }
6330 }
6286 return elfInfoWdgt::inputMethodQuery(arg__1);
6331 return elfInfoWdgt::inputMethodQuery(arg__1);
6287 }
6332 }
6288 void PythonQtShell_elfInfoWdgt::keyPressEvent(QKeyEvent* arg__1)
6333 void PythonQtShell_elfInfoWdgt::keyPressEvent(QKeyEvent* arg__1)
6289 {
6334 {
6290 if (_wrapper) {
6335 if (_wrapper) {
6291 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
6336 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
6292 PyErr_Clear();
6337 PyErr_Clear();
6293 if (obj && !PythonQtSlotFunction_Check(obj)) {
6338 if (obj && !PythonQtSlotFunction_Check(obj)) {
6294 static const char* argumentList[] ={"" , "QKeyEvent*"};
6339 static const char* argumentList[] ={"" , "QKeyEvent*"};
6295 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6340 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6296 void* args[2] = {NULL, (void*)&arg__1};
6341 void* args[2] = {NULL, (void*)&arg__1};
6297 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6342 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6298 if (result) { Py_DECREF(result); }
6343 if (result) { Py_DECREF(result); }
6299 Py_DECREF(obj);
6344 Py_DECREF(obj);
6300 return;
6345 return;
6301 }
6346 }
6302 }
6347 }
6303 elfInfoWdgt::keyPressEvent(arg__1);
6348 elfInfoWdgt::keyPressEvent(arg__1);
6304 }
6349 }
6305 void PythonQtShell_elfInfoWdgt::keyReleaseEvent(QKeyEvent* arg__1)
6350 void PythonQtShell_elfInfoWdgt::keyReleaseEvent(QKeyEvent* arg__1)
6306 {
6351 {
6307 if (_wrapper) {
6352 if (_wrapper) {
6308 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
6353 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
6309 PyErr_Clear();
6354 PyErr_Clear();
6310 if (obj && !PythonQtSlotFunction_Check(obj)) {
6355 if (obj && !PythonQtSlotFunction_Check(obj)) {
6311 static const char* argumentList[] ={"" , "QKeyEvent*"};
6356 static const char* argumentList[] ={"" , "QKeyEvent*"};
6312 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6357 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6313 void* args[2] = {NULL, (void*)&arg__1};
6358 void* args[2] = {NULL, (void*)&arg__1};
6314 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6359 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6315 if (result) { Py_DECREF(result); }
6360 if (result) { Py_DECREF(result); }
6316 Py_DECREF(obj);
6361 Py_DECREF(obj);
6317 return;
6362 return;
6318 }
6363 }
6319 }
6364 }
6320 elfInfoWdgt::keyReleaseEvent(arg__1);
6365 elfInfoWdgt::keyReleaseEvent(arg__1);
6321 }
6366 }
6322 void PythonQtShell_elfInfoWdgt::leaveEvent(QEvent* arg__1)
6367 void PythonQtShell_elfInfoWdgt::leaveEvent(QEvent* arg__1)
6323 {
6368 {
6324 if (_wrapper) {
6369 if (_wrapper) {
6325 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
6370 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
6326 PyErr_Clear();
6371 PyErr_Clear();
6327 if (obj && !PythonQtSlotFunction_Check(obj)) {
6372 if (obj && !PythonQtSlotFunction_Check(obj)) {
6328 static const char* argumentList[] ={"" , "QEvent*"};
6373 static const char* argumentList[] ={"" , "QEvent*"};
6329 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6374 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6330 void* args[2] = {NULL, (void*)&arg__1};
6375 void* args[2] = {NULL, (void*)&arg__1};
6331 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6376 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6332 if (result) { Py_DECREF(result); }
6377 if (result) { Py_DECREF(result); }
6333 Py_DECREF(obj);
6378 Py_DECREF(obj);
6334 return;
6379 return;
6335 }
6380 }
6336 }
6381 }
6337 elfInfoWdgt::leaveEvent(arg__1);
6382 elfInfoWdgt::leaveEvent(arg__1);
6338 }
6383 }
6339 int PythonQtShell_elfInfoWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
6384 int PythonQtShell_elfInfoWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
6340 {
6385 {
6341 if (_wrapper) {
6386 if (_wrapper) {
6342 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
6387 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
6343 PyErr_Clear();
6388 PyErr_Clear();
6344 if (obj && !PythonQtSlotFunction_Check(obj)) {
6389 if (obj && !PythonQtSlotFunction_Check(obj)) {
6345 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
6390 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
6346 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6391 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6347 int returnValue;
6392 int returnValue;
6348 void* args[2] = {NULL, (void*)&arg__1};
6393 void* args[2] = {NULL, (void*)&arg__1};
6349 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6394 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6350 if (result) {
6395 if (result) {
6351 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6396 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6352 if (args[0]!=&returnValue) {
6397 if (args[0]!=&returnValue) {
6353 if (args[0]==NULL) {
6398 if (args[0]==NULL) {
6354 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
6399 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
6355 } else {
6400 } else {
6356 returnValue = *((int*)args[0]);
6401 returnValue = *((int*)args[0]);
6357 }
6402 }
6358 }
6403 }
6359 }
6404 }
6360 if (result) { Py_DECREF(result); }
6405 if (result) { Py_DECREF(result); }
6361 Py_DECREF(obj);
6406 Py_DECREF(obj);
6362 return returnValue;
6407 return returnValue;
6363 }
6408 }
6364 }
6409 }
6365 return elfInfoWdgt::metric(arg__1);
6410 return elfInfoWdgt::metric(arg__1);
6366 }
6411 }
6367 QSize PythonQtShell_elfInfoWdgt::minimumSizeHint() const
6412 QSize PythonQtShell_elfInfoWdgt::minimumSizeHint() const
6368 {
6413 {
6369 if (_wrapper) {
6414 if (_wrapper) {
6370 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
6415 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
6371 PyErr_Clear();
6416 PyErr_Clear();
6372 if (obj && !PythonQtSlotFunction_Check(obj)) {
6417 if (obj && !PythonQtSlotFunction_Check(obj)) {
6373 static const char* argumentList[] ={"QSize"};
6418 static const char* argumentList[] ={"QSize"};
6374 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6419 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6375 QSize returnValue;
6420 QSize returnValue;
6376 void* args[1] = {NULL};
6421 void* args[1] = {NULL};
6377 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6422 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6378 if (result) {
6423 if (result) {
6379 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6424 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6380 if (args[0]!=&returnValue) {
6425 if (args[0]!=&returnValue) {
6381 if (args[0]==NULL) {
6426 if (args[0]==NULL) {
6382 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
6427 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
6383 } else {
6428 } else {
6384 returnValue = *((QSize*)args[0]);
6429 returnValue = *((QSize*)args[0]);
6385 }
6430 }
6386 }
6431 }
6387 }
6432 }
6388 if (result) { Py_DECREF(result); }
6433 if (result) { Py_DECREF(result); }
6389 Py_DECREF(obj);
6434 Py_DECREF(obj);
6390 return returnValue;
6435 return returnValue;
6391 }
6436 }
6392 }
6437 }
6393 return elfInfoWdgt::minimumSizeHint();
6438 return elfInfoWdgt::minimumSizeHint();
6394 }
6439 }
6395 void PythonQtShell_elfInfoWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
6440 void PythonQtShell_elfInfoWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
6396 {
6441 {
6397 if (_wrapper) {
6442 if (_wrapper) {
6398 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
6443 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
6399 PyErr_Clear();
6444 PyErr_Clear();
6400 if (obj && !PythonQtSlotFunction_Check(obj)) {
6445 if (obj && !PythonQtSlotFunction_Check(obj)) {
6401 static const char* argumentList[] ={"" , "QMouseEvent*"};
6446 static const char* argumentList[] ={"" , "QMouseEvent*"};
6402 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6447 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6403 void* args[2] = {NULL, (void*)&arg__1};
6448 void* args[2] = {NULL, (void*)&arg__1};
6404 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6449 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6405 if (result) { Py_DECREF(result); }
6450 if (result) { Py_DECREF(result); }
6406 Py_DECREF(obj);
6451 Py_DECREF(obj);
6407 return;
6452 return;
6408 }
6453 }
6409 }
6454 }
6410 elfInfoWdgt::mouseDoubleClickEvent(arg__1);
6455 elfInfoWdgt::mouseDoubleClickEvent(arg__1);
6411 }
6456 }
6412 void PythonQtShell_elfInfoWdgt::mouseMoveEvent(QMouseEvent* arg__1)
6457 void PythonQtShell_elfInfoWdgt::mouseMoveEvent(QMouseEvent* arg__1)
6413 {
6458 {
6414 if (_wrapper) {
6459 if (_wrapper) {
6415 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
6460 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
6416 PyErr_Clear();
6461 PyErr_Clear();
6417 if (obj && !PythonQtSlotFunction_Check(obj)) {
6462 if (obj && !PythonQtSlotFunction_Check(obj)) {
6418 static const char* argumentList[] ={"" , "QMouseEvent*"};
6463 static const char* argumentList[] ={"" , "QMouseEvent*"};
6419 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6464 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6420 void* args[2] = {NULL, (void*)&arg__1};
6465 void* args[2] = {NULL, (void*)&arg__1};
6421 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6466 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6422 if (result) { Py_DECREF(result); }
6467 if (result) { Py_DECREF(result); }
6423 Py_DECREF(obj);
6468 Py_DECREF(obj);
6424 return;
6469 return;
6425 }
6470 }
6426 }
6471 }
6427 elfInfoWdgt::mouseMoveEvent(arg__1);
6472 elfInfoWdgt::mouseMoveEvent(arg__1);
6428 }
6473 }
6429 void PythonQtShell_elfInfoWdgt::mousePressEvent(QMouseEvent* arg__1)
6474 void PythonQtShell_elfInfoWdgt::mousePressEvent(QMouseEvent* arg__1)
6430 {
6475 {
6431 if (_wrapper) {
6476 if (_wrapper) {
6432 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
6477 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
6433 PyErr_Clear();
6478 PyErr_Clear();
6434 if (obj && !PythonQtSlotFunction_Check(obj)) {
6479 if (obj && !PythonQtSlotFunction_Check(obj)) {
6435 static const char* argumentList[] ={"" , "QMouseEvent*"};
6480 static const char* argumentList[] ={"" , "QMouseEvent*"};
6436 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6481 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6437 void* args[2] = {NULL, (void*)&arg__1};
6482 void* args[2] = {NULL, (void*)&arg__1};
6438 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6483 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6439 if (result) { Py_DECREF(result); }
6484 if (result) { Py_DECREF(result); }
6440 Py_DECREF(obj);
6485 Py_DECREF(obj);
6441 return;
6486 return;
6442 }
6487 }
6443 }
6488 }
6444 elfInfoWdgt::mousePressEvent(arg__1);
6489 elfInfoWdgt::mousePressEvent(arg__1);
6445 }
6490 }
6446 void PythonQtShell_elfInfoWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
6491 void PythonQtShell_elfInfoWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
6447 {
6492 {
6448 if (_wrapper) {
6493 if (_wrapper) {
6449 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
6494 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
6450 PyErr_Clear();
6495 PyErr_Clear();
6451 if (obj && !PythonQtSlotFunction_Check(obj)) {
6496 if (obj && !PythonQtSlotFunction_Check(obj)) {
6452 static const char* argumentList[] ={"" , "QMouseEvent*"};
6497 static const char* argumentList[] ={"" , "QMouseEvent*"};
6453 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6498 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6454 void* args[2] = {NULL, (void*)&arg__1};
6499 void* args[2] = {NULL, (void*)&arg__1};
6455 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6500 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6456 if (result) { Py_DECREF(result); }
6501 if (result) { Py_DECREF(result); }
6457 Py_DECREF(obj);
6502 Py_DECREF(obj);
6458 return;
6503 return;
6459 }
6504 }
6460 }
6505 }
6461 elfInfoWdgt::mouseReleaseEvent(arg__1);
6506 elfInfoWdgt::mouseReleaseEvent(arg__1);
6462 }
6507 }
6463 void PythonQtShell_elfInfoWdgt::moveEvent(QMoveEvent* arg__1)
6508 void PythonQtShell_elfInfoWdgt::moveEvent(QMoveEvent* arg__1)
6464 {
6509 {
6465 if (_wrapper) {
6510 if (_wrapper) {
6466 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
6511 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
6467 PyErr_Clear();
6512 PyErr_Clear();
6468 if (obj && !PythonQtSlotFunction_Check(obj)) {
6513 if (obj && !PythonQtSlotFunction_Check(obj)) {
6469 static const char* argumentList[] ={"" , "QMoveEvent*"};
6514 static const char* argumentList[] ={"" , "QMoveEvent*"};
6470 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6515 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6471 void* args[2] = {NULL, (void*)&arg__1};
6516 void* args[2] = {NULL, (void*)&arg__1};
6472 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6517 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6473 if (result) { Py_DECREF(result); }
6518 if (result) { Py_DECREF(result); }
6474 Py_DECREF(obj);
6519 Py_DECREF(obj);
6475 return;
6520 return;
6476 }
6521 }
6477 }
6522 }
6478 elfInfoWdgt::moveEvent(arg__1);
6523 elfInfoWdgt::moveEvent(arg__1);
6479 }
6524 }
6480 bool PythonQtShell_elfInfoWdgt::nativeEvent(const QByteArray& eventType, void* message, long* result)
6525 bool PythonQtShell_elfInfoWdgt::nativeEvent(const QByteArray& eventType, void* message, long* result)
6481 {
6526 {
6482 if (_wrapper) {
6527 if (_wrapper) {
6483 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
6528 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
6484 PyErr_Clear();
6529 PyErr_Clear();
6485 if (obj && !PythonQtSlotFunction_Check(obj)) {
6530 if (obj && !PythonQtSlotFunction_Check(obj)) {
6486 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
6531 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
6487 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
6532 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
6488 bool returnValue;
6533 bool returnValue;
6489 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
6534 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
6490 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6535 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6491 if (result) {
6536 if (result) {
6492 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6537 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6493 if (args[0]!=&returnValue) {
6538 if (args[0]!=&returnValue) {
6494 if (args[0]==NULL) {
6539 if (args[0]==NULL) {
6495 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
6540 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
6496 } else {
6541 } else {
6497 returnValue = *((bool*)args[0]);
6542 returnValue = *((bool*)args[0]);
6498 }
6543 }
6499 }
6544 }
6500 }
6545 }
6501 if (result) { Py_DECREF(result); }
6546 if (result) { Py_DECREF(result); }
6502 Py_DECREF(obj);
6547 Py_DECREF(obj);
6503 return returnValue;
6548 return returnValue;
6504 }
6549 }
6505 }
6550 }
6506 return elfInfoWdgt::nativeEvent(eventType, message, result);
6551 return elfInfoWdgt::nativeEvent(eventType, message, result);
6507 }
6552 }
6508 QPaintEngine* PythonQtShell_elfInfoWdgt::paintEngine() const
6553 QPaintEngine* PythonQtShell_elfInfoWdgt::paintEngine() const
6509 {
6554 {
6510 if (_wrapper) {
6555 if (_wrapper) {
6511 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
6556 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
6512 PyErr_Clear();
6557 PyErr_Clear();
6513 if (obj && !PythonQtSlotFunction_Check(obj)) {
6558 if (obj && !PythonQtSlotFunction_Check(obj)) {
6514 static const char* argumentList[] ={"QPaintEngine*"};
6559 static const char* argumentList[] ={"QPaintEngine*"};
6515 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6560 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6516 QPaintEngine* returnValue;
6561 QPaintEngine* returnValue;
6517 void* args[1] = {NULL};
6562 void* args[1] = {NULL};
6518 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6563 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6519 if (result) {
6564 if (result) {
6520 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6565 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6521 if (args[0]!=&returnValue) {
6566 if (args[0]!=&returnValue) {
6522 if (args[0]==NULL) {
6567 if (args[0]==NULL) {
6523 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
6568 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
6524 } else {
6569 } else {
6525 returnValue = *((QPaintEngine**)args[0]);
6570 returnValue = *((QPaintEngine**)args[0]);
6526 }
6571 }
6527 }
6572 }
6528 }
6573 }
6529 if (result) { Py_DECREF(result); }
6574 if (result) { Py_DECREF(result); }
6530 Py_DECREF(obj);
6575 Py_DECREF(obj);
6531 return returnValue;
6576 return returnValue;
6532 }
6577 }
6533 }
6578 }
6534 return elfInfoWdgt::paintEngine();
6579 return elfInfoWdgt::paintEngine();
6535 }
6580 }
6536 void PythonQtShell_elfInfoWdgt::paintEvent(QPaintEvent* arg__1)
6581 void PythonQtShell_elfInfoWdgt::paintEvent(QPaintEvent* arg__1)
6537 {
6582 {
6538 if (_wrapper) {
6583 if (_wrapper) {
6539 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
6584 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
6540 PyErr_Clear();
6585 PyErr_Clear();
6541 if (obj && !PythonQtSlotFunction_Check(obj)) {
6586 if (obj && !PythonQtSlotFunction_Check(obj)) {
6542 static const char* argumentList[] ={"" , "QPaintEvent*"};
6587 static const char* argumentList[] ={"" , "QPaintEvent*"};
6543 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6588 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6544 void* args[2] = {NULL, (void*)&arg__1};
6589 void* args[2] = {NULL, (void*)&arg__1};
6545 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6590 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6546 if (result) { Py_DECREF(result); }
6591 if (result) { Py_DECREF(result); }
6547 Py_DECREF(obj);
6592 Py_DECREF(obj);
6548 return;
6593 return;
6549 }
6594 }
6550 }
6595 }
6551 elfInfoWdgt::paintEvent(arg__1);
6596 elfInfoWdgt::paintEvent(arg__1);
6552 }
6597 }
6553 QPaintDevice* PythonQtShell_elfInfoWdgt::redirected(QPoint* offset) const
6598 QPaintDevice* PythonQtShell_elfInfoWdgt::redirected(QPoint* offset) const
6554 {
6599 {
6555 if (_wrapper) {
6600 if (_wrapper) {
6556 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
6601 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
6557 PyErr_Clear();
6602 PyErr_Clear();
6558 if (obj && !PythonQtSlotFunction_Check(obj)) {
6603 if (obj && !PythonQtSlotFunction_Check(obj)) {
6559 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
6604 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
6560 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6605 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6561 QPaintDevice* returnValue;
6606 QPaintDevice* returnValue;
6562 void* args[2] = {NULL, (void*)&offset};
6607 void* args[2] = {NULL, (void*)&offset};
6563 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6608 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6564 if (result) {
6609 if (result) {
6565 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6610 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6566 if (args[0]!=&returnValue) {
6611 if (args[0]!=&returnValue) {
6567 if (args[0]==NULL) {
6612 if (args[0]==NULL) {
6568 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
6613 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
6569 } else {
6614 } else {
6570 returnValue = *((QPaintDevice**)args[0]);
6615 returnValue = *((QPaintDevice**)args[0]);
6571 }
6616 }
6572 }
6617 }
6573 }
6618 }
6574 if (result) { Py_DECREF(result); }
6619 if (result) { Py_DECREF(result); }
6575 Py_DECREF(obj);
6620 Py_DECREF(obj);
6576 return returnValue;
6621 return returnValue;
6577 }
6622 }
6578 }
6623 }
6579 return elfInfoWdgt::redirected(offset);
6624 return elfInfoWdgt::redirected(offset);
6580 }
6625 }
6581 void PythonQtShell_elfInfoWdgt::resizeEvent(QResizeEvent* arg__1)
6626 void PythonQtShell_elfInfoWdgt::resizeEvent(QResizeEvent* arg__1)
6582 {
6627 {
6583 if (_wrapper) {
6628 if (_wrapper) {
6584 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
6629 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
6585 PyErr_Clear();
6630 PyErr_Clear();
6586 if (obj && !PythonQtSlotFunction_Check(obj)) {
6631 if (obj && !PythonQtSlotFunction_Check(obj)) {
6587 static const char* argumentList[] ={"" , "QResizeEvent*"};
6632 static const char* argumentList[] ={"" , "QResizeEvent*"};
6588 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6633 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6589 void* args[2] = {NULL, (void*)&arg__1};
6634 void* args[2] = {NULL, (void*)&arg__1};
6590 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6635 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6591 if (result) { Py_DECREF(result); }
6636 if (result) { Py_DECREF(result); }
6592 Py_DECREF(obj);
6637 Py_DECREF(obj);
6593 return;
6638 return;
6594 }
6639 }
6595 }
6640 }
6596 elfInfoWdgt::resizeEvent(arg__1);
6641 elfInfoWdgt::resizeEvent(arg__1);
6597 }
6642 }
6598 QPainter* PythonQtShell_elfInfoWdgt::sharedPainter() const
6643 QPainter* PythonQtShell_elfInfoWdgt::sharedPainter() const
6599 {
6644 {
6600 if (_wrapper) {
6645 if (_wrapper) {
6601 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
6646 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
6602 PyErr_Clear();
6647 PyErr_Clear();
6603 if (obj && !PythonQtSlotFunction_Check(obj)) {
6648 if (obj && !PythonQtSlotFunction_Check(obj)) {
6604 static const char* argumentList[] ={"QPainter*"};
6649 static const char* argumentList[] ={"QPainter*"};
6605 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6650 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6606 QPainter* returnValue;
6651 QPainter* returnValue;
6607 void* args[1] = {NULL};
6652 void* args[1] = {NULL};
6608 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6653 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6609 if (result) {
6654 if (result) {
6610 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6655 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6611 if (args[0]!=&returnValue) {
6656 if (args[0]!=&returnValue) {
6612 if (args[0]==NULL) {
6657 if (args[0]==NULL) {
6613 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
6658 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
6614 } else {
6659 } else {
6615 returnValue = *((QPainter**)args[0]);
6660 returnValue = *((QPainter**)args[0]);
6616 }
6661 }
6617 }
6662 }
6618 }
6663 }
6619 if (result) { Py_DECREF(result); }
6664 if (result) { Py_DECREF(result); }
6620 Py_DECREF(obj);
6665 Py_DECREF(obj);
6621 return returnValue;
6666 return returnValue;
6622 }
6667 }
6623 }
6668 }
6624 return elfInfoWdgt::sharedPainter();
6669 return elfInfoWdgt::sharedPainter();
6625 }
6670 }
6626 void PythonQtShell_elfInfoWdgt::showEvent(QShowEvent* arg__1)
6671 void PythonQtShell_elfInfoWdgt::showEvent(QShowEvent* arg__1)
6627 {
6672 {
6628 if (_wrapper) {
6673 if (_wrapper) {
6629 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
6674 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
6630 PyErr_Clear();
6675 PyErr_Clear();
6631 if (obj && !PythonQtSlotFunction_Check(obj)) {
6676 if (obj && !PythonQtSlotFunction_Check(obj)) {
6632 static const char* argumentList[] ={"" , "QShowEvent*"};
6677 static const char* argumentList[] ={"" , "QShowEvent*"};
6633 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6678 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6634 void* args[2] = {NULL, (void*)&arg__1};
6679 void* args[2] = {NULL, (void*)&arg__1};
6635 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6680 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6636 if (result) { Py_DECREF(result); }
6681 if (result) { Py_DECREF(result); }
6637 Py_DECREF(obj);
6682 Py_DECREF(obj);
6638 return;
6683 return;
6639 }
6684 }
6640 }
6685 }
6641 elfInfoWdgt::showEvent(arg__1);
6686 elfInfoWdgt::showEvent(arg__1);
6642 }
6687 }
6643 QSize PythonQtShell_elfInfoWdgt::sizeHint() const
6688 QSize PythonQtShell_elfInfoWdgt::sizeHint() const
6644 {
6689 {
6645 if (_wrapper) {
6690 if (_wrapper) {
6646 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
6691 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
6647 PyErr_Clear();
6692 PyErr_Clear();
6648 if (obj && !PythonQtSlotFunction_Check(obj)) {
6693 if (obj && !PythonQtSlotFunction_Check(obj)) {
6649 static const char* argumentList[] ={"QSize"};
6694 static const char* argumentList[] ={"QSize"};
6650 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6695 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6651 QSize returnValue;
6696 QSize returnValue;
6652 void* args[1] = {NULL};
6697 void* args[1] = {NULL};
6653 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6698 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6654 if (result) {
6699 if (result) {
6655 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6700 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6656 if (args[0]!=&returnValue) {
6701 if (args[0]!=&returnValue) {
6657 if (args[0]==NULL) {
6702 if (args[0]==NULL) {
6658 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
6703 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
6659 } else {
6704 } else {
6660 returnValue = *((QSize*)args[0]);
6705 returnValue = *((QSize*)args[0]);
6661 }
6706 }
6662 }
6707 }
6663 }
6708 }
6664 if (result) { Py_DECREF(result); }
6709 if (result) { Py_DECREF(result); }
6665 Py_DECREF(obj);
6710 Py_DECREF(obj);
6666 return returnValue;
6711 return returnValue;
6667 }
6712 }
6668 }
6713 }
6669 return elfInfoWdgt::sizeHint();
6714 return elfInfoWdgt::sizeHint();
6670 }
6715 }
6671 void PythonQtShell_elfInfoWdgt::tabletEvent(QTabletEvent* arg__1)
6716 void PythonQtShell_elfInfoWdgt::tabletEvent(QTabletEvent* arg__1)
6672 {
6717 {
6673 if (_wrapper) {
6718 if (_wrapper) {
6674 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
6719 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
6675 PyErr_Clear();
6720 PyErr_Clear();
6676 if (obj && !PythonQtSlotFunction_Check(obj)) {
6721 if (obj && !PythonQtSlotFunction_Check(obj)) {
6677 static const char* argumentList[] ={"" , "QTabletEvent*"};
6722 static const char* argumentList[] ={"" , "QTabletEvent*"};
6678 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6723 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6679 void* args[2] = {NULL, (void*)&arg__1};
6724 void* args[2] = {NULL, (void*)&arg__1};
6680 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6725 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6681 if (result) { Py_DECREF(result); }
6726 if (result) { Py_DECREF(result); }
6682 Py_DECREF(obj);
6727 Py_DECREF(obj);
6683 return;
6728 return;
6684 }
6729 }
6685 }
6730 }
6686 elfInfoWdgt::tabletEvent(arg__1);
6731 elfInfoWdgt::tabletEvent(arg__1);
6687 }
6732 }
6688 void PythonQtShell_elfInfoWdgt::timerEvent(QTimerEvent* arg__1)
6733 void PythonQtShell_elfInfoWdgt::timerEvent(QTimerEvent* arg__1)
6689 {
6734 {
6690 if (_wrapper) {
6735 if (_wrapper) {
6691 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
6736 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
6692 PyErr_Clear();
6737 PyErr_Clear();
6693 if (obj && !PythonQtSlotFunction_Check(obj)) {
6738 if (obj && !PythonQtSlotFunction_Check(obj)) {
6694 static const char* argumentList[] ={"" , "QTimerEvent*"};
6739 static const char* argumentList[] ={"" , "QTimerEvent*"};
6695 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6740 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6696 void* args[2] = {NULL, (void*)&arg__1};
6741 void* args[2] = {NULL, (void*)&arg__1};
6697 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6742 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6698 if (result) { Py_DECREF(result); }
6743 if (result) { Py_DECREF(result); }
6699 Py_DECREF(obj);
6744 Py_DECREF(obj);
6700 return;
6745 return;
6701 }
6746 }
6702 }
6747 }
6703 elfInfoWdgt::timerEvent(arg__1);
6748 elfInfoWdgt::timerEvent(arg__1);
6704 }
6749 }
6705 void PythonQtShell_elfInfoWdgt::wheelEvent(QWheelEvent* arg__1)
6750 void PythonQtShell_elfInfoWdgt::wheelEvent(QWheelEvent* arg__1)
6706 {
6751 {
6707 if (_wrapper) {
6752 if (_wrapper) {
6708 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
6753 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
6709 PyErr_Clear();
6754 PyErr_Clear();
6710 if (obj && !PythonQtSlotFunction_Check(obj)) {
6755 if (obj && !PythonQtSlotFunction_Check(obj)) {
6711 static const char* argumentList[] ={"" , "QWheelEvent*"};
6756 static const char* argumentList[] ={"" , "QWheelEvent*"};
6712 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6757 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6713 void* args[2] = {NULL, (void*)&arg__1};
6758 void* args[2] = {NULL, (void*)&arg__1};
6714 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6759 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6715 if (result) { Py_DECREF(result); }
6760 if (result) { Py_DECREF(result); }
6716 Py_DECREF(obj);
6761 Py_DECREF(obj);
6717 return;
6762 return;
6718 }
6763 }
6719 }
6764 }
6720 elfInfoWdgt::wheelEvent(arg__1);
6765 elfInfoWdgt::wheelEvent(arg__1);
6721 }
6766 }
6722 elfInfoWdgt* PythonQtWrapper_elfInfoWdgt::new_elfInfoWdgt(QWidget* parent)
6767 elfInfoWdgt* PythonQtWrapper_elfInfoWdgt::new_elfInfoWdgt(QWidget* parent)
6723 {
6768 {
6724 return new PythonQtShell_elfInfoWdgt(parent); }
6769 return new PythonQtShell_elfInfoWdgt(parent); }
6725
6770
6726
6771
6727
6772
6728 elfparser* PythonQtWrapper_elfparser::new_elfparser()
6773 elfparser* PythonQtWrapper_elfparser::new_elfparser()
6729 {
6774 {
6730 return new elfparser(); }
6775 return new elfparser(); }
6731
6776
6732 int PythonQtWrapper_elfparser::closeFile(elfparser* theWrappedObject)
6777 int PythonQtWrapper_elfparser::closeFile(elfparser* theWrappedObject)
6733 {
6778 {
6734 return ( theWrappedObject->closeFile());
6779 return ( theWrappedObject->closeFile());
6735 }
6780 }
6736
6781
6737 QString PythonQtWrapper_elfparser::getABI(elfparser* theWrappedObject)
6782 QString PythonQtWrapper_elfparser::getABI(elfparser* theWrappedObject)
6738 {
6783 {
6739 return ( theWrappedObject->getABI());
6784 return ( theWrappedObject->getABI());
6740 }
6785 }
6741
6786
6742 QString PythonQtWrapper_elfparser::getArchitecture(elfparser* theWrappedObject)
6787 QString PythonQtWrapper_elfparser::getArchitecture(elfparser* theWrappedObject)
6743 {
6788 {
6744 return ( theWrappedObject->getArchitecture());
6789 return ( theWrappedObject->getArchitecture());
6745 }
6790 }
6746
6791
6747 QString PythonQtWrapper_elfparser::getClass(elfparser* theWrappedObject)
6792 QString PythonQtWrapper_elfparser::getClass(elfparser* theWrappedObject)
6748 {
6793 {
6749 return ( theWrappedObject->getClass());
6794 return ( theWrappedObject->getClass());
6750 }
6795 }
6751
6796
6752 QString PythonQtWrapper_elfparser::getEndianness(elfparser* theWrappedObject)
6797 QString PythonQtWrapper_elfparser::getEndianness(elfparser* theWrappedObject)
6753 {
6798 {
6754 return ( theWrappedObject->getEndianness());
6799 return ( theWrappedObject->getEndianness());
6755 }
6800 }
6756
6801
6757 qint64 PythonQtWrapper_elfparser::getEntryPointAddress(elfparser* theWrappedObject)
6802 qint64 PythonQtWrapper_elfparser::getEntryPointAddress(elfparser* theWrappedObject)
6758 {
6803 {
6759 return ( theWrappedObject->getEntryPointAddress());
6804 return ( theWrappedObject->getEntryPointAddress());
6760 }
6805 }
6761
6806
6762 bool PythonQtWrapper_elfparser::getSectionData(elfparser* theWrappedObject, int index, char** buffer)
6807 bool PythonQtWrapper_elfparser::getSectionData(elfparser* theWrappedObject, int index, char** buffer)
6763 {
6808 {
6764 return ( theWrappedObject->getSectionData(index, buffer));
6809 return ( theWrappedObject->getSectionData(index, buffer));
6765 }
6810 }
6766
6811
6767 qint64 PythonQtWrapper_elfparser::getSectionDatasz(elfparser* theWrappedObject, int index)
6812 qint64 PythonQtWrapper_elfparser::getSectionDatasz(elfparser* theWrappedObject, int index)
6768 {
6813 {
6769 return ( theWrappedObject->getSectionDatasz(index));
6814 return ( theWrappedObject->getSectionDatasz(index));
6770 }
6815 }
6771
6816
6772 qint64 PythonQtWrapper_elfparser::getSectionMemsz(elfparser* theWrappedObject, int index)
6817 qint64 PythonQtWrapper_elfparser::getSectionMemsz(elfparser* theWrappedObject, int index)
6773 {
6818 {
6774 return ( theWrappedObject->getSectionMemsz(index));
6819 return ( theWrappedObject->getSectionMemsz(index));
6775 }
6820 }
6776
6821
6777 QString PythonQtWrapper_elfparser::getSectionName(elfparser* theWrappedObject, int index)
6822 QString PythonQtWrapper_elfparser::getSectionName(elfparser* theWrappedObject, int index)
6778 {
6823 {
6779 return ( theWrappedObject->getSectionName(index));
6824 return ( theWrappedObject->getSectionName(index));
6780 }
6825 }
6781
6826
6782 qint64 PythonQtWrapper_elfparser::getSectionPaddr(elfparser* theWrappedObject, int index)
6827 qint64 PythonQtWrapper_elfparser::getSectionPaddr(elfparser* theWrappedObject, int index)
6783 {
6828 {
6784 return ( theWrappedObject->getSectionPaddr(index));
6829 return ( theWrappedObject->getSectionPaddr(index));
6785 }
6830 }
6786
6831
6787 QString PythonQtWrapper_elfparser::getSectionType(elfparser* theWrappedObject, int index)
6832 QString PythonQtWrapper_elfparser::getSectionType(elfparser* theWrappedObject, int index)
6788 {
6833 {
6789 return ( theWrappedObject->getSectionType(index));
6834 return ( theWrappedObject->getSectionType(index));
6790 }
6835 }
6791
6836
6792 int PythonQtWrapper_elfparser::getSectioncount(elfparser* theWrappedObject)
6837 int PythonQtWrapper_elfparser::getSectioncount(elfparser* theWrappedObject)
6793 {
6838 {
6794 return ( theWrappedObject->getSectioncount());
6839 return ( theWrappedObject->getSectioncount());
6795 }
6840 }
6796
6841
6797 qint64 PythonQtWrapper_elfparser::getSegmentFilesz(elfparser* theWrappedObject, int index)
6842 qint64 PythonQtWrapper_elfparser::getSegmentFilesz(elfparser* theWrappedObject, int index)
6798 {
6843 {
6799 return ( theWrappedObject->getSegmentFilesz(index));
6844 return ( theWrappedObject->getSegmentFilesz(index));
6800 }
6845 }
6801
6846
6802 QString PythonQtWrapper_elfparser::getSegmentFlags(elfparser* theWrappedObject, int index)
6847 QString PythonQtWrapper_elfparser::getSegmentFlags(elfparser* theWrappedObject, int index)
6803 {
6848 {
6804 return ( theWrappedObject->getSegmentFlags(index));
6849 return ( theWrappedObject->getSegmentFlags(index));
6805 }
6850 }
6806
6851
6807 qint64 PythonQtWrapper_elfparser::getSegmentMemsz(elfparser* theWrappedObject, int index)
6852 qint64 PythonQtWrapper_elfparser::getSegmentMemsz(elfparser* theWrappedObject, int index)
6808 {
6853 {
6809 return ( theWrappedObject->getSegmentMemsz(index));
6854 return ( theWrappedObject->getSegmentMemsz(index));
6810 }
6855 }
6811
6856
6812 qint64 PythonQtWrapper_elfparser::getSegmentOffset(elfparser* theWrappedObject, int index)
6857 qint64 PythonQtWrapper_elfparser::getSegmentOffset(elfparser* theWrappedObject, int index)
6813 {
6858 {
6814 return ( theWrappedObject->getSegmentOffset(index));
6859 return ( theWrappedObject->getSegmentOffset(index));
6815 }
6860 }
6816
6861
6817 qint64 PythonQtWrapper_elfparser::getSegmentPaddr(elfparser* theWrappedObject, int index)
6862 qint64 PythonQtWrapper_elfparser::getSegmentPaddr(elfparser* theWrappedObject, int index)
6818 {
6863 {
6819 return ( theWrappedObject->getSegmentPaddr(index));
6864 return ( theWrappedObject->getSegmentPaddr(index));
6820 }
6865 }
6821
6866
6822 QString PythonQtWrapper_elfparser::getSegmentType(elfparser* theWrappedObject, int index)
6867 QString PythonQtWrapper_elfparser::getSegmentType(elfparser* theWrappedObject, int index)
6823 {
6868 {
6824 return ( theWrappedObject->getSegmentType(index));
6869 return ( theWrappedObject->getSegmentType(index));
6825 }
6870 }
6826
6871
6827 qint64 PythonQtWrapper_elfparser::getSegmentVaddr(elfparser* theWrappedObject, int index)
6872 qint64 PythonQtWrapper_elfparser::getSegmentVaddr(elfparser* theWrappedObject, int index)
6828 {
6873 {
6829 return ( theWrappedObject->getSegmentVaddr(index));
6874 return ( theWrappedObject->getSegmentVaddr(index));
6830 }
6875 }
6831
6876
6832 int PythonQtWrapper_elfparser::getSegmentcount(elfparser* theWrappedObject)
6877 int PythonQtWrapper_elfparser::getSegmentcount(elfparser* theWrappedObject)
6833 {
6878 {
6834 return ( theWrappedObject->getSegmentcount());
6879 return ( theWrappedObject->getSegmentcount());
6835 }
6880 }
6836
6881
6837 QString PythonQtWrapper_elfparser::getType(elfparser* theWrappedObject)
6882 QString PythonQtWrapper_elfparser::getType(elfparser* theWrappedObject)
6838 {
6883 {
6839 return ( theWrappedObject->getType());
6884 return ( theWrappedObject->getType());
6840 }
6885 }
6841
6886
6842 qint64 PythonQtWrapper_elfparser::getVersion(elfparser* theWrappedObject)
6887 qint64 PythonQtWrapper_elfparser::getVersion(elfparser* theWrappedObject)
6843 {
6888 {
6844 return ( theWrappedObject->getVersion());
6889 return ( theWrappedObject->getVersion());
6845 }
6890 }
6846
6891
6847 bool PythonQtWrapper_elfparser::static_elfparser_isElf(const QString& File)
6892 bool PythonQtWrapper_elfparser::static_elfparser_isElf(const QString& File)
6848 {
6893 {
6849 return (elfparser::isElf(File));
6894 return (elfparser::isElf(File));
6850 }
6895 }
6851
6896
6852 bool PythonQtWrapper_elfparser::iself(elfparser* theWrappedObject)
6897 bool PythonQtWrapper_elfparser::iself(elfparser* theWrappedObject)
6853 {
6898 {
6854 return ( theWrappedObject->iself());
6899 return ( theWrappedObject->iself());
6855 }
6900 }
6856
6901
6857 bool PythonQtWrapper_elfparser::isopened(elfparser* theWrappedObject)
6902 bool PythonQtWrapper_elfparser::isopened(elfparser* theWrappedObject)
6858 {
6903 {
6859 return ( theWrappedObject->isopened());
6904 return ( theWrappedObject->isopened());
6860 }
6905 }
6861
6906
6862 int PythonQtWrapper_elfparser::setFilename(elfparser* theWrappedObject, const QString& name)
6907 int PythonQtWrapper_elfparser::setFilename(elfparser* theWrappedObject, const QString& name)
6863 {
6908 {
6864 return ( theWrappedObject->setFilename(name));
6909 return ( theWrappedObject->setFilename(name));
6865 }
6910 }
6866
6911
6867
6912
Show file before | Show file after | Hide comments
@@ -1,773 +1,782
1 #include <PythonQt.h>
1 #include <PythonQt.h>
2 #include <QIconEngine>
2 #include <QIconEngine>
3 #include <QObject>
3 #include <QObject>
4 #include <QSpinBox>
4 #include <QSpinBox>
5 #include <QVariant>
5 #include <QVariant>
6 #include <QWidget>
6 #include <QWidget>
7 #include <SocExplorerPlot.h>
7 #include <SocExplorerPlot.h>
8 #include <abstractexecfile.h>
8 #include <abstractexecfile.h>
9 #include <elffile.h>
9 #include <elffile.h>
10 #include <elffilewidget.h>
10 #include <elffilewidget.h>
11 #include <elfinfowdgt.h>
11 #include <elfinfowdgt.h>
12 #include <elfparser.h>
12 #include <elfparser.h>
13 #include <memsizewdgt.h>
13 #include <memsizewdgt.h>
14 #include <qaction.h>
14 #include <qaction.h>
15 #include <qbitmap.h>
15 #include <qbitmap.h>
16 #include <qbytearray.h>
16 #include <qbytearray.h>
17 #include <qcolor.h>
17 #include <qcolor.h>
18 #include <qcoreevent.h>
18 #include <qcoreevent.h>
19 #include <qcursor.h>
19 #include <qcursor.h>
20 #include <qevent.h>
20 #include <qevent.h>
21 #include <qfont.h>
21 #include <qfont.h>
22 #include <qgraphicseffect.h>
22 #include <qgraphicseffect.h>
23 #include <qgraphicsproxywidget.h>
23 #include <qgraphicsproxywidget.h>
24 #include <qhexedit.h>
24 #include <qhexedit.h>
25 #include <qhexspinbox.h>
25 #include <qhexspinbox.h>
26 #include <qkeysequence.h>
26 #include <qkeysequence.h>
27 #include <qlayout.h>
27 #include <qlayout.h>
28 #include <qlineedit.h>
28 #include <qlineedit.h>
29 #include <qlist.h>
29 #include <qlist.h>
30 #include <qlocale.h>
30 #include <qlocale.h>
31 #include <qmargins.h>
31 #include <qmargins.h>
32 #include <qobject.h>
32 #include <qobject.h>
33 #include <qpaintdevice.h>
33 #include <qpaintdevice.h>
34 #include <qpaintengine.h>
34 #include <qpaintengine.h>
35 #include <qpainter.h>
35 #include <qpainter.h>
36 #include <qpalette.h>
36 #include <qpalette.h>
37 #include <qpen.h>
37 #include <qpen.h>
38 #include <qpixmap.h>
38 #include <qpixmap.h>
39 #include <qpoint.h>
39 #include <qpoint.h>
40 #include <qrect.h>
40 #include <qrect.h>
41 #include <qregion.h>
41 #include <qregion.h>
42 #include <qscrollarea.h>
42 #include <qscrollarea.h>
43 #include <qscrollbar.h>
43 #include <qscrollbar.h>
44 #include <qsize.h>
44 #include <qsize.h>
45 #include <qsizepolicy.h>
45 #include <qsizepolicy.h>
46 #include <qspinbox.h>
46 #include <qspinbox.h>
47 #include <qstringlist.h>
47 #include <qstringlist.h>
48 #include <qstyle.h>
48 #include <qstyle.h>
49 #include <qstyleoption.h>
49 #include <qstyleoption.h>
50 #include <qwidget.h>
50 #include <qwidget.h>
51 #include <tcp_terminal_client.h>
51 #include <tcp_terminal_client.h>
52 #include <xbytearray.h>
52 #include <xbytearray.h>
53
53
54
54
55
55
56 class PythonQtShell_ElfFile : public ElfFile
56 class PythonQtShell_ElfFile : public ElfFile
57 {
57 {
58 public:
58 public:
59 PythonQtShell_ElfFile():ElfFile(),_wrapper(NULL) {};
59 PythonQtShell_ElfFile():ElfFile(),_wrapper(NULL) {};
60 PythonQtShell_ElfFile(const QString& File):ElfFile(File),_wrapper(NULL) {};
60 PythonQtShell_ElfFile(const QString& File):ElfFile(File),_wrapper(NULL) {};
61
61
62 ~PythonQtShell_ElfFile();
62 ~PythonQtShell_ElfFile();
63
63
64 virtual int closeFile();
64 virtual int closeFile();
65 virtual QList<codeFragment* > getFragments();
65 virtual QList<codeFragment* > getFragments();
66 virtual bool isopened();
66 virtual bool isopened();
67 virtual bool openFile(const QString& File);
67 virtual bool openFile(const QString& File);
68
68
69 PythonQtInstanceWrapper* _wrapper;
69 PythonQtInstanceWrapper* _wrapper;
70 };
70 };
71
71
72 class PythonQtPublicPromoter_ElfFile : public ElfFile
72 class PythonQtPublicPromoter_ElfFile : public ElfFile
73 { public:
73 { public:
74 inline int promoted_closeFile() { return ElfFile::closeFile(); }
74 inline int promoted_closeFile() { return ElfFile::closeFile(); }
75 inline QList<codeFragment* > promoted_getFragments() { return ElfFile::getFragments(); }
75 inline QList<codeFragment* > promoted_getFragments() { return ElfFile::getFragments(); }
76 inline bool promoted_isopened() { return ElfFile::isopened(); }
76 inline bool promoted_isopened() { return ElfFile::isopened(); }
77 inline bool promoted_openFile(const QString& File) { return ElfFile::openFile(File); }
77 inline bool promoted_openFile(const QString& File) { return ElfFile::openFile(File); }
78 };
78 };
79
79
80 class PythonQtWrapper_ElfFile : public QObject
80 class PythonQtWrapper_ElfFile : public QObject
81 { Q_OBJECT
81 { Q_OBJECT
82 public:
82 public:
83 public slots:
83 public slots:
84 ElfFile* new_ElfFile();
84 ElfFile* new_ElfFile();
85 ElfFile* new_ElfFile(const QString& File);
85 ElfFile* new_ElfFile(const QString& File);
86 void delete_ElfFile(ElfFile* obj) { delete obj; }
86 void delete_ElfFile(ElfFile* obj) { delete obj; }
87 int closeFile(ElfFile* theWrappedObject);
87 int closeFile(ElfFile* theWrappedObject);
88 QString getABI(ElfFile* theWrappedObject);
88 QString getABI(ElfFile* theWrappedObject);
89 QString getArchitecture(ElfFile* theWrappedObject);
89 QString getArchitecture(ElfFile* theWrappedObject);
90 QString getClass(ElfFile* theWrappedObject);
90 QString getClass(ElfFile* theWrappedObject);
91 QString getEndianness(ElfFile* theWrappedObject);
91 QString getEndianness(ElfFile* theWrappedObject);
92 qint64 getEntryPointAddress(ElfFile* theWrappedObject);
92 qint64 getEntryPointAddress(ElfFile* theWrappedObject);
93 QList<codeFragment* > getFragments(ElfFile* theWrappedObject);
93 QList<codeFragment* > getFragments(ElfFile* theWrappedObject);
94 QList<codeFragment* > getFragments(ElfFile* theWrappedObject, QStringList fragmentList);
94 QList<codeFragment* > getFragments(ElfFile* theWrappedObject, QStringList fragmentList);
95 int getSectionCount(ElfFile* theWrappedObject);
95 bool getSectionData(ElfFile* theWrappedObject, int index, char** buffer);
96 bool getSectionData(ElfFile* theWrappedObject, int index, char** buffer);
96 qint64 getSectionDatasz(ElfFile* theWrappedObject, int index);
97 qint64 getSectionDatasz(ElfFile* theWrappedObject, int index);
98 int getSectionIndex(ElfFile* theWrappedObject, QString name);
97 qint64 getSectionMemsz(ElfFile* theWrappedObject, int index);
99 qint64 getSectionMemsz(ElfFile* theWrappedObject, int index);
98 QString getSectionName(ElfFile* theWrappedObject, int index);
100 QString getSectionName(ElfFile* theWrappedObject, int index);
99 qint64 getSectionPaddr(ElfFile* theWrappedObject, int index);
101 qint64 getSectionPaddr(ElfFile* theWrappedObject, int index);
100 QString getSectionType(ElfFile* theWrappedObject, int index);
102 QString getSectionType(ElfFile* theWrappedObject, int index);
101 int getSectioncount(ElfFile* theWrappedObject);
103 int getSegmentCount(ElfFile* theWrappedObject);
102 qint64 getSegmentFilesz(ElfFile* theWrappedObject, int index);
104 qint64 getSegmentFilesz(ElfFile* theWrappedObject, int index);
103 QString getSegmentFlags(ElfFile* theWrappedObject, int index);
105 QString getSegmentFlags(ElfFile* theWrappedObject, int index);
104 qint64 getSegmentMemsz(ElfFile* theWrappedObject, int index);
106 qint64 getSegmentMemsz(ElfFile* theWrappedObject, int index);
105 qint64 getSegmentOffset(ElfFile* theWrappedObject, int index);
107 qint64 getSegmentOffset(ElfFile* theWrappedObject, int index);
106 qint64 getSegmentPaddr(ElfFile* theWrappedObject, int index);
108 qint64 getSegmentPaddr(ElfFile* theWrappedObject, int index);
107 QString getSegmentType(ElfFile* theWrappedObject, int index);
109 QString getSegmentType(ElfFile* theWrappedObject, int index);
108 qint64 getSegmentVaddr(ElfFile* theWrappedObject, int index);
110 qint64 getSegmentVaddr(ElfFile* theWrappedObject, int index);
109 int getSegmentcount(ElfFile* theWrappedObject);
111 quint64 getSymbolAddress(ElfFile* theWrappedObject, int index);
112 int getSymbolCount(ElfFile* theWrappedObject);
113 QString getSymbolLinkType(ElfFile* theWrappedObject, int index);
114 QString getSymbolName(ElfFile* theWrappedObject, int index);
115 int getSymbolSectionIndex(ElfFile* theWrappedObject, int index);
116 QString getSymbolSectionName(ElfFile* theWrappedObject, int index);
117 quint64 getSymbolSize(ElfFile* theWrappedObject, int index);
118 QString getSymbolType(ElfFile* theWrappedObject, int index);
110 QString getType(ElfFile* theWrappedObject);
119 QString getType(ElfFile* theWrappedObject);
111 qint64 getVersion(ElfFile* theWrappedObject);
120 qint64 getVersion(ElfFile* theWrappedObject);
112 bool static_ElfFile_isElf(const QString& File);
121 bool static_ElfFile_isElf(const QString& File);
113 bool iself(ElfFile* theWrappedObject);
122 bool iself(ElfFile* theWrappedObject);
114 bool isopened(ElfFile* theWrappedObject);
123 bool isopened(ElfFile* theWrappedObject);
115 bool openFile(ElfFile* theWrappedObject, const QString& File);
124 bool openFile(ElfFile* theWrappedObject, const QString& File);
116 };
125 };
117
126
118
127
119
128
120
129
121
130
122 class PythonQtShell_MemSizeWdgt : public MemSizeWdgt
131 class PythonQtShell_MemSizeWdgt : public MemSizeWdgt
123 {
132 {
124 public:
133 public:
125 PythonQtShell_MemSizeWdgt(QWidget* parent = 0):MemSizeWdgt(parent),_wrapper(NULL) {};
134 PythonQtShell_MemSizeWdgt(QWidget* parent = 0):MemSizeWdgt(parent),_wrapper(NULL) {};
126 PythonQtShell_MemSizeWdgt(int defaultSize, QWidget* parent = 0):MemSizeWdgt(defaultSize, parent),_wrapper(NULL) {};
135 PythonQtShell_MemSizeWdgt(int defaultSize, QWidget* parent = 0):MemSizeWdgt(defaultSize, parent),_wrapper(NULL) {};
127
136
128 ~PythonQtShell_MemSizeWdgt();
137 ~PythonQtShell_MemSizeWdgt();
129
138
130 virtual void actionEvent(QActionEvent* arg__1);
139 virtual void actionEvent(QActionEvent* arg__1);
131 virtual void changeEvent(QEvent* arg__1);
140 virtual void changeEvent(QEvent* arg__1);
132 virtual void childEvent(QChildEvent* arg__1);
141 virtual void childEvent(QChildEvent* arg__1);
133 virtual void closeEvent(QCloseEvent* arg__1);
142 virtual void closeEvent(QCloseEvent* arg__1);
134 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
143 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
135 virtual void customEvent(QEvent* arg__1);
144 virtual void customEvent(QEvent* arg__1);
136 virtual int devType() const;
145 virtual int devType() const;
137 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
146 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
138 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
147 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
139 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
148 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
140 virtual void dropEvent(QDropEvent* arg__1);
149 virtual void dropEvent(QDropEvent* arg__1);
141 virtual void enterEvent(QEvent* arg__1);
150 virtual void enterEvent(QEvent* arg__1);
142 virtual bool event(QEvent* arg__1);
151 virtual bool event(QEvent* arg__1);
143 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
152 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
144 virtual void focusInEvent(QFocusEvent* arg__1);
153 virtual void focusInEvent(QFocusEvent* arg__1);
145 virtual bool focusNextPrevChild(bool next);
154 virtual bool focusNextPrevChild(bool next);
146 virtual void focusOutEvent(QFocusEvent* arg__1);
155 virtual void focusOutEvent(QFocusEvent* arg__1);
147 virtual bool hasHeightForWidth() const;
156 virtual bool hasHeightForWidth() const;
148 virtual int heightForWidth(int arg__1) const;
157 virtual int heightForWidth(int arg__1) const;
149 virtual void hideEvent(QHideEvent* arg__1);
158 virtual void hideEvent(QHideEvent* arg__1);
150 virtual void initPainter(QPainter* painter) const;
159 virtual void initPainter(QPainter* painter) const;
151 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
160 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
152 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
161 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
153 virtual void keyPressEvent(QKeyEvent* arg__1);
162 virtual void keyPressEvent(QKeyEvent* arg__1);
154 virtual void keyReleaseEvent(QKeyEvent* arg__1);
163 virtual void keyReleaseEvent(QKeyEvent* arg__1);
155 virtual void leaveEvent(QEvent* arg__1);
164 virtual void leaveEvent(QEvent* arg__1);
156 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
165 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
157 virtual QSize minimumSizeHint() const;
166 virtual QSize minimumSizeHint() const;
158 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
167 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
159 virtual void mouseMoveEvent(QMouseEvent* arg__1);
168 virtual void mouseMoveEvent(QMouseEvent* arg__1);
160 virtual void mousePressEvent(QMouseEvent* arg__1);
169 virtual void mousePressEvent(QMouseEvent* arg__1);
161 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
170 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
162 virtual void moveEvent(QMoveEvent* arg__1);
171 virtual void moveEvent(QMoveEvent* arg__1);
163 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
172 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
164 virtual QPaintEngine* paintEngine() const;
173 virtual QPaintEngine* paintEngine() const;
165 virtual void paintEvent(QPaintEvent* arg__1);
174 virtual void paintEvent(QPaintEvent* arg__1);
166 virtual QPaintDevice* redirected(QPoint* offset) const;
175 virtual QPaintDevice* redirected(QPoint* offset) const;
167 virtual void resizeEvent(QResizeEvent* arg__1);
176 virtual void resizeEvent(QResizeEvent* arg__1);
168 virtual QPainter* sharedPainter() const;
177 virtual QPainter* sharedPainter() const;
169 virtual void showEvent(QShowEvent* arg__1);
178 virtual void showEvent(QShowEvent* arg__1);
170 virtual QSize sizeHint() const;
179 virtual QSize sizeHint() const;
171 virtual void tabletEvent(QTabletEvent* arg__1);
180 virtual void tabletEvent(QTabletEvent* arg__1);
172 virtual void timerEvent(QTimerEvent* arg__1);
181 virtual void timerEvent(QTimerEvent* arg__1);
173 virtual void wheelEvent(QWheelEvent* arg__1);
182 virtual void wheelEvent(QWheelEvent* arg__1);
174
183
175 PythonQtInstanceWrapper* _wrapper;
184 PythonQtInstanceWrapper* _wrapper;
176 };
185 };
177
186
178 class PythonQtWrapper_MemSizeWdgt : public QObject
187 class PythonQtWrapper_MemSizeWdgt : public QObject
179 { Q_OBJECT
188 { Q_OBJECT
180 public:
189 public:
181 public slots:
190 public slots:
182 MemSizeWdgt* new_MemSizeWdgt(QWidget* parent = 0);
191 MemSizeWdgt* new_MemSizeWdgt(QWidget* parent = 0);
183 MemSizeWdgt* new_MemSizeWdgt(int defaultSize, QWidget* parent = 0);
192 MemSizeWdgt* new_MemSizeWdgt(int defaultSize, QWidget* parent = 0);
184 void delete_MemSizeWdgt(MemSizeWdgt* obj) { delete obj; }
193 void delete_MemSizeWdgt(MemSizeWdgt* obj) { delete obj; }
185 int getsize(MemSizeWdgt* theWrappedObject);
194 int getsize(MemSizeWdgt* theWrappedObject);
186 void setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max);
195 void setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max);
187 void show(MemSizeWdgt* theWrappedObject);
196 void show(MemSizeWdgt* theWrappedObject);
188 void updateSizeValue(MemSizeWdgt* theWrappedObject);
197 void updateSizeValue(MemSizeWdgt* theWrappedObject);
189 };
198 };
190
199
191
200
192
201
193
202
194
203
195 class PythonQtShell_QHexEdit : public QHexEdit
204 class PythonQtShell_QHexEdit : public QHexEdit
196 {
205 {
197 public:
206 public:
198 PythonQtShell_QHexEdit(QWidget* parent = 0):QHexEdit(parent),_wrapper(NULL) {};
207 PythonQtShell_QHexEdit(QWidget* parent = 0):QHexEdit(parent),_wrapper(NULL) {};
199
208
200 ~PythonQtShell_QHexEdit();
209 ~PythonQtShell_QHexEdit();
201
210
202 virtual void actionEvent(QActionEvent* arg__1);
211 virtual void actionEvent(QActionEvent* arg__1);
203 virtual void changeEvent(QEvent* arg__1);
212 virtual void changeEvent(QEvent* arg__1);
204 virtual void childEvent(QChildEvent* arg__1);
213 virtual void childEvent(QChildEvent* arg__1);
205 virtual void closeEvent(QCloseEvent* arg__1);
214 virtual void closeEvent(QCloseEvent* arg__1);
206 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
215 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
207 virtual void customEvent(QEvent* arg__1);
216 virtual void customEvent(QEvent* arg__1);
208 virtual int devType() const;
217 virtual int devType() const;
209 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
218 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
210 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
219 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
211 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
220 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
212 virtual void dropEvent(QDropEvent* arg__1);
221 virtual void dropEvent(QDropEvent* arg__1);
213 virtual void enterEvent(QEvent* arg__1);
222 virtual void enterEvent(QEvent* arg__1);
214 virtual bool event(QEvent* arg__1);
223 virtual bool event(QEvent* arg__1);
215 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
224 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
216 virtual void focusInEvent(QFocusEvent* arg__1);
225 virtual void focusInEvent(QFocusEvent* arg__1);
217 virtual bool focusNextPrevChild(bool next);
226 virtual bool focusNextPrevChild(bool next);
218 virtual void focusOutEvent(QFocusEvent* arg__1);
227 virtual void focusOutEvent(QFocusEvent* arg__1);
219 virtual bool hasHeightForWidth() const;
228 virtual bool hasHeightForWidth() const;
220 virtual int heightForWidth(int arg__1) const;
229 virtual int heightForWidth(int arg__1) const;
221 virtual void hideEvent(QHideEvent* arg__1);
230 virtual void hideEvent(QHideEvent* arg__1);
222 virtual void initPainter(QPainter* painter) const;
231 virtual void initPainter(QPainter* painter) const;
223 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
232 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
224 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
233 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
225 virtual void keyPressEvent(QKeyEvent* arg__1);
234 virtual void keyPressEvent(QKeyEvent* arg__1);
226 virtual void keyReleaseEvent(QKeyEvent* arg__1);
235 virtual void keyReleaseEvent(QKeyEvent* arg__1);
227 virtual void leaveEvent(QEvent* arg__1);
236 virtual void leaveEvent(QEvent* arg__1);
228 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
237 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
229 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
238 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
230 virtual void mouseMoveEvent(QMouseEvent* arg__1);
239 virtual void mouseMoveEvent(QMouseEvent* arg__1);
231 virtual void mousePressEvent(QMouseEvent* arg__1);
240 virtual void mousePressEvent(QMouseEvent* arg__1);
232 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
241 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
233 virtual void moveEvent(QMoveEvent* arg__1);
242 virtual void moveEvent(QMoveEvent* arg__1);
234 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
243 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
235 virtual QPaintEngine* paintEngine() const;
244 virtual QPaintEngine* paintEngine() const;
236 virtual void paintEvent(QPaintEvent* arg__1);
245 virtual void paintEvent(QPaintEvent* arg__1);
237 virtual QPaintDevice* redirected(QPoint* offset) const;
246 virtual QPaintDevice* redirected(QPoint* offset) const;
238 virtual void resizeEvent(QResizeEvent* arg__1);
247 virtual void resizeEvent(QResizeEvent* arg__1);
239 virtual void scrollContentsBy(int dx, int dy);
248 virtual void scrollContentsBy(int dx, int dy);
240 virtual void setupViewport(QWidget* viewport);
249 virtual void setupViewport(QWidget* viewport);
241 virtual QPainter* sharedPainter() const;
250 virtual QPainter* sharedPainter() const;
242 virtual void showEvent(QShowEvent* arg__1);
251 virtual void showEvent(QShowEvent* arg__1);
243 virtual void tabletEvent(QTabletEvent* arg__1);
252 virtual void tabletEvent(QTabletEvent* arg__1);
244 virtual void timerEvent(QTimerEvent* arg__1);
253 virtual void timerEvent(QTimerEvent* arg__1);
245 virtual bool viewportEvent(QEvent* arg__1);
254 virtual bool viewportEvent(QEvent* arg__1);
246 virtual QSize viewportSizeHint() const;
255 virtual QSize viewportSizeHint() const;
247 virtual void wheelEvent(QWheelEvent* arg__1);
256 virtual void wheelEvent(QWheelEvent* arg__1);
248
257
249 PythonQtInstanceWrapper* _wrapper;
258 PythonQtInstanceWrapper* _wrapper;
250 };
259 };
251
260
252 class PythonQtWrapper_QHexEdit : public QObject
261 class PythonQtWrapper_QHexEdit : public QObject
253 { Q_OBJECT
262 { Q_OBJECT
254 public:
263 public:
255 public slots:
264 public slots:
256 QHexEdit* new_QHexEdit(QWidget* parent = 0);
265 QHexEdit* new_QHexEdit(QWidget* parent = 0);
257 void delete_QHexEdit(QHexEdit* obj) { delete obj; }
266 void delete_QHexEdit(QHexEdit* obj) { delete obj; }
258 QColor addressAreaColor(QHexEdit* theWrappedObject);
267 QColor addressAreaColor(QHexEdit* theWrappedObject);
259 int addressOffset(QHexEdit* theWrappedObject);
268 int addressOffset(QHexEdit* theWrappedObject);
260 int cursorPosition(QHexEdit* theWrappedObject);
269 int cursorPosition(QHexEdit* theWrappedObject);
261 QByteArray data(QHexEdit* theWrappedObject);
270 QByteArray data(QHexEdit* theWrappedObject);
262 const QFont* font(QHexEdit* theWrappedObject) const;
271 const QFont* font(QHexEdit* theWrappedObject) const;
263 QColor highlightingColor(QHexEdit* theWrappedObject);
272 QColor highlightingColor(QHexEdit* theWrappedObject);
264 int indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
273 int indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
265 void insert(QHexEdit* theWrappedObject, int i, char ch);
274 void insert(QHexEdit* theWrappedObject, int i, char ch);
266 void insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba);
275 void insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba);
267 bool isReadOnly(QHexEdit* theWrappedObject);
276 bool isReadOnly(QHexEdit* theWrappedObject);
268 int lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
277 int lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
269 bool overwriteMode(QHexEdit* theWrappedObject);
278 bool overwriteMode(QHexEdit* theWrappedObject);
270 void remove(QHexEdit* theWrappedObject, int pos, int len = 1);
279 void remove(QHexEdit* theWrappedObject, int pos, int len = 1);
271 void replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after);
280 void replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after);
272 QColor selectionColor(QHexEdit* theWrappedObject);
281 QColor selectionColor(QHexEdit* theWrappedObject);
273 QString selectionToReadableString(QHexEdit* theWrappedObject);
282 QString selectionToReadableString(QHexEdit* theWrappedObject);
274 void setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color);
283 void setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color);
275 void setAddressOffset(QHexEdit* theWrappedObject, int offset);
284 void setAddressOffset(QHexEdit* theWrappedObject, int offset);
276 void setCursorPosition(QHexEdit* theWrappedObject, int cusorPos);
285 void setCursorPosition(QHexEdit* theWrappedObject, int cusorPos);
277 void setData(QHexEdit* theWrappedObject, const QByteArray& data);
286 void setData(QHexEdit* theWrappedObject, const QByteArray& data);
278 void setFont(QHexEdit* theWrappedObject, const QFont& arg__1);
287 void setFont(QHexEdit* theWrappedObject, const QFont& arg__1);
279 void setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color);
288 void setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color);
280 void setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1);
289 void setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1);
281 void setReadOnly(QHexEdit* theWrappedObject, bool arg__1);
290 void setReadOnly(QHexEdit* theWrappedObject, bool arg__1);
282 void setSelectionColor(QHexEdit* theWrappedObject, const QColor& color);
291 void setSelectionColor(QHexEdit* theWrappedObject, const QColor& color);
283 QString toReadableString(QHexEdit* theWrappedObject);
292 QString toReadableString(QHexEdit* theWrappedObject);
284 };
293 };
285
294
286
295
287
296
288
297
289
298
290 class PythonQtShell_QHexSpinBox : public QHexSpinBox
299 class PythonQtShell_QHexSpinBox : public QHexSpinBox
291 {
300 {
292 public:
301 public:
293 PythonQtShell_QHexSpinBox(QWidget* parent = 0):QHexSpinBox(parent),_wrapper(NULL) {};
302 PythonQtShell_QHexSpinBox(QWidget* parent = 0):QHexSpinBox(parent),_wrapper(NULL) {};
294
303
295 ~PythonQtShell_QHexSpinBox();
304 ~PythonQtShell_QHexSpinBox();
296
305
297 virtual void actionEvent(QActionEvent* arg__1);
306 virtual void actionEvent(QActionEvent* arg__1);
298 virtual void changeEvent(QEvent* event);
307 virtual void changeEvent(QEvent* event);
299 virtual void childEvent(QChildEvent* arg__1);
308 virtual void childEvent(QChildEvent* arg__1);
300 virtual void clear();
309 virtual void clear();
301 virtual void closeEvent(QCloseEvent* event);
310 virtual void closeEvent(QCloseEvent* event);
302 virtual void contextMenuEvent(QContextMenuEvent* event);
311 virtual void contextMenuEvent(QContextMenuEvent* event);
303 virtual void customEvent(QEvent* arg__1);
312 virtual void customEvent(QEvent* arg__1);
304 virtual int devType() const;
313 virtual int devType() const;
305 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
314 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
306 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
315 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
307 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
316 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
308 virtual void dropEvent(QDropEvent* arg__1);
317 virtual void dropEvent(QDropEvent* arg__1);
309 virtual void enterEvent(QEvent* arg__1);
318 virtual void enterEvent(QEvent* arg__1);
310 virtual bool event(QEvent* event);
319 virtual bool event(QEvent* event);
311 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
320 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
312 virtual void fixup(QString& str) const;
321 virtual void fixup(QString& str) const;
313 virtual void focusInEvent(QFocusEvent* event);
322 virtual void focusInEvent(QFocusEvent* event);
314 virtual bool focusNextPrevChild(bool next);
323 virtual bool focusNextPrevChild(bool next);
315 virtual void focusOutEvent(QFocusEvent* event);
324 virtual void focusOutEvent(QFocusEvent* event);
316 virtual bool hasHeightForWidth() const;
325 virtual bool hasHeightForWidth() const;
317 virtual int heightForWidth(int arg__1) const;
326 virtual int heightForWidth(int arg__1) const;
318 virtual void hideEvent(QHideEvent* event);
327 virtual void hideEvent(QHideEvent* event);
319 virtual void initPainter(QPainter* painter) const;
328 virtual void initPainter(QPainter* painter) const;
320 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
329 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
321 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
330 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
322 virtual void keyPressEvent(QKeyEvent* event);
331 virtual void keyPressEvent(QKeyEvent* event);
323 virtual void keyReleaseEvent(QKeyEvent* event);
332 virtual void keyReleaseEvent(QKeyEvent* event);
324 virtual void leaveEvent(QEvent* arg__1);
333 virtual void leaveEvent(QEvent* arg__1);
325 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
334 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
326 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
335 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
327 virtual void mouseMoveEvent(QMouseEvent* event);
336 virtual void mouseMoveEvent(QMouseEvent* event);
328 virtual void mousePressEvent(QMouseEvent* event);
337 virtual void mousePressEvent(QMouseEvent* event);
329 virtual void mouseReleaseEvent(QMouseEvent* event);
338 virtual void mouseReleaseEvent(QMouseEvent* event);
330 virtual void moveEvent(QMoveEvent* arg__1);
339 virtual void moveEvent(QMoveEvent* arg__1);
331 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
340 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
332 virtual QPaintEngine* paintEngine() const;
341 virtual QPaintEngine* paintEngine() const;
333 virtual void paintEvent(QPaintEvent* event);
342 virtual void paintEvent(QPaintEvent* event);
334 virtual QPaintDevice* redirected(QPoint* offset) const;
343 virtual QPaintDevice* redirected(QPoint* offset) const;
335 virtual void resizeEvent(QResizeEvent* event);
344 virtual void resizeEvent(QResizeEvent* event);
336 virtual QPainter* sharedPainter() const;
345 virtual QPainter* sharedPainter() const;
337 virtual void showEvent(QShowEvent* event);
346 virtual void showEvent(QShowEvent* event);
338 virtual void stepBy(int steps);
347 virtual void stepBy(int steps);
339 virtual QAbstractSpinBox::StepEnabled stepEnabled() const;
348 virtual QAbstractSpinBox::StepEnabled stepEnabled() const;
340 virtual void tabletEvent(QTabletEvent* arg__1);
349 virtual void tabletEvent(QTabletEvent* arg__1);
341 virtual QString textFromValue(int value) const;
350 virtual QString textFromValue(int value) const;
342 virtual void timerEvent(QTimerEvent* event);
351 virtual void timerEvent(QTimerEvent* event);
343 virtual QValidator::State validate(QString& input, int& pos) const;
352 virtual QValidator::State validate(QString& input, int& pos) const;
344 virtual int valueFromText(const QString& text) const;
353 virtual int valueFromText(const QString& text) const;
345 virtual void wheelEvent(QWheelEvent* event);
354 virtual void wheelEvent(QWheelEvent* event);
346
355
347 PythonQtInstanceWrapper* _wrapper;
356 PythonQtInstanceWrapper* _wrapper;
348 };
357 };
349
358
350 class PythonQtPublicPromoter_QHexSpinBox : public QHexSpinBox
359 class PythonQtPublicPromoter_QHexSpinBox : public QHexSpinBox
351 { public:
360 { public:
352 inline QString promoted_textFromValue(int value) const { return QHexSpinBox::textFromValue(value); }
361 inline QString promoted_textFromValue(int value) const { return QHexSpinBox::textFromValue(value); }
353 inline QValidator::State promoted_validate(QString& input, int& pos) const { return QHexSpinBox::validate(input, pos); }
362 inline QValidator::State promoted_validate(QString& input, int& pos) const { return QHexSpinBox::validate(input, pos); }
354 inline int promoted_valueFromText(const QString& text) const { return QHexSpinBox::valueFromText(text); }
363 inline int promoted_valueFromText(const QString& text) const { return QHexSpinBox::valueFromText(text); }
355 };
364 };
356
365
357 class PythonQtWrapper_QHexSpinBox : public QObject
366 class PythonQtWrapper_QHexSpinBox : public QObject
358 { Q_OBJECT
367 { Q_OBJECT
359 public:
368 public:
360 public slots:
369 public slots:
361 QHexSpinBox* new_QHexSpinBox(QWidget* parent = 0);
370 QHexSpinBox* new_QHexSpinBox(QWidget* parent = 0);
362 void delete_QHexSpinBox(QHexSpinBox* obj) { delete obj; }
371 void delete_QHexSpinBox(QHexSpinBox* obj) { delete obj; }
363 void show(QHexSpinBox* theWrappedObject);
372 void show(QHexSpinBox* theWrappedObject);
364 QString textFromValue(QHexSpinBox* theWrappedObject, int value) const;
373 QString textFromValue(QHexSpinBox* theWrappedObject, int value) const;
365 QValidator::State validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const;
374 QValidator::State validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const;
366 int valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const;
375 int valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const;
367 };
376 };
368
377
369
378
370
379
371
380
372
381
373 class PythonQtShell_SocExplorerPlot : public SocExplorerPlot
382 class PythonQtShell_SocExplorerPlot : public SocExplorerPlot
374 {
383 {
375 public:
384 public:
376 PythonQtShell_SocExplorerPlot(QWidget* parent = 0):SocExplorerPlot(parent),_wrapper(NULL) {};
385 PythonQtShell_SocExplorerPlot(QWidget* parent = 0):SocExplorerPlot(parent),_wrapper(NULL) {};
377
386
378 ~PythonQtShell_SocExplorerPlot();
387 ~PythonQtShell_SocExplorerPlot();
379
388
380 virtual void actionEvent(QActionEvent* arg__1);
389 virtual void actionEvent(QActionEvent* arg__1);
381 virtual void changeEvent(QEvent* arg__1);
390 virtual void changeEvent(QEvent* arg__1);
382 virtual void childEvent(QChildEvent* arg__1);
391 virtual void childEvent(QChildEvent* arg__1);
383 virtual void closeEvent(QCloseEvent* arg__1);
392 virtual void closeEvent(QCloseEvent* arg__1);
384 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
393 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
385 virtual void customEvent(QEvent* arg__1);
394 virtual void customEvent(QEvent* arg__1);
386 virtual int devType() const;
395 virtual int devType() const;
387 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
396 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
388 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
397 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
389 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
398 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
390 virtual void dropEvent(QDropEvent* arg__1);
399 virtual void dropEvent(QDropEvent* arg__1);
391 virtual void enterEvent(QEvent* arg__1);
400 virtual void enterEvent(QEvent* arg__1);
392 virtual bool event(QEvent* arg__1);
401 virtual bool event(QEvent* arg__1);
393 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
402 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
394 virtual void focusInEvent(QFocusEvent* arg__1);
403 virtual void focusInEvent(QFocusEvent* arg__1);
395 virtual bool focusNextPrevChild(bool next);
404 virtual bool focusNextPrevChild(bool next);
396 virtual void focusOutEvent(QFocusEvent* arg__1);
405 virtual void focusOutEvent(QFocusEvent* arg__1);
397 virtual bool hasHeightForWidth() const;
406 virtual bool hasHeightForWidth() const;
398 virtual int heightForWidth(int arg__1) const;
407 virtual int heightForWidth(int arg__1) const;
399 virtual void hideEvent(QHideEvent* arg__1);
408 virtual void hideEvent(QHideEvent* arg__1);
400 virtual void initPainter(QPainter* painter) const;
409 virtual void initPainter(QPainter* painter) const;
401 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
410 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
402 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
411 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
403 virtual void keyPressEvent(QKeyEvent* arg__1);
412 virtual void keyPressEvent(QKeyEvent* arg__1);
404 virtual void keyReleaseEvent(QKeyEvent* arg__1);
413 virtual void keyReleaseEvent(QKeyEvent* arg__1);
405 virtual void leaveEvent(QEvent* arg__1);
414 virtual void leaveEvent(QEvent* arg__1);
406 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
415 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
407 virtual QSize minimumSizeHint() const;
416 virtual QSize minimumSizeHint() const;
408 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
417 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
409 virtual void mouseMoveEvent(QMouseEvent* arg__1);
418 virtual void mouseMoveEvent(QMouseEvent* arg__1);
410 virtual void mousePressEvent(QMouseEvent* arg__1);
419 virtual void mousePressEvent(QMouseEvent* arg__1);
411 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
420 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
412 virtual void moveEvent(QMoveEvent* arg__1);
421 virtual void moveEvent(QMoveEvent* arg__1);
413 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
422 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
414 virtual QPaintEngine* paintEngine() const;
423 virtual QPaintEngine* paintEngine() const;
415 virtual void paintEvent(QPaintEvent* arg__1);
424 virtual void paintEvent(QPaintEvent* arg__1);
416 virtual QPaintDevice* redirected(QPoint* offset) const;
425 virtual QPaintDevice* redirected(QPoint* offset) const;
417 virtual void resizeEvent(QResizeEvent* arg__1);
426 virtual void resizeEvent(QResizeEvent* arg__1);
418 virtual QPainter* sharedPainter() const;
427 virtual QPainter* sharedPainter() const;
419 virtual void showEvent(QShowEvent* arg__1);
428 virtual void showEvent(QShowEvent* arg__1);
420 virtual QSize sizeHint() const;
429 virtual QSize sizeHint() const;
421 virtual void tabletEvent(QTabletEvent* arg__1);
430 virtual void tabletEvent(QTabletEvent* arg__1);
422 virtual void timerEvent(QTimerEvent* arg__1);
431 virtual void timerEvent(QTimerEvent* arg__1);
423 virtual void wheelEvent(QWheelEvent* arg__1);
432 virtual void wheelEvent(QWheelEvent* arg__1);
424
433
425 PythonQtInstanceWrapper* _wrapper;
434 PythonQtInstanceWrapper* _wrapper;
426 };
435 };
427
436
428 class PythonQtPublicPromoter_SocExplorerPlot : public SocExplorerPlot
437 class PythonQtPublicPromoter_SocExplorerPlot : public SocExplorerPlot
429 { public:
438 { public:
430 inline void promoted_keyPressEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyPressEvent(arg__1); }
439 inline void promoted_keyPressEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyPressEvent(arg__1); }
431 inline void promoted_keyReleaseEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyReleaseEvent(arg__1); }
440 inline void promoted_keyReleaseEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyReleaseEvent(arg__1); }
432 inline void promoted_mouseMoveEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseMoveEvent(arg__1); }
441 inline void promoted_mouseMoveEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseMoveEvent(arg__1); }
433 inline void promoted_mousePressEvent(QMouseEvent* arg__1) { SocExplorerPlot::mousePressEvent(arg__1); }
442 inline void promoted_mousePressEvent(QMouseEvent* arg__1) { SocExplorerPlot::mousePressEvent(arg__1); }
434 inline void promoted_mouseReleaseEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseReleaseEvent(arg__1); }
443 inline void promoted_mouseReleaseEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseReleaseEvent(arg__1); }
435 inline void promoted_wheelEvent(QWheelEvent* arg__1) { SocExplorerPlot::wheelEvent(arg__1); }
444 inline void promoted_wheelEvent(QWheelEvent* arg__1) { SocExplorerPlot::wheelEvent(arg__1); }
436 };
445 };
437
446
438 class PythonQtWrapper_SocExplorerPlot : public QObject
447 class PythonQtWrapper_SocExplorerPlot : public QObject
439 { Q_OBJECT
448 { Q_OBJECT
440 public:
449 public:
441 public slots:
450 public slots:
442 SocExplorerPlot* new_SocExplorerPlot(QWidget* parent = 0);
451 SocExplorerPlot* new_SocExplorerPlot(QWidget* parent = 0);
443 void delete_SocExplorerPlot(SocExplorerPlot* obj) { delete obj; }
452 void delete_SocExplorerPlot(SocExplorerPlot* obj) { delete obj; }
444 int addGraph(SocExplorerPlot* theWrappedObject);
453 int addGraph(SocExplorerPlot* theWrappedObject);
445 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
454 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
446 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y);
455 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y);
447 QPen getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex);
456 QPen getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex);
448 void keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
457 void keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
449 void keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
458 void keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
450 void mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
459 void mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
451 void mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
460 void mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
452 void mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
461 void mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
453 void rescaleAxis(SocExplorerPlot* theWrappedObject);
462 void rescaleAxis(SocExplorerPlot* theWrappedObject);
454 void setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable);
463 void setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable);
455 void setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
464 void setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
456 void setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle);
465 void setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle);
457 void setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name);
466 void setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name);
458 void setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen);
467 void setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen);
459 void setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle);
468 void setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle);
460 void setLegendFont(SocExplorerPlot* theWrappedObject, QFont font);
469 void setLegendFont(SocExplorerPlot* theWrappedObject, QFont font);
461 void setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font);
470 void setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font);
462 void setTitle(SocExplorerPlot* theWrappedObject, QString title);
471 void setTitle(SocExplorerPlot* theWrappedObject, QString title);
463 void setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
472 void setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
464 void setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
473 void setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
465 void setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
474 void setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
466 void setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
475 void setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
467 void show(SocExplorerPlot* theWrappedObject);
476 void show(SocExplorerPlot* theWrappedObject);
468 void wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1);
477 void wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1);
469 };
478 };
470
479
471
480
472
481
473
482
474
483
475 class PythonQtShell_TCP_Terminal_Client : public TCP_Terminal_Client
484 class PythonQtShell_TCP_Terminal_Client : public TCP_Terminal_Client
476 {
485 {
477 public:
486 public:
478 PythonQtShell_TCP_Terminal_Client(QObject* parent = 0):TCP_Terminal_Client(parent),_wrapper(NULL) {};
487 PythonQtShell_TCP_Terminal_Client(QObject* parent = 0):TCP_Terminal_Client(parent),_wrapper(NULL) {};
479
488
480 ~PythonQtShell_TCP_Terminal_Client();
489 ~PythonQtShell_TCP_Terminal_Client();
481
490
482 virtual void childEvent(QChildEvent* arg__1);
491 virtual void childEvent(QChildEvent* arg__1);
483 virtual void customEvent(QEvent* arg__1);
492 virtual void customEvent(QEvent* arg__1);
484 virtual bool event(QEvent* arg__1);
493 virtual bool event(QEvent* arg__1);
485 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
494 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
486 virtual void timerEvent(QTimerEvent* arg__1);
495 virtual void timerEvent(QTimerEvent* arg__1);
487
496
488 PythonQtInstanceWrapper* _wrapper;
497 PythonQtInstanceWrapper* _wrapper;
489 };
498 };
490
499
491 class PythonQtWrapper_TCP_Terminal_Client : public QObject
500 class PythonQtWrapper_TCP_Terminal_Client : public QObject
492 { Q_OBJECT
501 { Q_OBJECT
493 public:
502 public:
494 public slots:
503 public slots:
495 TCP_Terminal_Client* new_TCP_Terminal_Client(QObject* parent = 0);
504 TCP_Terminal_Client* new_TCP_Terminal_Client(QObject* parent = 0);
496 void delete_TCP_Terminal_Client(TCP_Terminal_Client* obj) { delete obj; }
505 void delete_TCP_Terminal_Client(TCP_Terminal_Client* obj) { delete obj; }
497 void connectToServer(TCP_Terminal_Client* theWrappedObject);
506 void connectToServer(TCP_Terminal_Client* theWrappedObject);
498 void connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port);
507 void connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port);
499 bool isConnected(TCP_Terminal_Client* theWrappedObject);
508 bool isConnected(TCP_Terminal_Client* theWrappedObject);
500 void sendText(TCP_Terminal_Client* theWrappedObject, const QString& text);
509 void sendText(TCP_Terminal_Client* theWrappedObject, const QString& text);
501 void startServer(TCP_Terminal_Client* theWrappedObject);
510 void startServer(TCP_Terminal_Client* theWrappedObject);
502 void startServer(TCP_Terminal_Client* theWrappedObject, int port);
511 void startServer(TCP_Terminal_Client* theWrappedObject, int port);
503 };
512 };
504
513
505
514
506
515
507
516
508
517
509 class PythonQtWrapper_XByteArray : public QObject
518 class PythonQtWrapper_XByteArray : public QObject
510 { Q_OBJECT
519 { Q_OBJECT
511 public:
520 public:
512 public slots:
521 public slots:
513 XByteArray* new_XByteArray();
522 XByteArray* new_XByteArray();
514 void delete_XByteArray(XByteArray* obj) { delete obj; }
523 void delete_XByteArray(XByteArray* obj) { delete obj; }
515 int addressOffset(XByteArray* theWrappedObject);
524 int addressOffset(XByteArray* theWrappedObject);
516 int addressWidth(XByteArray* theWrappedObject);
525 int addressWidth(XByteArray* theWrappedObject);
517 QChar asciiChar(XByteArray* theWrappedObject, int index);
526 QChar asciiChar(XByteArray* theWrappedObject, int index);
518 QByteArray* data(XByteArray* theWrappedObject);
527 QByteArray* data(XByteArray* theWrappedObject);
519 bool dataChanged(XByteArray* theWrappedObject, int i);
528 bool dataChanged(XByteArray* theWrappedObject, int i);
520 QByteArray dataChanged(XByteArray* theWrappedObject, int i, int len);
529 QByteArray dataChanged(XByteArray* theWrappedObject, int i, int len);
521 QByteArray* insert(XByteArray* theWrappedObject, int i, char ch);
530 QByteArray* insert(XByteArray* theWrappedObject, int i, char ch);
522 QByteArray* insert(XByteArray* theWrappedObject, int i, const QByteArray& ba);
531 QByteArray* insert(XByteArray* theWrappedObject, int i, const QByteArray& ba);
523 int realAddressNumbers(XByteArray* theWrappedObject);
532 int realAddressNumbers(XByteArray* theWrappedObject);
524 QByteArray* remove(XByteArray* theWrappedObject, int pos, int len);
533 QByteArray* remove(XByteArray* theWrappedObject, int pos, int len);
525 QByteArray* replace(XByteArray* theWrappedObject, int index, char ch);
534 QByteArray* replace(XByteArray* theWrappedObject, int index, char ch);
526 QByteArray* replace(XByteArray* theWrappedObject, int index, const QByteArray& ba);
535 QByteArray* replace(XByteArray* theWrappedObject, int index, const QByteArray& ba);
527 QByteArray* replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba);
536 QByteArray* replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba);
528 void setAddressOffset(XByteArray* theWrappedObject, int offset);
537 void setAddressOffset(XByteArray* theWrappedObject, int offset);
529 void setAddressWidth(XByteArray* theWrappedObject, int width);
538 void setAddressWidth(XByteArray* theWrappedObject, int width);
530 void setData(XByteArray* theWrappedObject, QByteArray data);
539 void setData(XByteArray* theWrappedObject, QByteArray data);
531 void setDataChanged(XByteArray* theWrappedObject, int i, bool state);
540 void setDataChanged(XByteArray* theWrappedObject, int i, bool state);
532 void setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state);
541 void setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state);
533 int size(XByteArray* theWrappedObject);
542 int size(XByteArray* theWrappedObject);
534 QString toRedableString(XByteArray* theWrappedObject, int start = 0, int end = -1);
543 QString toRedableString(XByteArray* theWrappedObject, int start = 0, int end = -1);
535 };
544 };
536
545
537
546
538
547
539
548
540
549
541 class PythonQtShell_abstractExecFile : public abstractExecFile
550 class PythonQtShell_abstractExecFile : public abstractExecFile
542 {
551 {
543 public:
552 public:
544 PythonQtShell_abstractExecFile():abstractExecFile(),_wrapper(NULL) {};
553 PythonQtShell_abstractExecFile():abstractExecFile(),_wrapper(NULL) {};
545
554
546 ~PythonQtShell_abstractExecFile();
555 ~PythonQtShell_abstractExecFile();
547
556
548 virtual void childEvent(QChildEvent* arg__1);
557 virtual void childEvent(QChildEvent* arg__1);
549 virtual int closeFile();
558 virtual int closeFile();
550 virtual void customEvent(QEvent* arg__1);
559 virtual void customEvent(QEvent* arg__1);
551 virtual bool event(QEvent* arg__1);
560 virtual bool event(QEvent* arg__1);
552 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
561 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
553 virtual QList<codeFragment* > getFragments();
562 virtual QList<codeFragment* > getFragments();
554 virtual bool isopened();
563 virtual bool isopened();
555 virtual bool openFile(const QString& File);
564 virtual bool openFile(const QString& File);
556 virtual void timerEvent(QTimerEvent* arg__1);
565 virtual void timerEvent(QTimerEvent* arg__1);
557
566
558 PythonQtInstanceWrapper* _wrapper;
567 PythonQtInstanceWrapper* _wrapper;
559 };
568 };
560
569
561 class PythonQtWrapper_abstractExecFile : public QObject
570 class PythonQtWrapper_abstractExecFile : public QObject
562 { Q_OBJECT
571 { Q_OBJECT
563 public:
572 public:
564 public slots:
573 public slots:
565 abstractExecFile* new_abstractExecFile();
574 abstractExecFile* new_abstractExecFile();
566 void delete_abstractExecFile(abstractExecFile* obj) { delete obj; }
575 void delete_abstractExecFile(abstractExecFile* obj) { delete obj; }
567 };
576 };
568
577
569
578
570
579
571
580
572
581
573 class PythonQtShell_codeFragment : public codeFragment
582 class PythonQtShell_codeFragment : public codeFragment
574 {
583 {
575 public:
584 public:
576 PythonQtShell_codeFragment():codeFragment(),_wrapper(NULL) {};
585 PythonQtShell_codeFragment():codeFragment(),_wrapper(NULL) {};
577 PythonQtShell_codeFragment(char* data, unsigned int size, unsigned int address):codeFragment(data, size, address),_wrapper(NULL) {};
586 PythonQtShell_codeFragment(char* data, unsigned int size, unsigned int address):codeFragment(data, size, address),_wrapper(NULL) {};
578
587
579 ~PythonQtShell_codeFragment();
588 ~PythonQtShell_codeFragment();
580
589
581
590
582 PythonQtInstanceWrapper* _wrapper;
591 PythonQtInstanceWrapper* _wrapper;
583 };
592 };
584
593
585 class PythonQtWrapper_codeFragment : public QObject
594 class PythonQtWrapper_codeFragment : public QObject
586 { Q_OBJECT
595 { Q_OBJECT
587 public:
596 public:
588 public slots:
597 public slots:
589 codeFragment* new_codeFragment();
598 codeFragment* new_codeFragment();
590 codeFragment* new_codeFragment(char* data, unsigned int size, unsigned int address);
599 codeFragment* new_codeFragment(char* data, unsigned int size, unsigned int address);
591 void delete_codeFragment(codeFragment* obj) { delete obj; }
600 void delete_codeFragment(codeFragment* obj) { delete obj; }
601 void py_set_address(codeFragment* theWrappedObject, unsigned int address){ theWrappedObject->address = address; }
602 unsigned int py_get_address(codeFragment* theWrappedObject){ return theWrappedObject->address; }
603 void py_set_data(codeFragment* theWrappedObject, char* data){ theWrappedObject->data = data; }
604 char* py_get_data(codeFragment* theWrappedObject){ return theWrappedObject->data; }
592 void py_set_size(codeFragment* theWrappedObject, unsigned int size){ theWrappedObject->size = size; }
605 void py_set_size(codeFragment* theWrappedObject, unsigned int size){ theWrappedObject->size = size; }
593 unsigned int py_get_size(codeFragment* theWrappedObject){ return theWrappedObject->size; }
606 unsigned int py_get_size(codeFragment* theWrappedObject){ return theWrappedObject->size; }
594 void py_set_data(codeFragment* theWrappedObject, char* data){ theWrappedObject->data = data; }
595 char* py_get_data(codeFragment* theWrappedObject){ return theWrappedObject->data; }
596 void py_set_address(codeFragment* theWrappedObject, unsigned int address){ theWrappedObject->address = address; }
597 unsigned int py_get_address(codeFragment* theWrappedObject){ return theWrappedObject->address; }
598 };
607 };
599
608
600
609
601
610
602
611
603
612
604 class PythonQtShell_elfFileWidget : public elfFileWidget
613 class PythonQtShell_elfFileWidget : public elfFileWidget
605 {
614 {
606 public:
615 public:
607 PythonQtShell_elfFileWidget(QWidget* parent = 0):elfFileWidget(parent),_wrapper(NULL) {};
616 PythonQtShell_elfFileWidget(QWidget* parent = 0):elfFileWidget(parent),_wrapper(NULL) {};
608
617
609 ~PythonQtShell_elfFileWidget();
618 ~PythonQtShell_elfFileWidget();
610
619
611 virtual void actionEvent(QActionEvent* arg__1);
620 virtual void actionEvent(QActionEvent* arg__1);
612 virtual void changeEvent(QEvent* arg__1);
621 virtual void changeEvent(QEvent* arg__1);
613 virtual void childEvent(QChildEvent* arg__1);
622 virtual void childEvent(QChildEvent* arg__1);
614 virtual void closeEvent(QCloseEvent* arg__1);
623 virtual void closeEvent(QCloseEvent* arg__1);
615 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
624 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
616 virtual void customEvent(QEvent* arg__1);
625 virtual void customEvent(QEvent* arg__1);
617 virtual int devType() const;
626 virtual int devType() const;
618 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
627 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
619 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
628 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
620 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
629 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
621 virtual void dropEvent(QDropEvent* arg__1);
630 virtual void dropEvent(QDropEvent* arg__1);
622 virtual void enterEvent(QEvent* arg__1);
631 virtual void enterEvent(QEvent* arg__1);
623 virtual bool event(QEvent* arg__1);
632 virtual bool event(QEvent* arg__1);
624 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
633 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
625 virtual void focusInEvent(QFocusEvent* arg__1);
634 virtual void focusInEvent(QFocusEvent* arg__1);
626 virtual bool focusNextPrevChild(bool next);
635 virtual bool focusNextPrevChild(bool next);
627 virtual void focusOutEvent(QFocusEvent* arg__1);
636 virtual void focusOutEvent(QFocusEvent* arg__1);
628 virtual bool hasHeightForWidth() const;
637 virtual bool hasHeightForWidth() const;
629 virtual int heightForWidth(int arg__1) const;
638 virtual int heightForWidth(int arg__1) const;
630 virtual void hideEvent(QHideEvent* arg__1);
639 virtual void hideEvent(QHideEvent* arg__1);
631 virtual void initPainter(QPainter* painter) const;
640 virtual void initPainter(QPainter* painter) const;
632 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
641 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
633 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
642 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
634 virtual void keyPressEvent(QKeyEvent* arg__1);
643 virtual void keyPressEvent(QKeyEvent* arg__1);
635 virtual void keyReleaseEvent(QKeyEvent* arg__1);
644 virtual void keyReleaseEvent(QKeyEvent* arg__1);
636 virtual void leaveEvent(QEvent* arg__1);
645 virtual void leaveEvent(QEvent* arg__1);
637 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
646 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
638 virtual QSize minimumSizeHint() const;
647 virtual QSize minimumSizeHint() const;
639 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
648 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
640 virtual void mouseMoveEvent(QMouseEvent* arg__1);
649 virtual void mouseMoveEvent(QMouseEvent* arg__1);
641 virtual void mousePressEvent(QMouseEvent* arg__1);
650 virtual void mousePressEvent(QMouseEvent* arg__1);
642 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
651 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
643 virtual void moveEvent(QMoveEvent* arg__1);
652 virtual void moveEvent(QMoveEvent* arg__1);
644 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
653 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
645 virtual QPaintEngine* paintEngine() const;
654 virtual QPaintEngine* paintEngine() const;
646 virtual void paintEvent(QPaintEvent* arg__1);
655 virtual void paintEvent(QPaintEvent* arg__1);
647 virtual QPaintDevice* redirected(QPoint* offset) const;
656 virtual QPaintDevice* redirected(QPoint* offset) const;
648 virtual void resizeEvent(QResizeEvent* arg__1);
657 virtual void resizeEvent(QResizeEvent* arg__1);
649 virtual QPainter* sharedPainter() const;
658 virtual QPainter* sharedPainter() const;
650 virtual void showEvent(QShowEvent* arg__1);
659 virtual void showEvent(QShowEvent* arg__1);
651 virtual QSize sizeHint() const;
660 virtual QSize sizeHint() const;
652 virtual void tabletEvent(QTabletEvent* arg__1);
661 virtual void tabletEvent(QTabletEvent* arg__1);
653 virtual void timerEvent(QTimerEvent* arg__1);
662 virtual void timerEvent(QTimerEvent* arg__1);
654 virtual void wheelEvent(QWheelEvent* arg__1);
663 virtual void wheelEvent(QWheelEvent* arg__1);
655
664
656 PythonQtInstanceWrapper* _wrapper;
665 PythonQtInstanceWrapper* _wrapper;
657 };
666 };
658
667
659 class PythonQtWrapper_elfFileWidget : public QObject
668 class PythonQtWrapper_elfFileWidget : public QObject
660 { Q_OBJECT
669 { Q_OBJECT
661 public:
670 public:
662 public slots:
671 public slots:
663 elfFileWidget* new_elfFileWidget(QWidget* parent = 0);
672 elfFileWidget* new_elfFileWidget(QWidget* parent = 0);
664 void delete_elfFileWidget(elfFileWidget* obj) { delete obj; }
673 void delete_elfFileWidget(elfFileWidget* obj) { delete obj; }
665 };
674 };
666
675
667
676
668
677
669
678
670
679
671 class PythonQtShell_elfInfoWdgt : public elfInfoWdgt
680 class PythonQtShell_elfInfoWdgt : public elfInfoWdgt
672 {
681 {
673 public:
682 public:
674 PythonQtShell_elfInfoWdgt(QWidget* parent = 0):elfInfoWdgt(parent),_wrapper(NULL) {};
683 PythonQtShell_elfInfoWdgt(QWidget* parent = 0):elfInfoWdgt(parent),_wrapper(NULL) {};
675
684
676 ~PythonQtShell_elfInfoWdgt();
685 ~PythonQtShell_elfInfoWdgt();
677
686
678 virtual void actionEvent(QActionEvent* arg__1);
687 virtual void actionEvent(QActionEvent* arg__1);
679 virtual void changeEvent(QEvent* arg__1);
688 virtual void changeEvent(QEvent* arg__1);
680 virtual void childEvent(QChildEvent* arg__1);
689 virtual void childEvent(QChildEvent* arg__1);
681 virtual void closeEvent(QCloseEvent* arg__1);
690 virtual void closeEvent(QCloseEvent* arg__1);
682 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
691 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
683 virtual void customEvent(QEvent* arg__1);
692 virtual void customEvent(QEvent* arg__1);
684 virtual int devType() const;
693 virtual int devType() const;
685 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
694 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
686 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
695 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
687 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
696 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
688 virtual void dropEvent(QDropEvent* arg__1);
697 virtual void dropEvent(QDropEvent* arg__1);
689 virtual void enterEvent(QEvent* arg__1);
698 virtual void enterEvent(QEvent* arg__1);
690 virtual bool event(QEvent* arg__1);
699 virtual bool event(QEvent* arg__1);
691 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
700 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
692 virtual void focusInEvent(QFocusEvent* arg__1);
701 virtual void focusInEvent(QFocusEvent* arg__1);
693 virtual bool focusNextPrevChild(bool next);
702 virtual bool focusNextPrevChild(bool next);
694 virtual void focusOutEvent(QFocusEvent* arg__1);
703 virtual void focusOutEvent(QFocusEvent* arg__1);
695 virtual bool hasHeightForWidth() const;
704 virtual bool hasHeightForWidth() const;
696 virtual int heightForWidth(int arg__1) const;
705 virtual int heightForWidth(int arg__1) const;
697 virtual void hideEvent(QHideEvent* arg__1);
706 virtual void hideEvent(QHideEvent* arg__1);
698 virtual void initPainter(QPainter* painter) const;
707 virtual void initPainter(QPainter* painter) const;
699 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
708 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
700 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
709 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
701 virtual void keyPressEvent(QKeyEvent* arg__1);
710 virtual void keyPressEvent(QKeyEvent* arg__1);
702 virtual void keyReleaseEvent(QKeyEvent* arg__1);
711 virtual void keyReleaseEvent(QKeyEvent* arg__1);
703 virtual void leaveEvent(QEvent* arg__1);
712 virtual void leaveEvent(QEvent* arg__1);
704 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
713 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
705 virtual QSize minimumSizeHint() const;
714 virtual QSize minimumSizeHint() const;
706 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
715 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
707 virtual void mouseMoveEvent(QMouseEvent* arg__1);
716 virtual void mouseMoveEvent(QMouseEvent* arg__1);
708 virtual void mousePressEvent(QMouseEvent* arg__1);
717 virtual void mousePressEvent(QMouseEvent* arg__1);
709 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
718 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
710 virtual void moveEvent(QMoveEvent* arg__1);
719 virtual void moveEvent(QMoveEvent* arg__1);
711 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
720 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
712 virtual QPaintEngine* paintEngine() const;
721 virtual QPaintEngine* paintEngine() const;
713 virtual void paintEvent(QPaintEvent* arg__1);
722 virtual void paintEvent(QPaintEvent* arg__1);
714 virtual QPaintDevice* redirected(QPoint* offset) const;
723 virtual QPaintDevice* redirected(QPoint* offset) const;
715 virtual void resizeEvent(QResizeEvent* arg__1);
724 virtual void resizeEvent(QResizeEvent* arg__1);
716 virtual QPainter* sharedPainter() const;
725 virtual QPainter* sharedPainter() const;
717 virtual void showEvent(QShowEvent* arg__1);
726 virtual void showEvent(QShowEvent* arg__1);
718 virtual QSize sizeHint() const;
727 virtual QSize sizeHint() const;
719 virtual void tabletEvent(QTabletEvent* arg__1);
728 virtual void tabletEvent(QTabletEvent* arg__1);
720 virtual void timerEvent(QTimerEvent* arg__1);
729 virtual void timerEvent(QTimerEvent* arg__1);
721 virtual void wheelEvent(QWheelEvent* arg__1);
730 virtual void wheelEvent(QWheelEvent* arg__1);
722
731
723 PythonQtInstanceWrapper* _wrapper;
732 PythonQtInstanceWrapper* _wrapper;
724 };
733 };
725
734
726 class PythonQtWrapper_elfInfoWdgt : public QObject
735 class PythonQtWrapper_elfInfoWdgt : public QObject
727 { Q_OBJECT
736 { Q_OBJECT
728 public:
737 public:
729 public slots:
738 public slots:
730 elfInfoWdgt* new_elfInfoWdgt(QWidget* parent = 0);
739 elfInfoWdgt* new_elfInfoWdgt(QWidget* parent = 0);
731 void delete_elfInfoWdgt(elfInfoWdgt* obj) { delete obj; }
740 void delete_elfInfoWdgt(elfInfoWdgt* obj) { delete obj; }
732 };
741 };
733
742
734
743
735
744
736
745
737
746
738 class PythonQtWrapper_elfparser : public QObject
747 class PythonQtWrapper_elfparser : public QObject
739 { Q_OBJECT
748 { Q_OBJECT
740 public:
749 public:
741 public slots:
750 public slots:
742 elfparser* new_elfparser();
751 elfparser* new_elfparser();
743 void delete_elfparser(elfparser* obj) { delete obj; }
752 void delete_elfparser(elfparser* obj) { delete obj; }
744 int closeFile(elfparser* theWrappedObject);
753 int closeFile(elfparser* theWrappedObject);
745 QString getABI(elfparser* theWrappedObject);
754 QString getABI(elfparser* theWrappedObject);
746 QString getArchitecture(elfparser* theWrappedObject);
755 QString getArchitecture(elfparser* theWrappedObject);
747 QString getClass(elfparser* theWrappedObject);
756 QString getClass(elfparser* theWrappedObject);
748 QString getEndianness(elfparser* theWrappedObject);
757 QString getEndianness(elfparser* theWrappedObject);
749 qint64 getEntryPointAddress(elfparser* theWrappedObject);
758 qint64 getEntryPointAddress(elfparser* theWrappedObject);
750 bool getSectionData(elfparser* theWrappedObject, int index, char** buffer);
759 bool getSectionData(elfparser* theWrappedObject, int index, char** buffer);
751 qint64 getSectionDatasz(elfparser* theWrappedObject, int index);
760 qint64 getSectionDatasz(elfparser* theWrappedObject, int index);
752 qint64 getSectionMemsz(elfparser* theWrappedObject, int index);
761 qint64 getSectionMemsz(elfparser* theWrappedObject, int index);
753 QString getSectionName(elfparser* theWrappedObject, int index);
762 QString getSectionName(elfparser* theWrappedObject, int index);
754 qint64 getSectionPaddr(elfparser* theWrappedObject, int index);
763 qint64 getSectionPaddr(elfparser* theWrappedObject, int index);
755 QString getSectionType(elfparser* theWrappedObject, int index);
764 QString getSectionType(elfparser* theWrappedObject, int index);
756 int getSectioncount(elfparser* theWrappedObject);
765 int getSectioncount(elfparser* theWrappedObject);
757 qint64 getSegmentFilesz(elfparser* theWrappedObject, int index);
766 qint64 getSegmentFilesz(elfparser* theWrappedObject, int index);
758 QString getSegmentFlags(elfparser* theWrappedObject, int index);
767 QString getSegmentFlags(elfparser* theWrappedObject, int index);
759 qint64 getSegmentMemsz(elfparser* theWrappedObject, int index);
768 qint64 getSegmentMemsz(elfparser* theWrappedObject, int index);
760 qint64 getSegmentOffset(elfparser* theWrappedObject, int index);
769 qint64 getSegmentOffset(elfparser* theWrappedObject, int index);
761 qint64 getSegmentPaddr(elfparser* theWrappedObject, int index);
770 qint64 getSegmentPaddr(elfparser* theWrappedObject, int index);
762 QString getSegmentType(elfparser* theWrappedObject, int index);
771 QString getSegmentType(elfparser* theWrappedObject, int index);
763 qint64 getSegmentVaddr(elfparser* theWrappedObject, int index);
772 qint64 getSegmentVaddr(elfparser* theWrappedObject, int index);
764 int getSegmentcount(elfparser* theWrappedObject);
773 int getSegmentcount(elfparser* theWrappedObject);
765 QString getType(elfparser* theWrappedObject);
774 QString getType(elfparser* theWrappedObject);
766 qint64 getVersion(elfparser* theWrappedObject);
775 qint64 getVersion(elfparser* theWrappedObject);
767 bool static_elfparser_isElf(const QString& File);
776 bool static_elfparser_isElf(const QString& File);
768 bool iself(elfparser* theWrappedObject);
777 bool iself(elfparser* theWrappedObject);
769 bool isopened(elfparser* theWrappedObject);
778 bool isopened(elfparser* theWrappedObject);
770 int setFilename(elfparser* theWrappedObject, const QString& name);
779 int setFilename(elfparser* theWrappedObject, const QString& name);
771 };
780 };
772
781
773
782
General Comments 0
You need to be logged in to leave comments. Login now