ElfFile classes WIP....
jeandet -
r40:91ff842275d6 default
Not Reviewed
Show More
Add another comment
TODOs: 0 unresolved 0 Resolved
COMMENTS: 0 General 0 Inline
@@ -10,3 +10,4
10 #include "elf/elffile.h"
10 #include "elf/elffile.h"
11 #include "elf/elffilewidget.h"
11 #include "elf/elffilewidget.h"
12 #include "elf/elfinfowdgt.h"
12 #include "elf/elfinfowdgt.h"
13 #include "QCustomPlot/qcustomplot.h"
@@ -61,6 +61,7 bool ElfFile::openFile(const QString &Fi
61 elf_getshdrstrndx (this->e, &this->shstrndx);
61 elf_getshdrstrndx (this->e, &this->shstrndx);
62 this->updateSegments();
62 this->updateSegments();
63 this->updateSections();
63 this->updateSections();
64 this->opened = true;
64 return 1;
65 return 1;
65 }
66 }
66
67
@@ -81,6 +82,7 int ElfFile::closeFile()
81 close(this->elfFile);
82 close(this->elfFile);
82 this->elfFile = NULL;
83 this->elfFile = NULL;
83 }
84 }
85 this->opened = false;
84 return 0;
86 return 0;
85 }
87 }
86
88
@@ -106,7 +108,7 QList<codeFragment*> ElfFile::getFragmen
106 codeFragment *ElfFile::getFragment(const QString &name)
108 codeFragment *ElfFile::getFragment(const QString &name)
107 {
109 {
108 codeFragment* fragment= new codeFragment();
110 codeFragment* fragment= new codeFragment();
109 for(int i=0;i<getSectioncount();i++)
111 for(int i=0;i<getSectionCount();i++)
110 {
112 {
111 if(getSectionName(i) == name)
113 if(getSectionName(i) == name)
112 {
114 {
@@ -392,7 +394,7 QString ElfFile::getClass()
392
394
393 bool ElfFile::iself()
395 bool ElfFile::iself()
394 {
396 {
395 return this->type_elf;
397 return (this->getType()!="Unknow");
396 }
398 }
397
399
398 QString ElfFile::getArchitecture()
400 QString ElfFile::getArchitecture()
@@ -487,13 +489,18 qint64 ElfFile::getEntryPointAddress()
487 }
489 }
488
490
489
491
490 int ElfFile::getSectioncount()
492 int ElfFile::getSectionCount()
491 {
493 {
492 return (int)this->SectionCount;
494 return (int)this->SectionCount;
493 }
495 }
494
496
497 int ElfFile::getSymbolCount()
498 {
499 return (int)this->SymbolCount;
500 }
495
501
496 int ElfFile::getSegmentcount()
502
503 int ElfFile::getSegmentCount()
497 {
504 {
498 return (int)this->SegmentCount;
505 return (int)this->SegmentCount;
499 }
506 }
@@ -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
@@ -63,8 +63,9 public:
63 QString getABI();
63 QString getABI();
64 qint64 getVersion();
64 qint64 getVersion();
65 qint64 getEntryPointAddress();
65 qint64 getEntryPointAddress();
66 int getSectioncount();
66 int getSectionCount();
67 int getSegmentcount();
67 int getSymbolCount();
68 int getSegmentCount();
68 QString getSegmentType(int index);
69 QString getSegmentType(int index);
69 qint64 getSegmentOffset(int index);
70 qint64 getSegmentOffset(int index);
70 qint64 getSegmentVaddr(int index);
71 qint64 getSegmentVaddr(int index);
@@ -85,6 +86,7 private:
85 codeFragment* getFragment(const QString& name);
86 codeFragment* getFragment(const QString& name);
86 void updateSections();
87 void updateSections();
87 void updateSegments();
88 void updateSegments();
89 void updateSymbols();
88 int elfFile;
90 int elfFile;
89 bool opened;
91 bool opened;
90 bool type_elf;
92 bool type_elf;
@@ -93,7 +95,7 private:
93 GElf_Ehdr ehdr;
95 GElf_Ehdr ehdr;
94 Elf_Scn * scn;
96 Elf_Scn * scn;
95 Elf_Data * data;
97 Elf_Data * data;
96 size_t SectionCount,SegmentCount, shstrndx;
98 size_t SymbolCount,SectionCount,SegmentCount, shstrndx;
97 QList<GElf_Phdr*> Segments;
99 QList<GElf_Phdr*> Segments;
98 QList<Elf_Section*> sections;
100 QList<Elf_Section*> sections;
99
101
@@ -23,8 +23,10 void elfFileWidget::updateElfFile(ElfFil
23 this->ui->machineLabel->setText(p_elf->getArchitecture());
23 this->ui->machineLabel->setText(p_elf->getArchitecture());
24 this->ui->endiannesLabel->setText(p_elf->getEndianness());
24 this->ui->endiannesLabel->setText(p_elf->getEndianness());
25 this->ui->abiLabel->setText(p_elf->getABI());
25 this->ui->abiLabel->setText(p_elf->getABI());
26 this->ui->entryPointLabel->setText("0x"+QString::number(p_elf->getEntryPointAddress(),16,8));
26 this->ui->entryPointLabel->setText(QString("0x%1").arg((uint)p_elf->getEntryPointAddress(),8,16));
27 this->ui->sectionCountLabel->setText(QString::number(p_elf->getSectioncount()));
27 this->ui->typeLabel->setText(p_elf->getType());
28 this->ui->sectionCountLabel->setText(QString::number(p_elf->getSectionCount()));
29 // this->ui->symbolCountLabel->setText(p_elf->get);
28 }
30 }
29 }
31 }
30
32
@@ -143,7 +143,7
143 <item row="1" column="0">
143 <item row="1" column="0">
144 <widget class="QGroupBox" name="groupBox_2">
144 <widget class="QGroupBox" name="groupBox_2">
145 <property name="title">
145 <property name="title">
146 <string>Sections</string>
146 <string>Sections &amp; Symbols</string>
147 </property>
147 </property>
148 <layout class="QFormLayout" name="formLayout_2">
148 <layout class="QFormLayout" name="formLayout_2">
149 <item row="0" column="0">
149 <item row="0" column="0">
@@ -156,7 +156,7
156 <item row="1" column="0">
156 <item row="1" column="0">
157 <widget class="QLabel" name="label_10">
157 <widget class="QLabel" name="label_10">
158 <property name="text">
158 <property name="text">
159 <string>Sections begin address:</string>
159 <string>Symbols count:</string>
160 </property>
160 </property>
161 </widget>
161 </widget>
162 </item>
162 </item>
@@ -168,7 +168,7
168 </widget>
168 </widget>
169 </item>
169 </item>
170 <item row="1" column="1">
170 <item row="1" column="1">
171 <widget class="QLabel" name="sectionBeginLabel">
171 <widget class="QLabel" name="symbolCountLabel">
172 <property name="text">
172 <property name="text">
173 <string>none</string>
173 <string>none</string>
174 </property>
174 </property>
@@ -22,15 +22,15
22 #ifndef ELFINFOWDGT_H
22 #ifndef ELFINFOWDGT_H
23 #define ELFINFOWDGT_H
23 #define ELFINFOWDGT_H
24
24
25 #include <QWidget>
25 #include <QtWidgets/QWidget>
26 #include "elfparser.h"
26 #include "elfparser.h"
27 #include <QVBoxLayout>
27 #include <QtWidgets/QVBoxLayout>
28 #include <QHBoxLayout>
28 #include <QtWidgets/QHBoxLayout>
29 #include <QLabel>
29 #include <QtWidgets/QLabel>
30 #include <QTextEdit>
30 #include <QtWidgets/QTextEdit>
31 #include <QTableWidget>
31 #include <QtWidgets/QTableWidget>
32 #include <qhexedit.h>
32 #include <qhexedit.h>
33 #include <QSplitter>
33 #include <QtWidgets/QSplitter>
34
34
35 class elfInfoWdgt : public QWidget
35 class elfInfoWdgt : public QWidget
36 {
36 {
This diff has been collapsed as it changes many lines, (5896 lines changed) Show them Hide them
@@ -2,10 +2,49
2 #include <PythonQtConversion.h>
2 #include <PythonQtConversion.h>
3 #include <PythonQtMethodInfo.h>
3 #include <PythonQtMethodInfo.h>
4 #include <PythonQtSignalReceiver.h>
4 #include <PythonQtSignalReceiver.h>
5 #include <QIconEngine>
6 #include <QObject>
7 #include <QSpinBox>
5 #include <QVariant>
8 #include <QVariant>
9 #include <QWidget>
6 #include <abstractexecfile.h>
10 #include <abstractexecfile.h>
7 #include <elffile.h>
11 #include <elffile.h>
8 #include <elfparser.h>
12 #include <elfparser.h>
13 #include <qaction.h>
14 #include <qbitmap.h>
15 #include <qbytearray.h>
16 #include <qcolor.h>
17 #include <qcoreevent.h>
18 #include <qcursor.h>
19 #include <qevent.h>
20 #include <qfont.h>
21 #include <qgraphicseffect.h>
22 #include <qgraphicsproxywidget.h>
23 #include <qkeysequence.h>
24 #include <qlayout.h>
25 #include <qlineedit.h>
26 #include <qlist.h>
27 #include <qlocale.h>
28 #include <qmargins.h>
29 #include <qobject.h>
30 #include <qpaintdevice.h>
31 #include <qpaintengine.h>
32 #include <qpainter.h>
33 #include <qpalette.h>
34 #include <qpen.h>
35 #include <qpixmap.h>
36 #include <qpoint.h>
37 #include <qrect.h>
38 #include <qregion.h>
39 #include <qscrollarea.h>
40 #include <qscrollbar.h>
41 #include <qsize.h>
42 #include <qsizepolicy.h>
43 #include <qspinbox.h>
44 #include <qstringlist.h>
45 #include <qstyle.h>
46 #include <qstyleoption.h>
47 #include <qwidget.h>
9
48
10 PythonQtShell_ElfFile::~PythonQtShell_ElfFile() {
49 PythonQtShell_ElfFile::~PythonQtShell_ElfFile() {
11 PythonQtPrivate* priv = PythonQt::priv();
50 PythonQtPrivate* priv = PythonQt::priv();
@@ -203,7 +242,7 QString PythonQtWrapper_ElfFile::getSec
203
242
204 int PythonQtWrapper_ElfFile::getSectioncount(ElfFile* theWrappedObject)
243 int PythonQtWrapper_ElfFile::getSectioncount(ElfFile* theWrappedObject)
205 {
244 {
206 return ( theWrappedObject->getSectioncount());
245 return ( theWrappedObject->getSectionCount());
207 }
246 }
208
247
209 qint64 PythonQtWrapper_ElfFile::getSegmentFilesz(ElfFile* theWrappedObject, int index)
248 qint64 PythonQtWrapper_ElfFile::getSegmentFilesz(ElfFile* theWrappedObject, int index)
@@ -243,7 +282,7 qint64 PythonQtWrapper_ElfFile::getSegm
243
282
244 int PythonQtWrapper_ElfFile::getSegmentcount(ElfFile* theWrappedObject)
283 int PythonQtWrapper_ElfFile::getSegmentcount(ElfFile* theWrappedObject)
245 {
284 {
246 return ( theWrappedObject->getSegmentcount());
285 return ( theWrappedObject->getSegmentCount());
247 }
286 }
248
287
249 QString PythonQtWrapper_ElfFile::getType(ElfFile* theWrappedObject)
288 QString PythonQtWrapper_ElfFile::getType(ElfFile* theWrappedObject)
@@ -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();