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