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