##// 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
@@ -10,3 +10,4
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
@@ -61,6 +61,7 bool ElfFile::openFile(const QString &Fi
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
@@ -81,6 +82,7 int ElfFile::closeFile()
81 82 close(this->elfFile);
82 83 this->elfFile = NULL;
83 84 }
85 this->opened = false;
84 86 return 0;
85 87 }
86 88
@@ -106,7 +108,7 QList<codeFragment*> ElfFile::getFragmen
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 {
@@ -392,7 +394,7 QString ElfFile::getClass()
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()
@@ -487,13 +489,18 qint64 ElfFile::getEntryPointAddress()
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 }
@@ -742,6 +749,11 void ElfFile::updateSegments()
742 749 }
743 750 }
744 751
752 void ElfFile::updateSymbols()
753 {
754
755 }
756
745 757
746 758
747 759
Show file before | Show file after | Hide comments
@@ -63,8 +63,9 public:
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);
@@ -85,6 +86,7 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;
@@ -93,7 +95,7 private:
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
Show file before | Show file after | Hide comments
@@ -23,8 +23,10 void elfFileWidget::updateElfFile(ElfFil
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
Show file before | Show file after | Hide comments
@@ -143,7 +143,7
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">
@@ -156,7 +156,7
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>
@@ -168,7 +168,7
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>
Show file before | Show file after | Hide comments
@@ -22,15 +22,15
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 {
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
@@ -2,10 +2,49
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();
@@ -203,7 +242,7 QString PythonQtWrapper_ElfFile::getSec
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)
@@ -243,7 +282,7 qint64 PythonQtWrapper_ElfFile::getSegm
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)
@@ -278,13 +317,919 bool PythonQtWrapper_ElfFile::openFile(
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 {
@@ -312,6 +1257,942 PythonQtShell_QHexEdit::~PythonQtShell_Q
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); }
@@ -448,9 +2329,1022 QString PythonQtWrapper_QHexEdit::toRea
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 {
@@ -459,17 +3353,17 void PythonQtWrapper_QHexSpinBox::show(Q
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
@@ -478,6 +3372,908 PythonQtShell_SocExplorerPlot::~PythonQt
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); }
@@ -502,6 +4298,31 QPen PythonQtWrapper_SocExplorerPlot::g
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());
@@ -577,11 +4398,127 void PythonQtWrapper_SocExplorerPlot::sh
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 {
@@ -725,6 +4662,23 PythonQtShell_abstractExecFile::~PythonQ
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) {
@@ -753,6 +4707,79 if (_wrapper) {
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) {
@@ -837,6 +4864,23 if (_wrapper) {
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(); }
@@ -851,17 +4895,1833 codeFragment* PythonQtWrapper_codeFragme
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
Show file before | Show file after | Hide comments
@@ -1,6 +1,9
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>
@@ -8,8 +11,43
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
@@ -81,6 +119,62 void delete_ElfFile(ElfFile* obj) { dele
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:
@@ -105,6 +199,52 public:
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 };
@@ -147,6 +287,73 void delete_QHexEdit(QHexEdit* obj) { de
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:
@@ -170,10 +377,64 public:
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:
@@ -184,6 +445,11 void delete_SocExplorerPlot(SocExplorerP
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);
@@ -199,12 +465,29 void delete_SocExplorerPlot(SocExplorerP
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:
@@ -262,10 +545,15 public:
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 };
@@ -286,6 +574,7 class PythonQtShell_codeFragment : publi
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
@@ -298,15 +587,75 class PythonQtWrapper_codeFragment : pub
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:
@@ -319,6 +668,61 void delete_elfFileWidget(elfFileWidget*
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:
Show file before | Show file after | Hide comments
@@ -5,16 +5,16
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
@@ -4,7 +4,13
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" />
@@ -13,10 +19,30
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
Show file before | Show file after | Hide comments
@@ -3,4 +3,4
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