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