##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » SocExplorer
RSS
Abstract Binary files tools WIP.
jeandet -
r51:c839740ef520 default
parent child
Show More
Show file before | Show file after | Hide comments
@@ -20,6 +20,7
20 20 -- Mail : alexis.jeandet@member.fsf.org
21 21 ----------------------------------------------------------------------------*/
22 22 #include "binaryfile.h"
23 #include "srecfile.h"
23 24
24 25 binaryFile::binaryFile()
25 26 {
@@ -47,13 +48,6 bool binaryFile::openFile(const QString
47 48
48 49 bool binaryFile::openFiles(const QStringList &Files)
49 50 {
50 this->p_fileNames.clear();
51 this->p_fileNames.append(Files);
52 for(int i=0;i<p_files.count();i++)
53 {
54 delete p_files.at(i);
55 }
56 this->p_files.clear();
57 51 for(int i=0;i<Files.count();i++)
58 52 {
59 53 this->p_files.append(new QFile(Files.at(i)));
@@ -125,6 +119,13 QString binaryFile::getFragmentHeader(in
125 119 return "";
126 120 }
127 121
122 codeFragment *binaryFile::getFragment(int index)
123 {
124 if((index>=0)&&(index<p_fragments.count()))
125 return p_fragments.at(index);
126 return NULL;
127 }
128
128 129 bool binaryFile::getFragmentData(int index, char **buffer)
129 130 {
130 131 if((index>=0)&&(index<p_fragments.count()))
@@ -135,6 +136,31 bool binaryFile::getFragmentData(int ind
135 136 return false;
136 137 }
137 138
139 bool binaryFile::toSrec(const QString &fileName)
140 {
141 srecFile::toSrec(p_fragments,fileName);
142 }
143
144 bool binaryFile::toBinary(const QString &fileName)
145 {
146 toBinary(p_fragments,fileName);
147 }
148
149 bool binaryFile::toBinary(QList<codeFragment *> fragments, const QString &File)
150 {
151 QFile file(File);
152 file.open(QIODevice::WriteOnly);
153 if(file.isOpen())
154 {
155 for(int i=0;i<fragments.count();i++)
156 {
157 file.write(fragments.at(i)->data,fragments.at(i)->size);
158 }
159 return true;
160 }
161 return false;
162 }
163
138 164 void binaryFile::loadFile(QFile *file)
139 165 {
140 166 if (file->isOpen())
Show file before | Show file after | Hide comments
@@ -45,7 +45,11 public:
45 45 int getFragmentAddress(int index);
46 46 int getFragmentSize(int index);
47 47 QString getFragmentHeader(int index);
48 codeFragment* getFragment(int index);
48 49 bool getFragmentData(int index, char **buffer);
50 bool toSrec(const QString& fileName);
51 bool toBinary(const QString& fileName);
52 static bool toBinary(QList<codeFragment*> fragments,const QString& File);
49 53 signals:
50 54
51 55 public slots:
Show file before | Show file after | Hide comments
@@ -2,14 +2,22
2 2 #include "ui_binaryfilewidget.h"
3 3 #include "qtablewidgetintitem.h"
4 4 #include <QtWidgets/QTableWidget>
5 #include <QtWidgets/QFileDialog>
6 #include "srecfile.h"
5 7
6 8 binaryFileWidget::binaryFileWidget(QWidget *parent) :
7 QWidget(parent),
9 abstractBinFileWidget(parent),
8 10 ui(new Ui::binaryFileWidget)
9 11 {
10 12 ui->setupUi(this);
11 13 connect(this->ui->fragmentList,SIGNAL(cellActivated(int,int)),this,SLOT(fragmentCellActivated(int,int)));
12 14 connect(this->ui->fragmentList,SIGNAL(cellChanged(int,int)),this,SLOT(fragmentCellChanged(int,int)));
15 exportToSREC_action = new QAction(tr("Export to SREC"),this);
16 exportToBIN_action = new QAction(tr("Export to Binary"),this);
17 this->ui->fragmentList->addAction(exportToBIN_action);
18 this->ui->fragmentList->addAction(exportToSREC_action);
19 connect(this->exportToBIN_action,SIGNAL(triggered()),this,SLOT(exportToBIN()));
20 connect(this->exportToSREC_action,SIGNAL(triggered()),this,SLOT(exportToSREC()));
13 21 }
14 22
15 23 binaryFileWidget::~binaryFileWidget()
@@ -17,16 +25,16 binaryFileWidget::~binaryFileWidget()
17 25 delete ui;
18 26 }
19 27
20 void binaryFileWidget::updateBinaryFile(binaryFile *file)
28 void binaryFileWidget::setFile(abstractBinFile *file)
21 29 {
22 this->p_binfile = file;
30 this->p_binfile = (binaryFile*)file;
23 31 if(p_binfile->isopened())
24 32 {
25 updateFragments();
33 reloadFile();
26 34 }
27 35 }
28 36
29 void binaryFileWidget::updateFragments()
37 void binaryFileWidget::reloadFile()
30 38 {
31 39 this->ui->fragmentList->clear();
32 40 this->ui->fragmentList->setRowCount(p_binfile->getFragmentsCount());
@@ -80,3 +88,63 void binaryFileWidget::fragmentCellChang
80 88 this->p_binfile->getFragments().at(row)->address = newAddress;
81 89 }
82 90 }
91
92 void binaryFileWidget::exportToSREC()
93 {
94 QList<codeFragment *> SelectedFragmentsList=getSelectedFragments();
95 if(SelectedFragmentsList.count()>0)
96 {
97 QString fileName = QFileDialog::getSaveFileName(this, tr("Save File"),
98 NULL,
99 tr("SREC Files (*.srec)"));
100 if(!fileName.isEmpty())
101 {
102 srecFile::toSrec(SelectedFragmentsList,fileName);
103 }
104 }
105 }
106
107 void binaryFileWidget::exportToBIN()
108 {
109 QList<codeFragment *> SelectedFragmentsList=getSelectedFragments();
110 if(SelectedFragmentsList.count()>0)
111 {
112 QString fileName = QFileDialog::getSaveFileName(this, tr("Save File"),
113 NULL,
114 tr("Binary Files (*.bin)"));
115 if(!fileName.isEmpty())
116 {
117 binaryFile::toBinary(SelectedFragmentsList,fileName);
118 }
119 }
120 }
121
122 QStringList binaryFileWidget::getSelectedFilesNames()
123 {
124 QStringList SelectedFilesList;
125 QList<QTableWidgetItem*> items = this->ui->fragmentList->selectedItems();
126 for(int i=0;i<items.count();i++)
127 {
128 QString file = p_binfile->getFragmentHeader(items.at(i)->row());
129 if(!SelectedFilesList.contains(file))
130 {
131 SelectedFilesList.append(file);
132 }
133 }
134 return SelectedFilesList;
135 }
136
137 QList<codeFragment *> binaryFileWidget::getSelectedFragments()
138 {
139 QList<codeFragment *> SelectedFragmentsList;
140 QList<QTableWidgetItem*> items = this->ui->fragmentList->selectedItems();
141 for(int i=0;i<items.count();i++)
142 {
143 codeFragment * fragment = p_binfile->getFragment(items.at(i)->row());
144 if(!SelectedFragmentsList.contains(fragment))
145 {
146 SelectedFragmentsList.append(fragment);
147 }
148 }
149 return SelectedFragmentsList;
150 }
Show file before | Show file after | Hide comments
@@ -1,14 +1,36
1 /*------------------------------------------------------------------------------
2 -- This file is a part of the SocExplorer Software
3 -- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
4 --
5 -- This program is free software; you can redistribute it and/or modify
6 -- it under the terms of the GNU General Public License as published by
7 -- the Free Software Foundation; either version 2 of the License, or
8 -- (at your option) any later version.
9 --
10 -- This program is distributed in the hope that it will be useful,
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 -- GNU General Public License for more details.
14 --
15 -- You should have received a copy of the GNU General Public License
16 -- along with this program; if not, write to the Free Software
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 -------------------------------------------------------------------------------*/
19 /*-- Author : Alexis Jeandet
20 -- Mail : alexis.jeandet@member.fsf.org
21 ----------------------------------------------------------------------------*/
1 22 #ifndef BINARYFILEWIDGET_H
2 23 #define BINARYFILEWIDGET_H
3 24
4 25 #include <QWidget>
5 26 #include "binaryfile.h"
27 #include <QAction>
6 28
7 29 namespace Ui {
8 30 class binaryFileWidget;
9 31 }
10 32
11 class binaryFileWidget : public QWidget
33 class binaryFileWidget : public abstractBinFileWidget
12 34 {
13 35 Q_OBJECT
14 36
@@ -17,16 +39,22 public:
17 39 ~binaryFileWidget();
18 40
19 41 public slots:
20 void updateBinaryFile(binaryFile* file);
21 void updateFragments();
42 void setFile(abstractBinFile* file);
43 void reloadFile();
22 44
23 45 private slots:
24 46 void fragmentCellActivated(int row, int column);
25 47 void fragmentCellChanged(int row, int column);
48 void exportToSREC();
49 void exportToBIN();
26 50
27 51 private:
52 QStringList getSelectedFilesNames();
53 QList<codeFragment *> getSelectedFragments();
28 54 Ui::binaryFileWidget *ui;
29 55 binaryFile* p_binfile;
56 QAction* exportToSREC_action;
57 QAction* exportToBIN_action;
30 58 };
31 59
32 60 #endif // BINARYFILEWIDGET_H
Show file before | Show file after | Hide comments
@@ -28,6 +28,9
28 28 </property>
29 29 </widget>
30 30 <widget class="QTableWidget" name="fragmentList">
31 <property name="contextMenuPolicy">
32 <enum>Qt::ActionsContextMenu</enum>
33 </property>
31 34 <column>
32 35 <property name="text">
33 36 <string>File</string>
Show file before | Show file after | Hide comments
@@ -23,6 +23,7
23 23 #define ABSTRACTBINFILE_H
24 24
25 25 #include <QtCore/QObject>
26 #include <QtWidgets/QWidget>
26 27
27 28 class codeFragment
28 29 {
@@ -44,9 +45,23 public:
44 45 virtual bool isopened()=0;
45 46 virtual int closeFile()=0;
46 47 virtual QList<codeFragment*> getFragments()=0;
47
48 virtual bool toSrec(const QString& File)=0;
49 virtual bool toBinary(const QString& File)=0;
48 50 protected:
49 51 QString p_fileName;
50 52 };
51 53
54
55 class abstractBinFileWidget : public QWidget
56 {
57 Q_OBJECT
58
59 public:
60 abstractBinFileWidget(QWidget* parent = 0):QWidget(parent){};
61
62 public slots:
63 virtual void setFile(abstractBinFile* file)=0;
64 virtual void reloadFile()=0;
65 };
66
52 67 #endif // ABSTRACTBINFILE_H
Show file before | Show file after | Hide comments
@@ -72,7 +72,7 isEmpty(header.path) {
72 72
73 73 INSTALLS += target header
74 74
75 INCLUDEPATH += QCustomPlot qhexedit srec
75 INCLUDEPATH += QCustomPlot qhexedit srec BinFile
76 76
77 77 HEADERS += \
78 78 memsizewdgt.h \
Show file before | Show file after | Hide comments
@@ -22,7 +22,8
22 22 alexis.jeandet@member.fsf.org
23 23 ----------------------------------------------------------------------------*/
24 24 #include "elffile.h"
25 #include "srec/srecfile.h"
25 #include "srecfile.h"
26 #include "binaryfile.h"
26 27 #include <stdint.h>
27 28
28 29 ElfFile::ElfFile()
@@ -1066,3 +1067,8 bool ElfFile::toSrec(const QString &File
1066 1067 {
1067 1068 return srecFile::toSrec(this->getFragments(),File);
1068 1069 }
1070
1071 bool ElfFile::toBinary(const QString &File)
1072 {
1073 return binaryFile::toBinary(getFragments(),File);
1074 }
Show file before | Show file after | Hide comments
@@ -111,6 +111,7 public:
111 111 static bool isElf(const QString& File);
112 112
113 113 bool toSrec(const QString& File);
114 bool toBinary(const QString& File);
114 115
115 116 private:
116 117 codeFragment* getFragment(const QString& name);
Show file before | Show file after | Hide comments
@@ -25,10 +25,11
25 25 #include <QtWidgets/QFileDialog>
26 26 #include "qhexedit.h"
27 27 #include "qtablewidgetintitem.h"
28 #include "srec/srecfile.h"
28 #include "srecfile.h"
29 #include "binaryfile.h"
29 30
30 31 elfFileWidget::elfFileWidget(QWidget *parent) :
31 QWidget(parent),
32 abstractBinFileWidget(parent),
32 33 ui(new Ui::elfFileWidget)
33 34 {
34 35 ui->setupUi(this);
@@ -59,7 +60,7 elfFileWidget::~elfFileWidget()
59 60
60 61
61 62
62 void elfFileWidget::updateElfFile(ElfFile *file)
63 void elfFileWidget::setFile(ElfFile *file)
63 64 {
64 65 this->p_elf = file;
65 66 if(p_elf->isopened() && p_elf->iself())
@@ -74,6 +75,11 void elfFileWidget::updateElfFile(ElfFil
74 75 this->ui->sectionCountLabel->setText(QString::number(p_elf->getSectionCount()));
75 76 this->ui->symbolCountLabel->setText(QString::number(p_elf->getSymbolCount()));
76 77 }
78 reloadFile();
79 }
80
81 void elfFileWidget::reloadFile()
82 {
77 83 updateSymbols();
78 84 updateSections();
79 85 }
@@ -189,6 +195,17 void elfFileWidget::exportToSREC()
189 195
190 196 void elfFileWidget::exportToBIN()
191 197 {
198 QStringList sectionList=getSelectedSectionsNames();
199 if(sectionList.count()>0)
200 {
201 QString fileName = QFileDialog::getSaveFileName(this, tr("Save File"),
202 NULL,
203 tr("Binary Files (*.bin)"));
204 if(!fileName.isEmpty())
205 {
206 binaryFile::toBinary(p_elf->getFragments(sectionList),fileName);
207 }
208 }
192 209
193 210 }
194 211
Show file before | Show file after | Hide comments
@@ -31,7 +31,7 namespace Ui {
31 31 class elfFileWidget;
32 32 }
33 33
34 class elfFileWidget : public QWidget
34 class elfFileWidget : public abstractBinFileWidget
35 35 {
36 36 Q_OBJECT
37 37
@@ -40,7 +40,8 public:
40 40 ~elfFileWidget();
41 41
42 42 public slots:
43 void updateElfFile(ElfFile* file);
43 void setFile(ElfFile* file);
44 void reloadFile();
44 45 void updateSymbols();
45 46 void updateSections();
46 47
Show file before | Show file after | Hide comments
This diff has been collapsed as it changes many lines, (4025 lines changed) Show them Hide them
@@ -8,7 +8,6
8 8 #include <QVariant>
9 9 #include <QWidget>
10 10 #include <abstractbinfile.h>
11 #include <binaryfile.h>
12 11 #include <elffile.h>
13 12 #include <elfparser.h>
14 13 #include <qaction.h>
@@ -47,7 +46,6
47 46 #include <qstyle.h>
48 47 #include <qstyleoption.h>
49 48 #include <qwidget.h>
50 #include <srecfile.h>
51 49
52 50 PythonQtShell_ElfFile::~PythonQtShell_ElfFile() {
53 51 PythonQtPrivate* priv = PythonQt::priv();
@@ -165,6 +163,62 if (_wrapper) {
165 163 }
166 164 return ElfFile::openFile(File);
167 165 }
166 bool PythonQtShell_ElfFile::toBinary(const QString& File)
167 {
168 if (_wrapper) {
169 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
170 PyErr_Clear();
171 if (obj && !PythonQtSlotFunction_Check(obj)) {
172 static const char* argumentList[] ={"bool" , "const QString&"};
173 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
174 bool returnValue;
175 void* args[2] = {NULL, (void*)&File};
176 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
177 if (result) {
178 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
179 if (args[0]!=&returnValue) {
180 if (args[0]==NULL) {
181 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
182 } else {
183 returnValue = *((bool*)args[0]);
184 }
185 }
186 }
187 if (result) { Py_DECREF(result); }
188 Py_DECREF(obj);
189 return returnValue;
190 }
191 }
192 return ElfFile::toBinary(File);
193 }
194 bool PythonQtShell_ElfFile::toSrec(const QString& File)
195 {
196 if (_wrapper) {
197 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
198 PyErr_Clear();
199 if (obj && !PythonQtSlotFunction_Check(obj)) {
200 static const char* argumentList[] ={"bool" , "const QString&"};
201 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
202 bool returnValue;
203 void* args[2] = {NULL, (void*)&File};
204 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
205 if (result) {
206 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
207 if (args[0]!=&returnValue) {
208 if (args[0]==NULL) {
209 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
210 } else {
211 returnValue = *((bool*)args[0]);
212 }
213 }
214 }
215 if (result) { Py_DECREF(result); }
216 Py_DECREF(obj);
217 return returnValue;
218 }
219 }
220 return ElfFile::toSrec(File);
221 }
168 222 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile()
169 223 {
170 224 return new PythonQtShell_ElfFile(); }
@@ -368,9 +422,14 bool PythonQtWrapper_ElfFile::sectionIs
368 422 return ( theWrappedObject->sectionIsNobits(index));
369 423 }
370 424
425 bool PythonQtWrapper_ElfFile::toBinary(ElfFile* theWrappedObject, const QString& File)
426 {
427 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_toBinary(File));
428 }
429
371 430 bool PythonQtWrapper_ElfFile::toSrec(ElfFile* theWrappedObject, const QString& File)
372 431 {
373 return ( theWrappedObject->toSrec(File));
432 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_toSrec(File));
374 433 }
375 434
376 435
@@ -4964,12 +5023,1014 if (_wrapper) {
4964 5023 }
4965 5024 abstractBinFile::timerEvent(arg__1);
4966 5025 }
5026 bool PythonQtShell_abstractBinFile::toBinary(const QString& File)
5027 {
5028 if (_wrapper) {
5029 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
5030 PyErr_Clear();
5031 if (obj && !PythonQtSlotFunction_Check(obj)) {
5032 static const char* argumentList[] ={"bool" , "const QString&"};
5033 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5034 bool returnValue;
5035 void* args[2] = {NULL, (void*)&File};
5036 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5037 if (result) {
5038 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5039 if (args[0]!=&returnValue) {
5040 if (args[0]==NULL) {
5041 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
5042 } else {
5043 returnValue = *((bool*)args[0]);
5044 }
5045 }
5046 }
5047 if (result) { Py_DECREF(result); }
5048 Py_DECREF(obj);
5049 return returnValue;
5050 }
5051 }
5052 return bool();
5053 }
5054 bool PythonQtShell_abstractBinFile::toSrec(const QString& File)
5055 {
5056 if (_wrapper) {
5057 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
5058 PyErr_Clear();
5059 if (obj && !PythonQtSlotFunction_Check(obj)) {
5060 static const char* argumentList[] ={"bool" , "const QString&"};
5061 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5062 bool returnValue;
5063 void* args[2] = {NULL, (void*)&File};
5064 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5065 if (result) {
5066 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5067 if (args[0]!=&returnValue) {
5068 if (args[0]==NULL) {
5069 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
5070 } else {
5071 returnValue = *((bool*)args[0]);
5072 }
5073 }
5074 }
5075 if (result) { Py_DECREF(result); }
5076 Py_DECREF(obj);
5077 return returnValue;
5078 }
5079 }
5080 return bool();
5081 }
4967 5082 abstractBinFile* PythonQtWrapper_abstractBinFile::new_abstractBinFile()
4968 5083 {
4969 5084 return new PythonQtShell_abstractBinFile(); }
4970 5085
4971 5086
4972 5087
5088 PythonQtShell_abstractBinFileWidget::~PythonQtShell_abstractBinFileWidget() {
5089 PythonQtPrivate* priv = PythonQt::priv();
5090 if (priv) { priv->shellClassDeleted(this); }
5091 }
5092 void PythonQtShell_abstractBinFileWidget::actionEvent(QActionEvent* arg__1)
5093 {
5094 if (_wrapper) {
5095 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
5096 PyErr_Clear();
5097 if (obj && !PythonQtSlotFunction_Check(obj)) {
5098 static const char* argumentList[] ={"" , "QActionEvent*"};
5099 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5100 void* args[2] = {NULL, (void*)&arg__1};
5101 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5102 if (result) { Py_DECREF(result); }
5103 Py_DECREF(obj);
5104 return;
5105 }
5106 }
5107 abstractBinFileWidget::actionEvent(arg__1);
5108 }
5109 void PythonQtShell_abstractBinFileWidget::changeEvent(QEvent* arg__1)
5110 {
5111 if (_wrapper) {
5112 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
5113 PyErr_Clear();
5114 if (obj && !PythonQtSlotFunction_Check(obj)) {
5115 static const char* argumentList[] ={"" , "QEvent*"};
5116 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5117 void* args[2] = {NULL, (void*)&arg__1};
5118 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5119 if (result) { Py_DECREF(result); }
5120 Py_DECREF(obj);
5121 return;
5122 }
5123 }
5124 abstractBinFileWidget::changeEvent(arg__1);
5125 }
5126 void PythonQtShell_abstractBinFileWidget::childEvent(QChildEvent* arg__1)
5127 {
5128 if (_wrapper) {
5129 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
5130 PyErr_Clear();
5131 if (obj && !PythonQtSlotFunction_Check(obj)) {
5132 static const char* argumentList[] ={"" , "QChildEvent*"};
5133 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5134 void* args[2] = {NULL, (void*)&arg__1};
5135 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5136 if (result) { Py_DECREF(result); }
5137 Py_DECREF(obj);
5138 return;
5139 }
5140 }
5141 abstractBinFileWidget::childEvent(arg__1);
5142 }
5143 void PythonQtShell_abstractBinFileWidget::closeEvent(QCloseEvent* arg__1)
5144 {
5145 if (_wrapper) {
5146 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
5147 PyErr_Clear();
5148 if (obj && !PythonQtSlotFunction_Check(obj)) {
5149 static const char* argumentList[] ={"" , "QCloseEvent*"};
5150 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5151 void* args[2] = {NULL, (void*)&arg__1};
5152 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5153 if (result) { Py_DECREF(result); }
5154 Py_DECREF(obj);
5155 return;
5156 }
5157 }
5158 abstractBinFileWidget::closeEvent(arg__1);
5159 }
5160 void PythonQtShell_abstractBinFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
5161 {
5162 if (_wrapper) {
5163 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
5164 PyErr_Clear();
5165 if (obj && !PythonQtSlotFunction_Check(obj)) {
5166 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
5167 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5168 void* args[2] = {NULL, (void*)&arg__1};
5169 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5170 if (result) { Py_DECREF(result); }
5171 Py_DECREF(obj);
5172 return;
5173 }
5174 }
5175 abstractBinFileWidget::contextMenuEvent(arg__1);
5176 }
5177 void PythonQtShell_abstractBinFileWidget::customEvent(QEvent* arg__1)
5178 {
5179 if (_wrapper) {
5180 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
5181 PyErr_Clear();
5182 if (obj && !PythonQtSlotFunction_Check(obj)) {
5183 static const char* argumentList[] ={"" , "QEvent*"};
5184 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5185 void* args[2] = {NULL, (void*)&arg__1};
5186 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5187 if (result) { Py_DECREF(result); }
5188 Py_DECREF(obj);
5189 return;
5190 }
5191 }
5192 abstractBinFileWidget::customEvent(arg__1);
5193 }
5194 int PythonQtShell_abstractBinFileWidget::devType() const
5195 {
5196 if (_wrapper) {
5197 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
5198 PyErr_Clear();
5199 if (obj && !PythonQtSlotFunction_Check(obj)) {
5200 static const char* argumentList[] ={"int"};
5201 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5202 int returnValue;
5203 void* args[1] = {NULL};
5204 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5205 if (result) {
5206 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5207 if (args[0]!=&returnValue) {
5208 if (args[0]==NULL) {
5209 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
5210 } else {
5211 returnValue = *((int*)args[0]);
5212 }
5213 }
5214 }
5215 if (result) { Py_DECREF(result); }
5216 Py_DECREF(obj);
5217 return returnValue;
5218 }
5219 }
5220 return abstractBinFileWidget::devType();
5221 }
5222 void PythonQtShell_abstractBinFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
5223 {
5224 if (_wrapper) {
5225 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
5226 PyErr_Clear();
5227 if (obj && !PythonQtSlotFunction_Check(obj)) {
5228 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
5229 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5230 void* args[2] = {NULL, (void*)&arg__1};
5231 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5232 if (result) { Py_DECREF(result); }
5233 Py_DECREF(obj);
5234 return;
5235 }
5236 }
5237 abstractBinFileWidget::dragEnterEvent(arg__1);
5238 }
5239 void PythonQtShell_abstractBinFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
5240 {
5241 if (_wrapper) {
5242 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
5243 PyErr_Clear();
5244 if (obj && !PythonQtSlotFunction_Check(obj)) {
5245 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
5246 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5247 void* args[2] = {NULL, (void*)&arg__1};
5248 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5249 if (result) { Py_DECREF(result); }
5250 Py_DECREF(obj);
5251 return;
5252 }
5253 }
5254 abstractBinFileWidget::dragLeaveEvent(arg__1);
5255 }
5256 void PythonQtShell_abstractBinFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
5257 {
5258 if (_wrapper) {
5259 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
5260 PyErr_Clear();
5261 if (obj && !PythonQtSlotFunction_Check(obj)) {
5262 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
5263 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5264 void* args[2] = {NULL, (void*)&arg__1};
5265 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5266 if (result) { Py_DECREF(result); }
5267 Py_DECREF(obj);
5268 return;
5269 }
5270 }
5271 abstractBinFileWidget::dragMoveEvent(arg__1);
5272 }
5273 void PythonQtShell_abstractBinFileWidget::dropEvent(QDropEvent* arg__1)
5274 {
5275 if (_wrapper) {
5276 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
5277 PyErr_Clear();
5278 if (obj && !PythonQtSlotFunction_Check(obj)) {
5279 static const char* argumentList[] ={"" , "QDropEvent*"};
5280 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5281 void* args[2] = {NULL, (void*)&arg__1};
5282 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5283 if (result) { Py_DECREF(result); }
5284 Py_DECREF(obj);
5285 return;
5286 }
5287 }
5288 abstractBinFileWidget::dropEvent(arg__1);
5289 }
5290 void PythonQtShell_abstractBinFileWidget::enterEvent(QEvent* arg__1)
5291 {
5292 if (_wrapper) {
5293 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
5294 PyErr_Clear();
5295 if (obj && !PythonQtSlotFunction_Check(obj)) {
5296 static const char* argumentList[] ={"" , "QEvent*"};
5297 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5298 void* args[2] = {NULL, (void*)&arg__1};
5299 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5300 if (result) { Py_DECREF(result); }
5301 Py_DECREF(obj);
5302 return;
5303 }
5304 }
5305 abstractBinFileWidget::enterEvent(arg__1);
5306 }
5307 bool PythonQtShell_abstractBinFileWidget::event(QEvent* arg__1)
5308 {
5309 if (_wrapper) {
5310 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
5311 PyErr_Clear();
5312 if (obj && !PythonQtSlotFunction_Check(obj)) {
5313 static const char* argumentList[] ={"bool" , "QEvent*"};
5314 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5315 bool returnValue;
5316 void* args[2] = {NULL, (void*)&arg__1};
5317 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5318 if (result) {
5319 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5320 if (args[0]!=&returnValue) {
5321 if (args[0]==NULL) {
5322 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
5323 } else {
5324 returnValue = *((bool*)args[0]);
5325 }
5326 }
5327 }
5328 if (result) { Py_DECREF(result); }
5329 Py_DECREF(obj);
5330 return returnValue;
5331 }
5332 }
5333 return abstractBinFileWidget::event(arg__1);
5334 }
5335 bool PythonQtShell_abstractBinFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
5336 {
5337 if (_wrapper) {
5338 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
5339 PyErr_Clear();
5340 if (obj && !PythonQtSlotFunction_Check(obj)) {
5341 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5342 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5343 bool returnValue;
5344 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
5345 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5346 if (result) {
5347 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5348 if (args[0]!=&returnValue) {
5349 if (args[0]==NULL) {
5350 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
5351 } else {
5352 returnValue = *((bool*)args[0]);
5353 }
5354 }
5355 }
5356 if (result) { Py_DECREF(result); }
5357 Py_DECREF(obj);
5358 return returnValue;
5359 }
5360 }
5361 return abstractBinFileWidget::eventFilter(arg__1, arg__2);
5362 }
5363 void PythonQtShell_abstractBinFileWidget::focusInEvent(QFocusEvent* arg__1)
5364 {
5365 if (_wrapper) {
5366 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
5367 PyErr_Clear();
5368 if (obj && !PythonQtSlotFunction_Check(obj)) {
5369 static const char* argumentList[] ={"" , "QFocusEvent*"};
5370 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5371 void* args[2] = {NULL, (void*)&arg__1};
5372 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5373 if (result) { Py_DECREF(result); }
5374 Py_DECREF(obj);
5375 return;
5376 }
5377 }
5378 abstractBinFileWidget::focusInEvent(arg__1);
5379 }
5380 bool PythonQtShell_abstractBinFileWidget::focusNextPrevChild(bool next)
5381 {
5382 if (_wrapper) {
5383 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
5384 PyErr_Clear();
5385 if (obj && !PythonQtSlotFunction_Check(obj)) {
5386 static const char* argumentList[] ={"bool" , "bool"};
5387 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5388 bool returnValue;
5389 void* args[2] = {NULL, (void*)&next};
5390 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5391 if (result) {
5392 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5393 if (args[0]!=&returnValue) {
5394 if (args[0]==NULL) {
5395 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
5396 } else {
5397 returnValue = *((bool*)args[0]);
5398 }
5399 }
5400 }
5401 if (result) { Py_DECREF(result); }
5402 Py_DECREF(obj);
5403 return returnValue;
5404 }
5405 }
5406 return abstractBinFileWidget::focusNextPrevChild(next);
5407 }
5408 void PythonQtShell_abstractBinFileWidget::focusOutEvent(QFocusEvent* arg__1)
5409 {
5410 if (_wrapper) {
5411 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
5412 PyErr_Clear();
5413 if (obj && !PythonQtSlotFunction_Check(obj)) {
5414 static const char* argumentList[] ={"" , "QFocusEvent*"};
5415 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5416 void* args[2] = {NULL, (void*)&arg__1};
5417 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5418 if (result) { Py_DECREF(result); }
5419 Py_DECREF(obj);
5420 return;
5421 }
5422 }
5423 abstractBinFileWidget::focusOutEvent(arg__1);
5424 }
5425 bool PythonQtShell_abstractBinFileWidget::hasHeightForWidth() const
5426 {
5427 if (_wrapper) {
5428 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
5429 PyErr_Clear();
5430 if (obj && !PythonQtSlotFunction_Check(obj)) {
5431 static const char* argumentList[] ={"bool"};
5432 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5433 bool returnValue;
5434 void* args[1] = {NULL};
5435 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5436 if (result) {
5437 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5438 if (args[0]!=&returnValue) {
5439 if (args[0]==NULL) {
5440 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
5441 } else {
5442 returnValue = *((bool*)args[0]);
5443 }
5444 }
5445 }
5446 if (result) { Py_DECREF(result); }
5447 Py_DECREF(obj);
5448 return returnValue;
5449 }
5450 }
5451 return abstractBinFileWidget::hasHeightForWidth();
5452 }
5453 int PythonQtShell_abstractBinFileWidget::heightForWidth(int arg__1) const
5454 {
5455 if (_wrapper) {
5456 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
5457 PyErr_Clear();
5458 if (obj && !PythonQtSlotFunction_Check(obj)) {
5459 static const char* argumentList[] ={"int" , "int"};
5460 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5461 int returnValue;
5462 void* args[2] = {NULL, (void*)&arg__1};
5463 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5464 if (result) {
5465 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5466 if (args[0]!=&returnValue) {
5467 if (args[0]==NULL) {
5468 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
5469 } else {
5470 returnValue = *((int*)args[0]);
5471 }
5472 }
5473 }
5474 if (result) { Py_DECREF(result); }
5475 Py_DECREF(obj);
5476 return returnValue;
5477 }
5478 }
5479 return abstractBinFileWidget::heightForWidth(arg__1);
5480 }
5481 void PythonQtShell_abstractBinFileWidget::hideEvent(QHideEvent* arg__1)
5482 {
5483 if (_wrapper) {
5484 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
5485 PyErr_Clear();
5486 if (obj && !PythonQtSlotFunction_Check(obj)) {
5487 static const char* argumentList[] ={"" , "QHideEvent*"};
5488 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5489 void* args[2] = {NULL, (void*)&arg__1};
5490 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5491 if (result) { Py_DECREF(result); }
5492 Py_DECREF(obj);
5493 return;
5494 }
5495 }
5496 abstractBinFileWidget::hideEvent(arg__1);
5497 }
5498 void PythonQtShell_abstractBinFileWidget::initPainter(QPainter* painter) const
5499 {
5500 if (_wrapper) {
5501 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
5502 PyErr_Clear();
5503 if (obj && !PythonQtSlotFunction_Check(obj)) {
5504 static const char* argumentList[] ={"" , "QPainter*"};
5505 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5506 void* args[2] = {NULL, (void*)&painter};
5507 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5508 if (result) { Py_DECREF(result); }
5509 Py_DECREF(obj);
5510 return;
5511 }
5512 }
5513 abstractBinFileWidget::initPainter(painter);
5514 }
5515 void PythonQtShell_abstractBinFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
5516 {
5517 if (_wrapper) {
5518 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
5519 PyErr_Clear();
5520 if (obj && !PythonQtSlotFunction_Check(obj)) {
5521 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
5522 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5523 void* args[2] = {NULL, (void*)&arg__1};
5524 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5525 if (result) { Py_DECREF(result); }
5526 Py_DECREF(obj);
5527 return;
5528 }
5529 }
5530 abstractBinFileWidget::inputMethodEvent(arg__1);
5531 }
5532 QVariant PythonQtShell_abstractBinFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
5533 {
5534 if (_wrapper) {
5535 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
5536 PyErr_Clear();
5537 if (obj && !PythonQtSlotFunction_Check(obj)) {
5538 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
5539 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5540 QVariant returnValue;
5541 void* args[2] = {NULL, (void*)&arg__1};
5542 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5543 if (result) {
5544 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5545 if (args[0]!=&returnValue) {
5546 if (args[0]==NULL) {
5547 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
5548 } else {
5549 returnValue = *((QVariant*)args[0]);
5550 }
5551 }
5552 }
5553 if (result) { Py_DECREF(result); }
5554 Py_DECREF(obj);
5555 return returnValue;
5556 }
5557 }
5558 return abstractBinFileWidget::inputMethodQuery(arg__1);
5559 }
5560 void PythonQtShell_abstractBinFileWidget::keyPressEvent(QKeyEvent* arg__1)
5561 {
5562 if (_wrapper) {
5563 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
5564 PyErr_Clear();
5565 if (obj && !PythonQtSlotFunction_Check(obj)) {
5566 static const char* argumentList[] ={"" , "QKeyEvent*"};
5567 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5568 void* args[2] = {NULL, (void*)&arg__1};
5569 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5570 if (result) { Py_DECREF(result); }
5571 Py_DECREF(obj);
5572 return;
5573 }
5574 }
5575 abstractBinFileWidget::keyPressEvent(arg__1);
5576 }
5577 void PythonQtShell_abstractBinFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
5578 {
5579 if (_wrapper) {
5580 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
5581 PyErr_Clear();
5582 if (obj && !PythonQtSlotFunction_Check(obj)) {
5583 static const char* argumentList[] ={"" , "QKeyEvent*"};
5584 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5585 void* args[2] = {NULL, (void*)&arg__1};
5586 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5587 if (result) { Py_DECREF(result); }
5588 Py_DECREF(obj);
5589 return;
5590 }
5591 }
5592 abstractBinFileWidget::keyReleaseEvent(arg__1);
5593 }
5594 void PythonQtShell_abstractBinFileWidget::leaveEvent(QEvent* arg__1)
5595 {
5596 if (_wrapper) {
5597 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
5598 PyErr_Clear();
5599 if (obj && !PythonQtSlotFunction_Check(obj)) {
5600 static const char* argumentList[] ={"" , "QEvent*"};
5601 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5602 void* args[2] = {NULL, (void*)&arg__1};
5603 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5604 if (result) { Py_DECREF(result); }
5605 Py_DECREF(obj);
5606 return;
5607 }
5608 }
5609 abstractBinFileWidget::leaveEvent(arg__1);
5610 }
5611 int PythonQtShell_abstractBinFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
5612 {
5613 if (_wrapper) {
5614 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
5615 PyErr_Clear();
5616 if (obj && !PythonQtSlotFunction_Check(obj)) {
5617 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
5618 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5619 int returnValue;
5620 void* args[2] = {NULL, (void*)&arg__1};
5621 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5622 if (result) {
5623 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5624 if (args[0]!=&returnValue) {
5625 if (args[0]==NULL) {
5626 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
5627 } else {
5628 returnValue = *((int*)args[0]);
5629 }
5630 }
5631 }
5632 if (result) { Py_DECREF(result); }
5633 Py_DECREF(obj);
5634 return returnValue;
5635 }
5636 }
5637 return abstractBinFileWidget::metric(arg__1);
5638 }
5639 QSize PythonQtShell_abstractBinFileWidget::minimumSizeHint() const
5640 {
5641 if (_wrapper) {
5642 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
5643 PyErr_Clear();
5644 if (obj && !PythonQtSlotFunction_Check(obj)) {
5645 static const char* argumentList[] ={"QSize"};
5646 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5647 QSize returnValue;
5648 void* args[1] = {NULL};
5649 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5650 if (result) {
5651 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5652 if (args[0]!=&returnValue) {
5653 if (args[0]==NULL) {
5654 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
5655 } else {
5656 returnValue = *((QSize*)args[0]);
5657 }
5658 }
5659 }
5660 if (result) { Py_DECREF(result); }
5661 Py_DECREF(obj);
5662 return returnValue;
5663 }
5664 }
5665 return abstractBinFileWidget::minimumSizeHint();
5666 }
5667 void PythonQtShell_abstractBinFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
5668 {
5669 if (_wrapper) {
5670 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
5671 PyErr_Clear();
5672 if (obj && !PythonQtSlotFunction_Check(obj)) {
5673 static const char* argumentList[] ={"" , "QMouseEvent*"};
5674 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5675 void* args[2] = {NULL, (void*)&arg__1};
5676 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5677 if (result) { Py_DECREF(result); }
5678 Py_DECREF(obj);
5679 return;
5680 }
5681 }
5682 abstractBinFileWidget::mouseDoubleClickEvent(arg__1);
5683 }
5684 void PythonQtShell_abstractBinFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
5685 {
5686 if (_wrapper) {
5687 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
5688 PyErr_Clear();
5689 if (obj && !PythonQtSlotFunction_Check(obj)) {
5690 static const char* argumentList[] ={"" , "QMouseEvent*"};
5691 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5692 void* args[2] = {NULL, (void*)&arg__1};
5693 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5694 if (result) { Py_DECREF(result); }
5695 Py_DECREF(obj);
5696 return;
5697 }
5698 }
5699 abstractBinFileWidget::mouseMoveEvent(arg__1);
5700 }
5701 void PythonQtShell_abstractBinFileWidget::mousePressEvent(QMouseEvent* arg__1)
5702 {
5703 if (_wrapper) {
5704 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
5705 PyErr_Clear();
5706 if (obj && !PythonQtSlotFunction_Check(obj)) {
5707 static const char* argumentList[] ={"" , "QMouseEvent*"};
5708 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5709 void* args[2] = {NULL, (void*)&arg__1};
5710 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5711 if (result) { Py_DECREF(result); }
5712 Py_DECREF(obj);
5713 return;
5714 }
5715 }
5716 abstractBinFileWidget::mousePressEvent(arg__1);
5717 }
5718 void PythonQtShell_abstractBinFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
5719 {
5720 if (_wrapper) {
5721 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
5722 PyErr_Clear();
5723 if (obj && !PythonQtSlotFunction_Check(obj)) {
5724 static const char* argumentList[] ={"" , "QMouseEvent*"};
5725 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5726 void* args[2] = {NULL, (void*)&arg__1};
5727 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5728 if (result) { Py_DECREF(result); }
5729 Py_DECREF(obj);
5730 return;
5731 }
5732 }
5733 abstractBinFileWidget::mouseReleaseEvent(arg__1);
5734 }
5735 void PythonQtShell_abstractBinFileWidget::moveEvent(QMoveEvent* arg__1)
5736 {
5737 if (_wrapper) {
5738 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
5739 PyErr_Clear();
5740 if (obj && !PythonQtSlotFunction_Check(obj)) {
5741 static const char* argumentList[] ={"" , "QMoveEvent*"};
5742 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5743 void* args[2] = {NULL, (void*)&arg__1};
5744 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5745 if (result) { Py_DECREF(result); }
5746 Py_DECREF(obj);
5747 return;
5748 }
5749 }
5750 abstractBinFileWidget::moveEvent(arg__1);
5751 }
5752 bool PythonQtShell_abstractBinFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result)
5753 {
5754 if (_wrapper) {
5755 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
5756 PyErr_Clear();
5757 if (obj && !PythonQtSlotFunction_Check(obj)) {
5758 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
5759 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
5760 bool returnValue;
5761 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
5762 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5763 if (result) {
5764 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5765 if (args[0]!=&returnValue) {
5766 if (args[0]==NULL) {
5767 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
5768 } else {
5769 returnValue = *((bool*)args[0]);
5770 }
5771 }
5772 }
5773 if (result) { Py_DECREF(result); }
5774 Py_DECREF(obj);
5775 return returnValue;
5776 }
5777 }
5778 return abstractBinFileWidget::nativeEvent(eventType, message, result);
5779 }
5780 QPaintEngine* PythonQtShell_abstractBinFileWidget::paintEngine() const
5781 {
5782 if (_wrapper) {
5783 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
5784 PyErr_Clear();
5785 if (obj && !PythonQtSlotFunction_Check(obj)) {
5786 static const char* argumentList[] ={"QPaintEngine*"};
5787 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5788 QPaintEngine* returnValue;
5789 void* args[1] = {NULL};
5790 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5791 if (result) {
5792 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5793 if (args[0]!=&returnValue) {
5794 if (args[0]==NULL) {
5795 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
5796 } else {
5797 returnValue = *((QPaintEngine**)args[0]);
5798 }
5799 }
5800 }
5801 if (result) { Py_DECREF(result); }
5802 Py_DECREF(obj);
5803 return returnValue;
5804 }
5805 }
5806 return abstractBinFileWidget::paintEngine();
5807 }
5808 void PythonQtShell_abstractBinFileWidget::paintEvent(QPaintEvent* arg__1)
5809 {
5810 if (_wrapper) {
5811 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
5812 PyErr_Clear();
5813 if (obj && !PythonQtSlotFunction_Check(obj)) {
5814 static const char* argumentList[] ={"" , "QPaintEvent*"};
5815 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5816 void* args[2] = {NULL, (void*)&arg__1};
5817 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5818 if (result) { Py_DECREF(result); }
5819 Py_DECREF(obj);
5820 return;
5821 }
5822 }
5823 abstractBinFileWidget::paintEvent(arg__1);
5824 }
5825 QPaintDevice* PythonQtShell_abstractBinFileWidget::redirected(QPoint* offset) const
5826 {
5827 if (_wrapper) {
5828 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
5829 PyErr_Clear();
5830 if (obj && !PythonQtSlotFunction_Check(obj)) {
5831 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
5832 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5833 QPaintDevice* returnValue;
5834 void* args[2] = {NULL, (void*)&offset};
5835 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5836 if (result) {
5837 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5838 if (args[0]!=&returnValue) {
5839 if (args[0]==NULL) {
5840 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
5841 } else {
5842 returnValue = *((QPaintDevice**)args[0]);
5843 }
5844 }
5845 }
5846 if (result) { Py_DECREF(result); }
5847 Py_DECREF(obj);
5848 return returnValue;
5849 }
5850 }
5851 return abstractBinFileWidget::redirected(offset);
5852 }
5853 void PythonQtShell_abstractBinFileWidget::reloadFile()
5854 {
5855 if (_wrapper) {
5856 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
5857 PyErr_Clear();
5858 if (obj && !PythonQtSlotFunction_Check(obj)) {
5859 static const char* argumentList[] ={""};
5860 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5861 void* args[1] = {NULL};
5862 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5863 if (result) { Py_DECREF(result); }
5864 Py_DECREF(obj);
5865 return;
5866 }
5867 }
5868
5869 }
5870 void PythonQtShell_abstractBinFileWidget::resizeEvent(QResizeEvent* arg__1)
5871 {
5872 if (_wrapper) {
5873 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
5874 PyErr_Clear();
5875 if (obj && !PythonQtSlotFunction_Check(obj)) {
5876 static const char* argumentList[] ={"" , "QResizeEvent*"};
5877 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5878 void* args[2] = {NULL, (void*)&arg__1};
5879 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5880 if (result) { Py_DECREF(result); }
5881 Py_DECREF(obj);
5882 return;
5883 }
5884 }
5885 abstractBinFileWidget::resizeEvent(arg__1);
5886 }
5887 void PythonQtShell_abstractBinFileWidget::setFile(abstractBinFile* file)
5888 {
5889 if (_wrapper) {
5890 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
5891 PyErr_Clear();
5892 if (obj && !PythonQtSlotFunction_Check(obj)) {
5893 static const char* argumentList[] ={"" , "abstractBinFile*"};
5894 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5895 void* args[2] = {NULL, (void*)&file};
5896 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5897 if (result) { Py_DECREF(result); }
5898 Py_DECREF(obj);
5899 return;
5900 }
5901 }
5902
5903 }
5904 QPainter* PythonQtShell_abstractBinFileWidget::sharedPainter() const
5905 {
5906 if (_wrapper) {
5907 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
5908 PyErr_Clear();
5909 if (obj && !PythonQtSlotFunction_Check(obj)) {
5910 static const char* argumentList[] ={"QPainter*"};
5911 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5912 QPainter* returnValue;
5913 void* args[1] = {NULL};
5914 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5915 if (result) {
5916 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5917 if (args[0]!=&returnValue) {
5918 if (args[0]==NULL) {
5919 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
5920 } else {
5921 returnValue = *((QPainter**)args[0]);
5922 }
5923 }
5924 }
5925 if (result) { Py_DECREF(result); }
5926 Py_DECREF(obj);
5927 return returnValue;
5928 }
5929 }
5930 return abstractBinFileWidget::sharedPainter();
5931 }
5932 void PythonQtShell_abstractBinFileWidget::showEvent(QShowEvent* arg__1)
5933 {
5934 if (_wrapper) {
5935 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
5936 PyErr_Clear();
5937 if (obj && !PythonQtSlotFunction_Check(obj)) {
5938 static const char* argumentList[] ={"" , "QShowEvent*"};
5939 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5940 void* args[2] = {NULL, (void*)&arg__1};
5941 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5942 if (result) { Py_DECREF(result); }
5943 Py_DECREF(obj);
5944 return;
5945 }
5946 }
5947 abstractBinFileWidget::showEvent(arg__1);
5948 }
5949 QSize PythonQtShell_abstractBinFileWidget::sizeHint() const
5950 {
5951 if (_wrapper) {
5952 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
5953 PyErr_Clear();
5954 if (obj && !PythonQtSlotFunction_Check(obj)) {
5955 static const char* argumentList[] ={"QSize"};
5956 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5957 QSize returnValue;
5958 void* args[1] = {NULL};
5959 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5960 if (result) {
5961 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5962 if (args[0]!=&returnValue) {
5963 if (args[0]==NULL) {
5964 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
5965 } else {
5966 returnValue = *((QSize*)args[0]);
5967 }
5968 }
5969 }
5970 if (result) { Py_DECREF(result); }
5971 Py_DECREF(obj);
5972 return returnValue;
5973 }
5974 }
5975 return abstractBinFileWidget::sizeHint();
5976 }
5977 void PythonQtShell_abstractBinFileWidget::tabletEvent(QTabletEvent* arg__1)
5978 {
5979 if (_wrapper) {
5980 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
5981 PyErr_Clear();
5982 if (obj && !PythonQtSlotFunction_Check(obj)) {
5983 static const char* argumentList[] ={"" , "QTabletEvent*"};
5984 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5985 void* args[2] = {NULL, (void*)&arg__1};
5986 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5987 if (result) { Py_DECREF(result); }
5988 Py_DECREF(obj);
5989 return;
5990 }
5991 }
5992 abstractBinFileWidget::tabletEvent(arg__1);
5993 }
5994 void PythonQtShell_abstractBinFileWidget::timerEvent(QTimerEvent* arg__1)
5995 {
5996 if (_wrapper) {
5997 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
5998 PyErr_Clear();
5999 if (obj && !PythonQtSlotFunction_Check(obj)) {
6000 static const char* argumentList[] ={"" , "QTimerEvent*"};
6001 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6002 void* args[2] = {NULL, (void*)&arg__1};
6003 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6004 if (result) { Py_DECREF(result); }
6005 Py_DECREF(obj);
6006 return;
6007 }
6008 }
6009 abstractBinFileWidget::timerEvent(arg__1);
6010 }
6011 void PythonQtShell_abstractBinFileWidget::wheelEvent(QWheelEvent* arg__1)
6012 {
6013 if (_wrapper) {
6014 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
6015 PyErr_Clear();
6016 if (obj && !PythonQtSlotFunction_Check(obj)) {
6017 static const char* argumentList[] ={"" , "QWheelEvent*"};
6018 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6019 void* args[2] = {NULL, (void*)&arg__1};
6020 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6021 if (result) { Py_DECREF(result); }
6022 Py_DECREF(obj);
6023 return;
6024 }
6025 }
6026 abstractBinFileWidget::wheelEvent(arg__1);
6027 }
6028 abstractBinFileWidget* PythonQtWrapper_abstractBinFileWidget::new_abstractBinFileWidget(QWidget* parent)
6029 {
6030 return new PythonQtShell_abstractBinFileWidget(parent); }
6031
6032
6033
4973 6034 PythonQtShell_binaryFile::~PythonQtShell_binaryFile() {
4974 6035 PythonQtPrivate* priv = PythonQt::priv();
4975 6036 if (priv) { priv->shellClassDeleted(this); }
@@ -5086,6 +6147,62 if (_wrapper) {
5086 6147 }
5087 6148 return binaryFile::openFile(File);
5088 6149 }
6150 bool PythonQtShell_binaryFile::toBinary(const QString& fileName)
6151 {
6152 if (_wrapper) {
6153 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
6154 PyErr_Clear();
6155 if (obj && !PythonQtSlotFunction_Check(obj)) {
6156 static const char* argumentList[] ={"bool" , "const QString&"};
6157 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6158 bool returnValue;
6159 void* args[2] = {NULL, (void*)&fileName};
6160 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6161 if (result) {
6162 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6163 if (args[0]!=&returnValue) {
6164 if (args[0]==NULL) {
6165 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
6166 } else {
6167 returnValue = *((bool*)args[0]);
6168 }
6169 }
6170 }
6171 if (result) { Py_DECREF(result); }
6172 Py_DECREF(obj);
6173 return returnValue;
6174 }
6175 }
6176 return binaryFile::toBinary(fileName);
6177 }
6178 bool PythonQtShell_binaryFile::toSrec(const QString& fileName)
6179 {
6180 if (_wrapper) {
6181 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
6182 PyErr_Clear();
6183 if (obj && !PythonQtSlotFunction_Check(obj)) {
6184 static const char* argumentList[] ={"bool" , "const QString&"};
6185 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6186 bool returnValue;
6187 void* args[2] = {NULL, (void*)&fileName};
6188 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6189 if (result) {
6190 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6191 if (args[0]!=&returnValue) {
6192 if (args[0]==NULL) {
6193 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
6194 } else {
6195 returnValue = *((bool*)args[0]);
6196 }
6197 }
6198 }
6199 if (result) { Py_DECREF(result); }
6200 Py_DECREF(obj);
6201 return returnValue;
6202 }
6203 }
6204 return binaryFile::toSrec(fileName);
6205 }
5089 6206 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile()
5090 6207 {
5091 6208 return new PythonQtShell_binaryFile(); }
@@ -5103,6 +6220,11 int PythonQtWrapper_binaryFile::closeFi
5103 6220 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_closeFile());
5104 6221 }
5105 6222
6223 codeFragment* PythonQtWrapper_binaryFile::getFragment(binaryFile* theWrappedObject, int index)
6224 {
6225 return ( theWrappedObject->getFragment(index));
6226 }
6227
5106 6228 int PythonQtWrapper_binaryFile::getFragmentAddress(binaryFile* theWrappedObject, int index)
5107 6229 {
5108 6230 return ( theWrappedObject->getFragmentAddress(index));
@@ -5148,918 +6270,75 bool PythonQtWrapper_binaryFile::openFi
5148 6270 return ( theWrappedObject->openFiles(Files));
5149 6271 }
5150 6272
6273 bool PythonQtWrapper_binaryFile::static_binaryFile_toBinary(QList<codeFragment* > fragments, const QString& File)
6274 {
6275 return (binaryFile::toBinary(fragments, File));
6276 }
6277
6278 bool PythonQtWrapper_binaryFile::toBinary(binaryFile* theWrappedObject, const QString& fileName)
6279 {
6280 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_toBinary(fileName));
6281 }
6282
6283 bool PythonQtWrapper_binaryFile::toSrec(binaryFile* theWrappedObject, const QString& fileName)
6284 {
6285 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_toSrec(fileName));
6286 }
6287
5151 6288
5152 6289
5153 6290 PythonQtShell_binaryFileWidget::~PythonQtShell_binaryFileWidget() {
5154 6291 PythonQtPrivate* priv = PythonQt::priv();
5155 6292 if (priv) { priv->shellClassDeleted(this); }
5156 6293 }
5157 void PythonQtShell_binaryFileWidget::actionEvent(QActionEvent* arg__1)
5158 {
5159 if (_wrapper) {
5160 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
5161 PyErr_Clear();
5162 if (obj && !PythonQtSlotFunction_Check(obj)) {
5163 static const char* argumentList[] ={"" , "QActionEvent*"};
5164 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5165 void* args[2] = {NULL, (void*)&arg__1};
5166 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5167 if (result) { Py_DECREF(result); }
5168 Py_DECREF(obj);
5169 return;
5170 }
5171 }
5172 binaryFileWidget::actionEvent(arg__1);
5173 }
5174 void PythonQtShell_binaryFileWidget::changeEvent(QEvent* arg__1)
5175 {
5176 if (_wrapper) {
5177 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
5178 PyErr_Clear();
5179 if (obj && !PythonQtSlotFunction_Check(obj)) {
5180 static const char* argumentList[] ={"" , "QEvent*"};
5181 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5182 void* args[2] = {NULL, (void*)&arg__1};
5183 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5184 if (result) { Py_DECREF(result); }
5185 Py_DECREF(obj);
5186 return;
5187 }
5188 }
5189 binaryFileWidget::changeEvent(arg__1);
5190 }
5191 void PythonQtShell_binaryFileWidget::childEvent(QChildEvent* arg__1)
5192 {
5193 if (_wrapper) {
5194 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
5195 PyErr_Clear();
5196 if (obj && !PythonQtSlotFunction_Check(obj)) {
5197 static const char* argumentList[] ={"" , "QChildEvent*"};
5198 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5199 void* args[2] = {NULL, (void*)&arg__1};
5200 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5201 if (result) { Py_DECREF(result); }
5202 Py_DECREF(obj);
5203 return;
5204 }
5205 }
5206 binaryFileWidget::childEvent(arg__1);
5207 }
5208 void PythonQtShell_binaryFileWidget::closeEvent(QCloseEvent* arg__1)
5209 {
5210 if (_wrapper) {
5211 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
5212 PyErr_Clear();
5213 if (obj && !PythonQtSlotFunction_Check(obj)) {
5214 static const char* argumentList[] ={"" , "QCloseEvent*"};
5215 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5216 void* args[2] = {NULL, (void*)&arg__1};
5217 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5218 if (result) { Py_DECREF(result); }
5219 Py_DECREF(obj);
5220 return;
5221 }
5222 }
5223 binaryFileWidget::closeEvent(arg__1);
5224 }
5225 void PythonQtShell_binaryFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
5226 {
5227 if (_wrapper) {
5228 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
5229 PyErr_Clear();
5230 if (obj && !PythonQtSlotFunction_Check(obj)) {
5231 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
5232 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5233 void* args[2] = {NULL, (void*)&arg__1};
5234 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5235 if (result) { Py_DECREF(result); }
5236 Py_DECREF(obj);
5237 return;
5238 }
5239 }
5240 binaryFileWidget::contextMenuEvent(arg__1);
5241 }
5242 void PythonQtShell_binaryFileWidget::customEvent(QEvent* arg__1)
5243 {
5244 if (_wrapper) {
5245 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
5246 PyErr_Clear();
5247 if (obj && !PythonQtSlotFunction_Check(obj)) {
5248 static const char* argumentList[] ={"" , "QEvent*"};
5249 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5250 void* args[2] = {NULL, (void*)&arg__1};
5251 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5252 if (result) { Py_DECREF(result); }
5253 Py_DECREF(obj);
5254 return;
5255 }
5256 }
5257 binaryFileWidget::customEvent(arg__1);
5258 }
5259 int PythonQtShell_binaryFileWidget::devType() const
5260 {
5261 if (_wrapper) {
5262 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
5263 PyErr_Clear();
5264 if (obj && !PythonQtSlotFunction_Check(obj)) {
5265 static const char* argumentList[] ={"int"};
6294 void PythonQtShell_binaryFileWidget::reloadFile()
6295 {
6296 if (_wrapper) {
6297 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
6298 PyErr_Clear();
6299 if (obj && !PythonQtSlotFunction_Check(obj)) {
6300 static const char* argumentList[] ={""};
5266 6301 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5267 int returnValue;
5268 void* args[1] = {NULL};
5269 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5270 if (result) {
5271 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5272 if (args[0]!=&returnValue) {
5273 if (args[0]==NULL) {
5274 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
5275 } else {
5276 returnValue = *((int*)args[0]);
5277 }
5278 }
5279 }
5280 if (result) { Py_DECREF(result); }
5281 Py_DECREF(obj);
5282 return returnValue;
5283 }
5284 }
5285 return binaryFileWidget::devType();
5286 }
5287 void PythonQtShell_binaryFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
5288 {
5289 if (_wrapper) {
5290 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
5291 PyErr_Clear();
5292 if (obj && !PythonQtSlotFunction_Check(obj)) {
5293 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
5294 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5295 void* args[2] = {NULL, (void*)&arg__1};
5296 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5297 if (result) { Py_DECREF(result); }
5298 Py_DECREF(obj);
5299 return;
5300 }
5301 }
5302 binaryFileWidget::dragEnterEvent(arg__1);
5303 }
5304 void PythonQtShell_binaryFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
5305 {
5306 if (_wrapper) {
5307 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
5308 PyErr_Clear();
5309 if (obj && !PythonQtSlotFunction_Check(obj)) {
5310 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
5311 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5312 void* args[2] = {NULL, (void*)&arg__1};
5313 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5314 if (result) { Py_DECREF(result); }
5315 Py_DECREF(obj);
5316 return;
5317 }
5318 }
5319 binaryFileWidget::dragLeaveEvent(arg__1);
5320 }
5321 void PythonQtShell_binaryFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
5322 {
5323 if (_wrapper) {
5324 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
5325 PyErr_Clear();
5326 if (obj && !PythonQtSlotFunction_Check(obj)) {
5327 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
5328 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5329 void* args[2] = {NULL, (void*)&arg__1};
5330 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5331 if (result) { Py_DECREF(result); }
5332 Py_DECREF(obj);
5333 return;
5334 }
5335 }
5336 binaryFileWidget::dragMoveEvent(arg__1);
5337 }
5338 void PythonQtShell_binaryFileWidget::dropEvent(QDropEvent* arg__1)
5339 {
5340 if (_wrapper) {
5341 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
5342 PyErr_Clear();
5343 if (obj && !PythonQtSlotFunction_Check(obj)) {
5344 static const char* argumentList[] ={"" , "QDropEvent*"};
5345 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5346 void* args[2] = {NULL, (void*)&arg__1};
5347 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5348 if (result) { Py_DECREF(result); }
5349 Py_DECREF(obj);
5350 return;
5351 }
5352 }
5353 binaryFileWidget::dropEvent(arg__1);
5354 }
5355 void PythonQtShell_binaryFileWidget::enterEvent(QEvent* arg__1)
5356 {
5357 if (_wrapper) {
5358 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
5359 PyErr_Clear();
5360 if (obj && !PythonQtSlotFunction_Check(obj)) {
5361 static const char* argumentList[] ={"" , "QEvent*"};
5362 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5363 void* args[2] = {NULL, (void*)&arg__1};
5364 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5365 if (result) { Py_DECREF(result); }
5366 Py_DECREF(obj);
5367 return;
5368 }
5369 }
5370 binaryFileWidget::enterEvent(arg__1);
5371 }
5372 bool PythonQtShell_binaryFileWidget::event(QEvent* arg__1)
5373 {
5374 if (_wrapper) {
5375 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
5376 PyErr_Clear();
5377 if (obj && !PythonQtSlotFunction_Check(obj)) {
5378 static const char* argumentList[] ={"bool" , "QEvent*"};
5379 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5380 bool returnValue;
5381 void* args[2] = {NULL, (void*)&arg__1};
5382 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5383 if (result) {
5384 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5385 if (args[0]!=&returnValue) {
5386 if (args[0]==NULL) {
5387 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
5388 } else {
5389 returnValue = *((bool*)args[0]);
5390 }
5391 }
5392 }
5393 if (result) { Py_DECREF(result); }
5394 Py_DECREF(obj);
5395 return returnValue;
5396 }
5397 }
5398 return binaryFileWidget::event(arg__1);
5399 }
5400 bool PythonQtShell_binaryFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
5401 {
5402 if (_wrapper) {
5403 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
5404 PyErr_Clear();
5405 if (obj && !PythonQtSlotFunction_Check(obj)) {
5406 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5407 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5408 bool returnValue;
5409 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
5410 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5411 if (result) {
5412 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5413 if (args[0]!=&returnValue) {
5414 if (args[0]==NULL) {
5415 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
5416 } else {
5417 returnValue = *((bool*)args[0]);
5418 }
5419 }
5420 }
5421 if (result) { Py_DECREF(result); }
5422 Py_DECREF(obj);
5423 return returnValue;
5424 }
5425 }
5426 return binaryFileWidget::eventFilter(arg__1, arg__2);
5427 }
5428 void PythonQtShell_binaryFileWidget::focusInEvent(QFocusEvent* arg__1)
5429 {
5430 if (_wrapper) {
5431 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
5432 PyErr_Clear();
5433 if (obj && !PythonQtSlotFunction_Check(obj)) {
5434 static const char* argumentList[] ={"" , "QFocusEvent*"};
5435 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5436 void* args[2] = {NULL, (void*)&arg__1};
5437 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5438 if (result) { Py_DECREF(result); }
5439 Py_DECREF(obj);
5440 return;
5441 }
5442 }
5443 binaryFileWidget::focusInEvent(arg__1);
5444 }
5445 bool PythonQtShell_binaryFileWidget::focusNextPrevChild(bool next)
5446 {
5447 if (_wrapper) {
5448 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
5449 PyErr_Clear();
5450 if (obj && !PythonQtSlotFunction_Check(obj)) {
5451 static const char* argumentList[] ={"bool" , "bool"};
5452 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5453 bool returnValue;
5454 void* args[2] = {NULL, (void*)&next};
5455 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5456 if (result) {
5457 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5458 if (args[0]!=&returnValue) {
5459 if (args[0]==NULL) {
5460 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
5461 } else {
5462 returnValue = *((bool*)args[0]);
5463 }
5464 }
5465 }
5466 if (result) { Py_DECREF(result); }
5467 Py_DECREF(obj);
5468 return returnValue;
5469 }
5470 }
5471 return binaryFileWidget::focusNextPrevChild(next);
5472 }
5473 void PythonQtShell_binaryFileWidget::focusOutEvent(QFocusEvent* arg__1)
5474 {
5475 if (_wrapper) {
5476 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
5477 PyErr_Clear();
5478 if (obj && !PythonQtSlotFunction_Check(obj)) {
5479 static const char* argumentList[] ={"" , "QFocusEvent*"};
5480 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5481 void* args[2] = {NULL, (void*)&arg__1};
5482 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5483 if (result) { Py_DECREF(result); }
5484 Py_DECREF(obj);
5485 return;
5486 }
5487 }
5488 binaryFileWidget::focusOutEvent(arg__1);
5489 }
5490 bool PythonQtShell_binaryFileWidget::hasHeightForWidth() const
5491 {
5492 if (_wrapper) {
5493 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
5494 PyErr_Clear();
5495 if (obj && !PythonQtSlotFunction_Check(obj)) {
5496 static const char* argumentList[] ={"bool"};
5497 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5498 bool returnValue;
5499 6302 void* args[1] = {NULL};
5500 6303 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5501 if (result) {
5502 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5503 if (args[0]!=&returnValue) {
5504 if (args[0]==NULL) {
5505 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
5506 } else {
5507 returnValue = *((bool*)args[0]);
5508 }
5509 }
5510 }
5511 if (result) { Py_DECREF(result); }
5512 Py_DECREF(obj);
5513 return returnValue;
5514 }
5515 }
5516 return binaryFileWidget::hasHeightForWidth();
5517 }
5518 int PythonQtShell_binaryFileWidget::heightForWidth(int arg__1) const
5519 {
5520 if (_wrapper) {
5521 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
5522 PyErr_Clear();
5523 if (obj && !PythonQtSlotFunction_Check(obj)) {
5524 static const char* argumentList[] ={"int" , "int"};
5525 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5526 int returnValue;
5527 void* args[2] = {NULL, (void*)&arg__1};
5528 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5529 if (result) {
5530 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5531 if (args[0]!=&returnValue) {
5532 if (args[0]==NULL) {
5533 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
5534 } else {
5535 returnValue = *((int*)args[0]);
5536 }
5537 }
5538 }
5539 if (result) { Py_DECREF(result); }
5540 Py_DECREF(obj);
5541 return returnValue;
5542 }
5543 }
5544 return binaryFileWidget::heightForWidth(arg__1);
5545 }
5546 void PythonQtShell_binaryFileWidget::hideEvent(QHideEvent* arg__1)
5547 {
5548 if (_wrapper) {
5549 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
5550 PyErr_Clear();
5551 if (obj && !PythonQtSlotFunction_Check(obj)) {
5552 static const char* argumentList[] ={"" , "QHideEvent*"};
5553 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5554 void* args[2] = {NULL, (void*)&arg__1};
5555 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5556 if (result) { Py_DECREF(result); }
5557 Py_DECREF(obj);
5558 return;
5559 }
5560 }
5561 binaryFileWidget::hideEvent(arg__1);
5562 }
5563 void PythonQtShell_binaryFileWidget::initPainter(QPainter* painter) const
5564 {
5565 if (_wrapper) {
5566 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
5567 PyErr_Clear();
5568 if (obj && !PythonQtSlotFunction_Check(obj)) {
5569 static const char* argumentList[] ={"" , "QPainter*"};
5570 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5571 void* args[2] = {NULL, (void*)&painter};
5572 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5573 if (result) { Py_DECREF(result); }
5574 Py_DECREF(obj);
5575 return;
5576 }
5577 }
5578 binaryFileWidget::initPainter(painter);
5579 }
5580 void PythonQtShell_binaryFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
5581 {
5582 if (_wrapper) {
5583 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
5584 PyErr_Clear();
5585 if (obj && !PythonQtSlotFunction_Check(obj)) {
5586 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
5587 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5588 void* args[2] = {NULL, (void*)&arg__1};
5589 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5590 if (result) { Py_DECREF(result); }
5591 Py_DECREF(obj);
5592 return;
5593 }
5594 }
5595 binaryFileWidget::inputMethodEvent(arg__1);
5596 }
5597 QVariant PythonQtShell_binaryFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
5598 {
5599 if (_wrapper) {
5600 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
5601 PyErr_Clear();
5602 if (obj && !PythonQtSlotFunction_Check(obj)) {
5603 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
5604 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5605 QVariant returnValue;
5606 void* args[2] = {NULL, (void*)&arg__1};
5607 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5608 if (result) {
5609 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5610 if (args[0]!=&returnValue) {
5611 if (args[0]==NULL) {
5612 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
5613 } else {
5614 returnValue = *((QVariant*)args[0]);
5615 }
5616 }
5617 }
5618 if (result) { Py_DECREF(result); }
5619 Py_DECREF(obj);
5620 return returnValue;
5621 }
5622 }
5623 return binaryFileWidget::inputMethodQuery(arg__1);
5624 }
5625 void PythonQtShell_binaryFileWidget::keyPressEvent(QKeyEvent* arg__1)
5626 {
5627 if (_wrapper) {
5628 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
5629 PyErr_Clear();
5630 if (obj && !PythonQtSlotFunction_Check(obj)) {
5631 static const char* argumentList[] ={"" , "QKeyEvent*"};
5632 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5633 void* args[2] = {NULL, (void*)&arg__1};
5634 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5635 if (result) { Py_DECREF(result); }
5636 Py_DECREF(obj);
5637 return;
5638 }
5639 }
5640 binaryFileWidget::keyPressEvent(arg__1);
5641 }
5642 void PythonQtShell_binaryFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
5643 {
5644 if (_wrapper) {
5645 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
5646 PyErr_Clear();
5647 if (obj && !PythonQtSlotFunction_Check(obj)) {
5648 static const char* argumentList[] ={"" , "QKeyEvent*"};
5649 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5650 void* args[2] = {NULL, (void*)&arg__1};
5651 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5652 if (result) { Py_DECREF(result); }
5653 Py_DECREF(obj);
5654 return;
5655 }
5656 }
5657 binaryFileWidget::keyReleaseEvent(arg__1);
5658 }
5659 void PythonQtShell_binaryFileWidget::leaveEvent(QEvent* arg__1)
5660 {
5661 if (_wrapper) {
5662 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
5663 PyErr_Clear();
5664 if (obj && !PythonQtSlotFunction_Check(obj)) {
5665 static const char* argumentList[] ={"" , "QEvent*"};
5666 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5667 void* args[2] = {NULL, (void*)&arg__1};
5668 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5669 if (result) { Py_DECREF(result); }
5670 Py_DECREF(obj);
5671 return;
5672 }
5673 }
5674 binaryFileWidget::leaveEvent(arg__1);
5675 }
5676 int PythonQtShell_binaryFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
5677 {
5678 if (_wrapper) {
5679 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
5680 PyErr_Clear();
5681 if (obj && !PythonQtSlotFunction_Check(obj)) {
5682 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
5683 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5684 int returnValue;
5685 void* args[2] = {NULL, (void*)&arg__1};
5686 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5687 if (result) {
5688 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5689 if (args[0]!=&returnValue) {
5690 if (args[0]==NULL) {
5691 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
5692 } else {
5693 returnValue = *((int*)args[0]);
5694 }
5695 }
5696 }
5697 if (result) { Py_DECREF(result); }
5698 Py_DECREF(obj);
5699 return returnValue;
5700 }
5701 }
5702 return binaryFileWidget::metric(arg__1);
5703 }
5704 QSize PythonQtShell_binaryFileWidget::minimumSizeHint() const
5705 {
5706 if (_wrapper) {
5707 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
5708 PyErr_Clear();
5709 if (obj && !PythonQtSlotFunction_Check(obj)) {
5710 static const char* argumentList[] ={"QSize"};
5711 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5712 QSize returnValue;
5713 void* args[1] = {NULL};
5714 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5715 if (result) {
5716 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5717 if (args[0]!=&returnValue) {
5718 if (args[0]==NULL) {
5719 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
5720 } else {
5721 returnValue = *((QSize*)args[0]);
5722 }
5723 }
5724 }
5725 if (result) { Py_DECREF(result); }
5726 Py_DECREF(obj);
5727 return returnValue;
5728 }
5729 }
5730 return binaryFileWidget::minimumSizeHint();
5731 }
5732 void PythonQtShell_binaryFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
5733 {
5734 if (_wrapper) {
5735 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
5736 PyErr_Clear();
5737 if (obj && !PythonQtSlotFunction_Check(obj)) {
5738 static const char* argumentList[] ={"" , "QMouseEvent*"};
5739 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5740 void* args[2] = {NULL, (void*)&arg__1};
5741 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5742 if (result) { Py_DECREF(result); }
5743 Py_DECREF(obj);
5744 return;
5745 }
5746 }
5747 binaryFileWidget::mouseDoubleClickEvent(arg__1);
5748 }
5749 void PythonQtShell_binaryFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
5750 {
5751 if (_wrapper) {
5752 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
5753 PyErr_Clear();
5754 if (obj && !PythonQtSlotFunction_Check(obj)) {
5755 static const char* argumentList[] ={"" , "QMouseEvent*"};
5756 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5757 void* args[2] = {NULL, (void*)&arg__1};
5758 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5759 if (result) { Py_DECREF(result); }
5760 Py_DECREF(obj);
5761 return;
5762 }
5763 }
5764 binaryFileWidget::mouseMoveEvent(arg__1);
5765 }
5766 void PythonQtShell_binaryFileWidget::mousePressEvent(QMouseEvent* arg__1)
5767 {
5768 if (_wrapper) {
5769 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
5770 PyErr_Clear();
5771 if (obj && !PythonQtSlotFunction_Check(obj)) {
5772 static const char* argumentList[] ={"" , "QMouseEvent*"};
5773 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5774 void* args[2] = {NULL, (void*)&arg__1};
5775 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5776 if (result) { Py_DECREF(result); }
5777 Py_DECREF(obj);
5778 return;
5779 }
5780 }
5781 binaryFileWidget::mousePressEvent(arg__1);
5782 }
5783 void PythonQtShell_binaryFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
5784 {
5785 if (_wrapper) {
5786 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
5787 PyErr_Clear();
5788 if (obj && !PythonQtSlotFunction_Check(obj)) {
5789 static const char* argumentList[] ={"" , "QMouseEvent*"};
5790 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5791 void* args[2] = {NULL, (void*)&arg__1};
5792 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5793 if (result) { Py_DECREF(result); }
5794 Py_DECREF(obj);
5795 return;
5796 }
5797 }
5798 binaryFileWidget::mouseReleaseEvent(arg__1);
5799 }
5800 void PythonQtShell_binaryFileWidget::moveEvent(QMoveEvent* arg__1)
5801 {
5802 if (_wrapper) {
5803 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
5804 PyErr_Clear();
5805 if (obj && !PythonQtSlotFunction_Check(obj)) {
5806 static const char* argumentList[] ={"" , "QMoveEvent*"};
5807 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5808 void* args[2] = {NULL, (void*)&arg__1};
5809 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5810 if (result) { Py_DECREF(result); }
5811 Py_DECREF(obj);
5812 return;
5813 }
5814 }
5815 binaryFileWidget::moveEvent(arg__1);
5816 }
5817 bool PythonQtShell_binaryFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result)
5818 {
5819 if (_wrapper) {
5820 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
5821 PyErr_Clear();
5822 if (obj && !PythonQtSlotFunction_Check(obj)) {
5823 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
5824 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
5825 bool returnValue;
5826 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
5827 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5828 if (result) {
5829 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5830 if (args[0]!=&returnValue) {
5831 if (args[0]==NULL) {
5832 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
5833 } else {
5834 returnValue = *((bool*)args[0]);
5835 }
5836 }
5837 }
5838 if (result) { Py_DECREF(result); }
5839 Py_DECREF(obj);
5840 return returnValue;
5841 }
5842 }
5843 return binaryFileWidget::nativeEvent(eventType, message, result);
5844 }
5845 QPaintEngine* PythonQtShell_binaryFileWidget::paintEngine() const
5846 {
5847 if (_wrapper) {
5848 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
5849 PyErr_Clear();
5850 if (obj && !PythonQtSlotFunction_Check(obj)) {
5851 static const char* argumentList[] ={"QPaintEngine*"};
5852 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5853 QPaintEngine* returnValue;
5854 void* args[1] = {NULL};
5855 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5856 if (result) {
5857 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5858 if (args[0]!=&returnValue) {
5859 if (args[0]==NULL) {
5860 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
5861 } else {
5862 returnValue = *((QPaintEngine**)args[0]);
5863 }
5864 }
5865 }
5866 if (result) { Py_DECREF(result); }
5867 Py_DECREF(obj);
5868 return returnValue;
5869 }
5870 }
5871 return binaryFileWidget::paintEngine();
5872 }
5873 void PythonQtShell_binaryFileWidget::paintEvent(QPaintEvent* arg__1)
5874 {
5875 if (_wrapper) {
5876 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
5877 PyErr_Clear();
5878 if (obj && !PythonQtSlotFunction_Check(obj)) {
5879 static const char* argumentList[] ={"" , "QPaintEvent*"};
5880 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5881 void* args[2] = {NULL, (void*)&arg__1};
5882 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5883 if (result) { Py_DECREF(result); }
5884 Py_DECREF(obj);
5885 return;
5886 }
5887 }
5888 binaryFileWidget::paintEvent(arg__1);
5889 }
5890 QPaintDevice* PythonQtShell_binaryFileWidget::redirected(QPoint* offset) const
5891 {
5892 if (_wrapper) {
5893 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
5894 PyErr_Clear();
5895 if (obj && !PythonQtSlotFunction_Check(obj)) {
5896 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
5897 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5898 QPaintDevice* returnValue;
5899 void* args[2] = {NULL, (void*)&offset};
5900 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5901 if (result) {
5902 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5903 if (args[0]!=&returnValue) {
5904 if (args[0]==NULL) {
5905 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
5906 } else {
5907 returnValue = *((QPaintDevice**)args[0]);
5908 }
5909 }
5910 }
5911 if (result) { Py_DECREF(result); }
5912 Py_DECREF(obj);
5913 return returnValue;
5914 }
5915 }
5916 return binaryFileWidget::redirected(offset);
5917 }
5918 void PythonQtShell_binaryFileWidget::resizeEvent(QResizeEvent* arg__1)
5919 {
5920 if (_wrapper) {
5921 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
5922 PyErr_Clear();
5923 if (obj && !PythonQtSlotFunction_Check(obj)) {
5924 static const char* argumentList[] ={"" , "QResizeEvent*"};
5925 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5926 void* args[2] = {NULL, (void*)&arg__1};
5927 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5928 if (result) { Py_DECREF(result); }
5929 Py_DECREF(obj);
5930 return;
5931 }
5932 }
5933 binaryFileWidget::resizeEvent(arg__1);
5934 }
5935 QPainter* PythonQtShell_binaryFileWidget::sharedPainter() const
5936 {
5937 if (_wrapper) {
5938 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
5939 PyErr_Clear();
5940 if (obj && !PythonQtSlotFunction_Check(obj)) {
5941 static const char* argumentList[] ={"QPainter*"};
5942 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5943 QPainter* returnValue;
5944 void* args[1] = {NULL};
5945 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5946 if (result) {
5947 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5948 if (args[0]!=&returnValue) {
5949 if (args[0]==NULL) {
5950 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
5951 } else {
5952 returnValue = *((QPainter**)args[0]);
5953 }
5954 }
5955 }
5956 if (result) { Py_DECREF(result); }
5957 Py_DECREF(obj);
5958 return returnValue;
5959 }
5960 }
5961 return binaryFileWidget::sharedPainter();
5962 }
5963 void PythonQtShell_binaryFileWidget::showEvent(QShowEvent* arg__1)
5964 {
5965 if (_wrapper) {
5966 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
5967 PyErr_Clear();
5968 if (obj && !PythonQtSlotFunction_Check(obj)) {
5969 static const char* argumentList[] ={"" , "QShowEvent*"};
5970 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5971 void* args[2] = {NULL, (void*)&arg__1};
5972 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5973 if (result) { Py_DECREF(result); }
5974 Py_DECREF(obj);
5975 return;
5976 }
5977 }
5978 binaryFileWidget::showEvent(arg__1);
5979 }
5980 QSize PythonQtShell_binaryFileWidget::sizeHint() const
5981 {
5982 if (_wrapper) {
5983 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
5984 PyErr_Clear();
5985 if (obj && !PythonQtSlotFunction_Check(obj)) {
5986 static const char* argumentList[] ={"QSize"};
5987 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5988 QSize returnValue;
5989 void* args[1] = {NULL};
5990 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5991 if (result) {
5992 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5993 if (args[0]!=&returnValue) {
5994 if (args[0]==NULL) {
5995 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
5996 } else {
5997 returnValue = *((QSize*)args[0]);
5998 }
5999 }
6000 }
6001 if (result) { Py_DECREF(result); }
6002 Py_DECREF(obj);
6003 return returnValue;
6004 }
6005 }
6006 return binaryFileWidget::sizeHint();
6007 }
6008 void PythonQtShell_binaryFileWidget::tabletEvent(QTabletEvent* arg__1)
6009 {
6010 if (_wrapper) {
6011 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
6012 PyErr_Clear();
6013 if (obj && !PythonQtSlotFunction_Check(obj)) {
6014 static const char* argumentList[] ={"" , "QTabletEvent*"};
6015 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6016 void* args[2] = {NULL, (void*)&arg__1};
6017 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6018 if (result) { Py_DECREF(result); }
6019 Py_DECREF(obj);
6020 return;
6021 }
6022 }
6023 binaryFileWidget::tabletEvent(arg__1);
6024 }
6025 void PythonQtShell_binaryFileWidget::timerEvent(QTimerEvent* arg__1)
6026 {
6027 if (_wrapper) {
6028 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
6029 PyErr_Clear();
6030 if (obj && !PythonQtSlotFunction_Check(obj)) {
6031 static const char* argumentList[] ={"" , "QTimerEvent*"};
6032 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6033 void* args[2] = {NULL, (void*)&arg__1};
6034 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6035 if (result) { Py_DECREF(result); }
6036 Py_DECREF(obj);
6037 return;
6038 }
6039 }
6040 binaryFileWidget::timerEvent(arg__1);
6041 }
6042 void PythonQtShell_binaryFileWidget::wheelEvent(QWheelEvent* arg__1)
6043 {
6044 if (_wrapper) {
6045 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
6046 PyErr_Clear();
6047 if (obj && !PythonQtSlotFunction_Check(obj)) {
6048 static const char* argumentList[] ={"" , "QWheelEvent*"};
6049 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6050 void* args[2] = {NULL, (void*)&arg__1};
6051 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6052 if (result) { Py_DECREF(result); }
6053 Py_DECREF(obj);
6054 return;
6055 }
6056 }
6057 binaryFileWidget::wheelEvent(arg__1);
6304 if (result) { Py_DECREF(result); }
6305 Py_DECREF(obj);
6306 return;
6307 }
6308 }
6309 binaryFileWidget::reloadFile();
6310 }
6311 void PythonQtShell_binaryFileWidget::setFile(abstractBinFile* file)
6312 {
6313 if (_wrapper) {
6314 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
6315 PyErr_Clear();
6316 if (obj && !PythonQtSlotFunction_Check(obj)) {
6317 static const char* argumentList[] ={"" , "abstractBinFile*"};
6318 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6319 void* args[2] = {NULL, (void*)&file};
6320 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6321 if (result) { Py_DECREF(result); }
6322 Py_DECREF(obj);
6323 return;
6324 }
6325 }
6326 binaryFileWidget::setFile(file);
6058 6327 }
6059 6328 binaryFileWidget* PythonQtWrapper_binaryFileWidget::new_binaryFileWidget(QWidget* parent)
6060 6329 {
6061 6330 return new PythonQtShell_binaryFileWidget(parent); }
6062 6331
6332 void PythonQtWrapper_binaryFileWidget::reloadFile(binaryFileWidget* theWrappedObject)
6333 {
6334 ( ((PythonQtPublicPromoter_binaryFileWidget*)theWrappedObject)->promoted_reloadFile());
6335 }
6336
6337 void PythonQtWrapper_binaryFileWidget::setFile(binaryFileWidget* theWrappedObject, abstractBinFile* file)
6338 {
6339 ( ((PythonQtPublicPromoter_binaryFileWidget*)theWrappedObject)->promoted_setFile(file));
6340 }
6341
6063 6342
6064 6343
6065 6344 PythonQtShell_codeFragment::~PythonQtShell_codeFragment() {
@@ -6080,912 +6359,49 PythonQtShell_elfFileWidget::~PythonQtSh
6080 6359 PythonQtPrivate* priv = PythonQt::priv();
6081 6360 if (priv) { priv->shellClassDeleted(this); }
6082 6361 }
6083 void PythonQtShell_elfFileWidget::actionEvent(QActionEvent* arg__1)
6084 {
6085 if (_wrapper) {
6086 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
6087 PyErr_Clear();
6088 if (obj && !PythonQtSlotFunction_Check(obj)) {
6089 static const char* argumentList[] ={"" , "QActionEvent*"};
6090 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6091 void* args[2] = {NULL, (void*)&arg__1};
6092 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6093 if (result) { Py_DECREF(result); }
6094 Py_DECREF(obj);
6095 return;
6096 }
6097 }
6098 elfFileWidget::actionEvent(arg__1);
6099 }
6100 void PythonQtShell_elfFileWidget::changeEvent(QEvent* arg__1)
6101 {
6102 if (_wrapper) {
6103 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
6104 PyErr_Clear();
6105 if (obj && !PythonQtSlotFunction_Check(obj)) {
6106 static const char* argumentList[] ={"" , "QEvent*"};
6107 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6108 void* args[2] = {NULL, (void*)&arg__1};
6109 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6110 if (result) { Py_DECREF(result); }
6111 Py_DECREF(obj);
6112 return;
6113 }
6114 }
6115 elfFileWidget::changeEvent(arg__1);
6116 }
6117 void PythonQtShell_elfFileWidget::childEvent(QChildEvent* arg__1)
6118 {
6119 if (_wrapper) {
6120 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
6121 PyErr_Clear();
6122 if (obj && !PythonQtSlotFunction_Check(obj)) {
6123 static const char* argumentList[] ={"" , "QChildEvent*"};
6124 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6125 void* args[2] = {NULL, (void*)&arg__1};
6126 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6127 if (result) { Py_DECREF(result); }
6128 Py_DECREF(obj);
6129 return;
6130 }
6131 }
6132 elfFileWidget::childEvent(arg__1);
6133 }
6134 void PythonQtShell_elfFileWidget::closeEvent(QCloseEvent* arg__1)
6135 {
6136 if (_wrapper) {
6137 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
6138 PyErr_Clear();
6139 if (obj && !PythonQtSlotFunction_Check(obj)) {
6140 static const char* argumentList[] ={"" , "QCloseEvent*"};
6141 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6142 void* args[2] = {NULL, (void*)&arg__1};
6143 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6144 if (result) { Py_DECREF(result); }
6145 Py_DECREF(obj);
6146 return;
6147 }
6148 }
6149 elfFileWidget::closeEvent(arg__1);
6150 }
6151 void PythonQtShell_elfFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
6152 {
6153 if (_wrapper) {
6154 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
6155 PyErr_Clear();
6156 if (obj && !PythonQtSlotFunction_Check(obj)) {
6157 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
6158 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6159 void* args[2] = {NULL, (void*)&arg__1};
6160 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6161 if (result) { Py_DECREF(result); }
6162 Py_DECREF(obj);
6163 return;
6164 }
6165 }
6166 elfFileWidget::contextMenuEvent(arg__1);
6167 }
6168 void PythonQtShell_elfFileWidget::customEvent(QEvent* arg__1)
6169 {
6170 if (_wrapper) {
6171 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
6172 PyErr_Clear();
6173 if (obj && !PythonQtSlotFunction_Check(obj)) {
6174 static const char* argumentList[] ={"" , "QEvent*"};
6175 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6176 void* args[2] = {NULL, (void*)&arg__1};
6177 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6178 if (result) { Py_DECREF(result); }
6179 Py_DECREF(obj);
6180 return;
6181 }
6182 }
6183 elfFileWidget::customEvent(arg__1);
6184 }
6185 int PythonQtShell_elfFileWidget::devType() const
6186 {
6187 if (_wrapper) {
6188 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
6189 PyErr_Clear();
6190 if (obj && !PythonQtSlotFunction_Check(obj)) {
6191 static const char* argumentList[] ={"int"};
6362 void PythonQtShell_elfFileWidget::reloadFile()
6363 {
6364 if (_wrapper) {
6365 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
6366 PyErr_Clear();
6367 if (obj && !PythonQtSlotFunction_Check(obj)) {
6368 static const char* argumentList[] ={""};
6192 6369 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6193 int returnValue;
6194 void* args[1] = {NULL};
6195 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6196 if (result) {
6197 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6198 if (args[0]!=&returnValue) {
6199 if (args[0]==NULL) {
6200 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
6201 } else {
6202 returnValue = *((int*)args[0]);
6203 }
6204 }
6205 }
6206 if (result) { Py_DECREF(result); }
6207 Py_DECREF(obj);
6208 return returnValue;
6209 }
6210 }
6211 return elfFileWidget::devType();
6212 }
6213 void PythonQtShell_elfFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
6214 {
6215 if (_wrapper) {
6216 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
6217 PyErr_Clear();
6218 if (obj && !PythonQtSlotFunction_Check(obj)) {
6219 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
6220 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6221 void* args[2] = {NULL, (void*)&arg__1};
6222 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6223 if (result) { Py_DECREF(result); }
6224 Py_DECREF(obj);
6225 return;
6226 }
6227 }
6228 elfFileWidget::dragEnterEvent(arg__1);
6229 }
6230 void PythonQtShell_elfFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
6231 {
6232 if (_wrapper) {
6233 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
6234 PyErr_Clear();
6235 if (obj && !PythonQtSlotFunction_Check(obj)) {
6236 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
6237 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6238 void* args[2] = {NULL, (void*)&arg__1};
6239 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6240 if (result) { Py_DECREF(result); }
6241 Py_DECREF(obj);
6242 return;
6243 }
6244 }
6245 elfFileWidget::dragLeaveEvent(arg__1);
6246 }
6247 void PythonQtShell_elfFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
6248 {
6249 if (_wrapper) {
6250 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
6251 PyErr_Clear();
6252 if (obj && !PythonQtSlotFunction_Check(obj)) {
6253 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
6254 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6255 void* args[2] = {NULL, (void*)&arg__1};
6256 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6257 if (result) { Py_DECREF(result); }
6258 Py_DECREF(obj);
6259 return;
6260 }
6261 }
6262 elfFileWidget::dragMoveEvent(arg__1);
6263 }
6264 void PythonQtShell_elfFileWidget::dropEvent(QDropEvent* arg__1)
6265 {
6266 if (_wrapper) {
6267 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
6268 PyErr_Clear();
6269 if (obj && !PythonQtSlotFunction_Check(obj)) {
6270 static const char* argumentList[] ={"" , "QDropEvent*"};
6271 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6272 void* args[2] = {NULL, (void*)&arg__1};
6273 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6274 if (result) { Py_DECREF(result); }
6275 Py_DECREF(obj);
6276 return;
6277 }
6278 }
6279 elfFileWidget::dropEvent(arg__1);
6280 }
6281 void PythonQtShell_elfFileWidget::enterEvent(QEvent* arg__1)
6282 {
6283 if (_wrapper) {
6284 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
6285 PyErr_Clear();
6286 if (obj && !PythonQtSlotFunction_Check(obj)) {
6287 static const char* argumentList[] ={"" , "QEvent*"};
6288 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6289 void* args[2] = {NULL, (void*)&arg__1};
6290 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6291 if (result) { Py_DECREF(result); }
6292 Py_DECREF(obj);
6293 return;
6294 }
6295 }
6296 elfFileWidget::enterEvent(arg__1);
6297 }
6298 bool PythonQtShell_elfFileWidget::event(QEvent* arg__1)
6299 {
6300 if (_wrapper) {
6301 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
6302 PyErr_Clear();
6303 if (obj && !PythonQtSlotFunction_Check(obj)) {
6304 static const char* argumentList[] ={"bool" , "QEvent*"};
6305 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6306 bool returnValue;
6307 void* args[2] = {NULL, (void*)&arg__1};
6308 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6309 if (result) {
6310 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6311 if (args[0]!=&returnValue) {
6312 if (args[0]==NULL) {
6313 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
6314 } else {
6315 returnValue = *((bool*)args[0]);
6316 }
6317 }
6318 }
6319 if (result) { Py_DECREF(result); }
6320 Py_DECREF(obj);
6321 return returnValue;
6322 }
6323 }
6324 return elfFileWidget::event(arg__1);
6325 }
6326 bool PythonQtShell_elfFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
6327 {
6328 if (_wrapper) {
6329 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
6330 PyErr_Clear();
6331 if (obj && !PythonQtSlotFunction_Check(obj)) {
6332 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
6333 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
6334 bool returnValue;
6335 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
6336 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6337 if (result) {
6338 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6339 if (args[0]!=&returnValue) {
6340 if (args[0]==NULL) {
6341 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
6342 } else {
6343 returnValue = *((bool*)args[0]);
6344 }
6345 }
6346 }
6347 if (result) { Py_DECREF(result); }
6348 Py_DECREF(obj);
6349 return returnValue;
6350 }
6351 }
6352 return elfFileWidget::eventFilter(arg__1, arg__2);
6353 }
6354 void PythonQtShell_elfFileWidget::focusInEvent(QFocusEvent* arg__1)
6355 {
6356 if (_wrapper) {
6357 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
6358 PyErr_Clear();
6359 if (obj && !PythonQtSlotFunction_Check(obj)) {
6360 static const char* argumentList[] ={"" , "QFocusEvent*"};
6361 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6362 void* args[2] = {NULL, (void*)&arg__1};
6363 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6364 if (result) { Py_DECREF(result); }
6365 Py_DECREF(obj);
6366 return;
6367 }
6368 }
6369 elfFileWidget::focusInEvent(arg__1);
6370 }
6371 bool PythonQtShell_elfFileWidget::focusNextPrevChild(bool next)
6372 {
6373 if (_wrapper) {
6374 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
6375 PyErr_Clear();
6376 if (obj && !PythonQtSlotFunction_Check(obj)) {
6377 static const char* argumentList[] ={"bool" , "bool"};
6378 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6379 bool returnValue;
6380 void* args[2] = {NULL, (void*)&next};
6381 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6382 if (result) {
6383 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6384 if (args[0]!=&returnValue) {
6385 if (args[0]==NULL) {
6386 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
6387 } else {
6388 returnValue = *((bool*)args[0]);
6389 }
6390 }
6391 }
6392 if (result) { Py_DECREF(result); }
6393 Py_DECREF(obj);
6394 return returnValue;
6395 }
6396 }
6397 return elfFileWidget::focusNextPrevChild(next);
6398 }
6399 void PythonQtShell_elfFileWidget::focusOutEvent(QFocusEvent* arg__1)
6400 {
6401 if (_wrapper) {
6402 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
6403 PyErr_Clear();
6404 if (obj && !PythonQtSlotFunction_Check(obj)) {
6405 static const char* argumentList[] ={"" , "QFocusEvent*"};
6406 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6407 void* args[2] = {NULL, (void*)&arg__1};
6408 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6409 if (result) { Py_DECREF(result); }
6410 Py_DECREF(obj);
6411 return;
6412 }
6413 }
6414 elfFileWidget::focusOutEvent(arg__1);
6415 }
6416 bool PythonQtShell_elfFileWidget::hasHeightForWidth() const
6417 {
6418 if (_wrapper) {
6419 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
6420 PyErr_Clear();
6421 if (obj && !PythonQtSlotFunction_Check(obj)) {
6422 static const char* argumentList[] ={"bool"};
6423 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6424 bool returnValue;
6425 6370 void* args[1] = {NULL};
6426 6371 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6427 if (result) {
6428 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6429 if (args[0]!=&returnValue) {
6430 if (args[0]==NULL) {
6431 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
6432 } else {
6433 returnValue = *((bool*)args[0]);
6434 }
6435 }
6436 }
6437 if (result) { Py_DECREF(result); }
6438 Py_DECREF(obj);
6439 return returnValue;
6440 }
6441 }
6442 return elfFileWidget::hasHeightForWidth();
6443 }
6444 int PythonQtShell_elfFileWidget::heightForWidth(int arg__1) const
6445 {
6446 if (_wrapper) {
6447 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
6448 PyErr_Clear();
6449 if (obj && !PythonQtSlotFunction_Check(obj)) {
6450 static const char* argumentList[] ={"int" , "int"};
6451 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6452 int returnValue;
6453 void* args[2] = {NULL, (void*)&arg__1};
6454 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6455 if (result) {
6456 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6457 if (args[0]!=&returnValue) {
6458 if (args[0]==NULL) {
6459 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
6460 } else {
6461 returnValue = *((int*)args[0]);
6462 }
6463 }
6464 }
6465 if (result) { Py_DECREF(result); }
6466 Py_DECREF(obj);
6467 return returnValue;
6468 }
6469 }
6470 return elfFileWidget::heightForWidth(arg__1);
6471 }
6472 void PythonQtShell_elfFileWidget::hideEvent(QHideEvent* arg__1)
6473 {
6474 if (_wrapper) {
6475 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
6476 PyErr_Clear();
6477 if (obj && !PythonQtSlotFunction_Check(obj)) {
6478 static const char* argumentList[] ={"" , "QHideEvent*"};
6479 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6480 void* args[2] = {NULL, (void*)&arg__1};
6481 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6482 if (result) { Py_DECREF(result); }
6483 Py_DECREF(obj);
6484 return;
6485 }
6486 }
6487 elfFileWidget::hideEvent(arg__1);
6488 }
6489 void PythonQtShell_elfFileWidget::initPainter(QPainter* painter) const
6490 {
6491 if (_wrapper) {
6492 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
6493 PyErr_Clear();
6494 if (obj && !PythonQtSlotFunction_Check(obj)) {
6495 static const char* argumentList[] ={"" , "QPainter*"};
6496 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6497 void* args[2] = {NULL, (void*)&painter};
6498 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6499 if (result) { Py_DECREF(result); }
6500 Py_DECREF(obj);
6501 return;
6502 }
6503 }
6504 elfFileWidget::initPainter(painter);
6505 }
6506 void PythonQtShell_elfFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
6507 {
6508 if (_wrapper) {
6509 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
6510 PyErr_Clear();
6511 if (obj && !PythonQtSlotFunction_Check(obj)) {
6512 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
6513 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6514 void* args[2] = {NULL, (void*)&arg__1};
6515 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6516 if (result) { Py_DECREF(result); }
6517 Py_DECREF(obj);
6518 return;
6519 }
6520 }
6521 elfFileWidget::inputMethodEvent(arg__1);
6522 }
6523 QVariant PythonQtShell_elfFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
6524 {
6525 if (_wrapper) {
6526 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
6527 PyErr_Clear();
6528 if (obj && !PythonQtSlotFunction_Check(obj)) {
6529 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
6530 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6531 QVariant returnValue;
6532 void* args[2] = {NULL, (void*)&arg__1};
6533 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6534 if (result) {
6535 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6536 if (args[0]!=&returnValue) {
6537 if (args[0]==NULL) {
6538 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
6539 } else {
6540 returnValue = *((QVariant*)args[0]);
6541 }
6542 }
6543 }
6544 if (result) { Py_DECREF(result); }
6545 Py_DECREF(obj);
6546 return returnValue;
6547 }
6548 }
6549 return elfFileWidget::inputMethodQuery(arg__1);
6550 }
6551 void PythonQtShell_elfFileWidget::keyPressEvent(QKeyEvent* arg__1)
6552 {
6553 if (_wrapper) {
6554 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
6555 PyErr_Clear();
6556 if (obj && !PythonQtSlotFunction_Check(obj)) {
6557 static const char* argumentList[] ={"" , "QKeyEvent*"};
6558 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6559 void* args[2] = {NULL, (void*)&arg__1};
6560 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6561 if (result) { Py_DECREF(result); }
6562 Py_DECREF(obj);
6563 return;
6564 }
6565 }
6566 elfFileWidget::keyPressEvent(arg__1);
6567 }
6568 void PythonQtShell_elfFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
6569 {
6570 if (_wrapper) {
6571 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
6572 PyErr_Clear();
6573 if (obj && !PythonQtSlotFunction_Check(obj)) {
6574 static const char* argumentList[] ={"" , "QKeyEvent*"};
6575 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6576 void* args[2] = {NULL, (void*)&arg__1};
6577 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6578 if (result) { Py_DECREF(result); }
6579 Py_DECREF(obj);
6580 return;
6581 }
6582 }
6583 elfFileWidget::keyReleaseEvent(arg__1);
6584 }
6585 void PythonQtShell_elfFileWidget::leaveEvent(QEvent* arg__1)
6586 {
6587 if (_wrapper) {
6588 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
6589 PyErr_Clear();
6590 if (obj && !PythonQtSlotFunction_Check(obj)) {
6591 static const char* argumentList[] ={"" , "QEvent*"};
6592 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6593 void* args[2] = {NULL, (void*)&arg__1};
6594 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6595 if (result) { Py_DECREF(result); }
6596 Py_DECREF(obj);
6597 return;
6598 }
6599 }
6600 elfFileWidget::leaveEvent(arg__1);
6601 }
6602 int PythonQtShell_elfFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
6603 {
6604 if (_wrapper) {
6605 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
6606 PyErr_Clear();
6607 if (obj && !PythonQtSlotFunction_Check(obj)) {
6608 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
6609 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6610 int returnValue;
6611 void* args[2] = {NULL, (void*)&arg__1};
6612 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6613 if (result) {
6614 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6615 if (args[0]!=&returnValue) {
6616 if (args[0]==NULL) {
6617 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
6618 } else {
6619 returnValue = *((int*)args[0]);
6620 }
6621 }
6622 }
6623 if (result) { Py_DECREF(result); }
6624 Py_DECREF(obj);
6625 return returnValue;
6626 }
6627 }
6628 return elfFileWidget::metric(arg__1);
6629 }
6630 QSize PythonQtShell_elfFileWidget::minimumSizeHint() const
6631 {
6632 if (_wrapper) {
6633 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
6634 PyErr_Clear();
6635 if (obj && !PythonQtSlotFunction_Check(obj)) {
6636 static const char* argumentList[] ={"QSize"};
6637 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6638 QSize returnValue;
6639 void* args[1] = {NULL};
6640 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6641 if (result) {
6642 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6643 if (args[0]!=&returnValue) {
6644 if (args[0]==NULL) {
6645 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
6646 } else {
6647 returnValue = *((QSize*)args[0]);
6648 }
6649 }
6650 }
6651 if (result) { Py_DECREF(result); }
6652 Py_DECREF(obj);
6653 return returnValue;
6654 }
6655 }
6656 return elfFileWidget::minimumSizeHint();
6657 }
6658 void PythonQtShell_elfFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
6659 {
6660 if (_wrapper) {
6661 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
6662 PyErr_Clear();
6663 if (obj && !PythonQtSlotFunction_Check(obj)) {
6664 static const char* argumentList[] ={"" , "QMouseEvent*"};
6665 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6666 void* args[2] = {NULL, (void*)&arg__1};
6667 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6668 if (result) { Py_DECREF(result); }
6669 Py_DECREF(obj);
6670 return;
6671 }
6672 }
6673 elfFileWidget::mouseDoubleClickEvent(arg__1);
6674 }
6675 void PythonQtShell_elfFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
6676 {
6677 if (_wrapper) {
6678 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
6679 PyErr_Clear();
6680 if (obj && !PythonQtSlotFunction_Check(obj)) {
6681 static const char* argumentList[] ={"" , "QMouseEvent*"};
6682 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6683 void* args[2] = {NULL, (void*)&arg__1};
6684 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6685 if (result) { Py_DECREF(result); }
6686 Py_DECREF(obj);
6687 return;
6688 }
6689 }
6690 elfFileWidget::mouseMoveEvent(arg__1);
6691 }
6692 void PythonQtShell_elfFileWidget::mousePressEvent(QMouseEvent* arg__1)
6693 {
6694 if (_wrapper) {
6695 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
6696 PyErr_Clear();
6697 if (obj && !PythonQtSlotFunction_Check(obj)) {
6698 static const char* argumentList[] ={"" , "QMouseEvent*"};
6699 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6700 void* args[2] = {NULL, (void*)&arg__1};
6701 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6702 if (result) { Py_DECREF(result); }
6703 Py_DECREF(obj);
6704 return;
6705 }
6706 }
6707 elfFileWidget::mousePressEvent(arg__1);
6708 }
6709 void PythonQtShell_elfFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
6710 {
6711 if (_wrapper) {
6712 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
6713 PyErr_Clear();
6714 if (obj && !PythonQtSlotFunction_Check(obj)) {
6715 static const char* argumentList[] ={"" , "QMouseEvent*"};
6716 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6717 void* args[2] = {NULL, (void*)&arg__1};
6718 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6719 if (result) { Py_DECREF(result); }
6720 Py_DECREF(obj);
6721 return;
6722 }
6723 }
6724 elfFileWidget::mouseReleaseEvent(arg__1);
6725 }
6726 void PythonQtShell_elfFileWidget::moveEvent(QMoveEvent* arg__1)
6727 {
6728 if (_wrapper) {
6729 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
6730 PyErr_Clear();
6731 if (obj && !PythonQtSlotFunction_Check(obj)) {
6732 static const char* argumentList[] ={"" , "QMoveEvent*"};
6733 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6734 void* args[2] = {NULL, (void*)&arg__1};
6735 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6736 if (result) { Py_DECREF(result); }
6737 Py_DECREF(obj);
6738 return;
6739 }
6740 }
6741 elfFileWidget::moveEvent(arg__1);
6742 }
6743 bool PythonQtShell_elfFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result)
6744 {
6745 if (_wrapper) {
6746 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
6747 PyErr_Clear();
6748 if (obj && !PythonQtSlotFunction_Check(obj)) {
6749 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
6750 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
6751 bool returnValue;
6752 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
6753 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6754 if (result) {
6755 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6756 if (args[0]!=&returnValue) {
6757 if (args[0]==NULL) {
6758 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
6759 } else {
6760 returnValue = *((bool*)args[0]);
6761 }
6762 }
6763 }
6764 if (result) { Py_DECREF(result); }
6765 Py_DECREF(obj);
6766 return returnValue;
6767 }
6768 }
6769 return elfFileWidget::nativeEvent(eventType, message, result);
6770 }
6771 QPaintEngine* PythonQtShell_elfFileWidget::paintEngine() const
6772 {
6773 if (_wrapper) {
6774 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
6775 PyErr_Clear();
6776 if (obj && !PythonQtSlotFunction_Check(obj)) {
6777 static const char* argumentList[] ={"QPaintEngine*"};
6778 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6779 QPaintEngine* returnValue;
6780 void* args[1] = {NULL};
6781 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6782 if (result) {
6783 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6784 if (args[0]!=&returnValue) {
6785 if (args[0]==NULL) {
6786 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
6787 } else {
6788 returnValue = *((QPaintEngine**)args[0]);
6789 }
6790 }
6791 }
6792 if (result) { Py_DECREF(result); }
6793 Py_DECREF(obj);
6794 return returnValue;
6795 }
6796 }
6797 return elfFileWidget::paintEngine();
6798 }
6799 void PythonQtShell_elfFileWidget::paintEvent(QPaintEvent* arg__1)
6800 {
6801 if (_wrapper) {
6802 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
6803 PyErr_Clear();
6804 if (obj && !PythonQtSlotFunction_Check(obj)) {
6805 static const char* argumentList[] ={"" , "QPaintEvent*"};
6806 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6807 void* args[2] = {NULL, (void*)&arg__1};
6808 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6809 if (result) { Py_DECREF(result); }
6810 Py_DECREF(obj);
6811 return;
6812 }
6813 }
6814 elfFileWidget::paintEvent(arg__1);
6815 }
6816 QPaintDevice* PythonQtShell_elfFileWidget::redirected(QPoint* offset) const
6817 {
6818 if (_wrapper) {
6819 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
6820 PyErr_Clear();
6821 if (obj && !PythonQtSlotFunction_Check(obj)) {
6822 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
6823 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6824 QPaintDevice* returnValue;
6825 void* args[2] = {NULL, (void*)&offset};
6826 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6827 if (result) {
6828 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6829 if (args[0]!=&returnValue) {
6830 if (args[0]==NULL) {
6831 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
6832 } else {
6833 returnValue = *((QPaintDevice**)args[0]);
6834 }
6835 }
6836 }
6837 if (result) { Py_DECREF(result); }
6838 Py_DECREF(obj);
6839 return returnValue;
6840 }
6841 }
6842 return elfFileWidget::redirected(offset);
6843 }
6844 void PythonQtShell_elfFileWidget::resizeEvent(QResizeEvent* arg__1)
6845 {
6846 if (_wrapper) {
6847 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
6848 PyErr_Clear();
6849 if (obj && !PythonQtSlotFunction_Check(obj)) {
6850 static const char* argumentList[] ={"" , "QResizeEvent*"};
6851 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6852 void* args[2] = {NULL, (void*)&arg__1};
6853 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6854 if (result) { Py_DECREF(result); }
6855 Py_DECREF(obj);
6856 return;
6857 }
6858 }
6859 elfFileWidget::resizeEvent(arg__1);
6860 }
6861 QPainter* PythonQtShell_elfFileWidget::sharedPainter() const
6862 {
6863 if (_wrapper) {
6864 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
6865 PyErr_Clear();
6866 if (obj && !PythonQtSlotFunction_Check(obj)) {
6867 static const char* argumentList[] ={"QPainter*"};
6868 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6869 QPainter* returnValue;
6870 void* args[1] = {NULL};
6871 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6872 if (result) {
6873 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6874 if (args[0]!=&returnValue) {
6875 if (args[0]==NULL) {
6876 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
6877 } else {
6878 returnValue = *((QPainter**)args[0]);
6879 }
6880 }
6881 }
6882 if (result) { Py_DECREF(result); }
6883 Py_DECREF(obj);
6884 return returnValue;
6885 }
6886 }
6887 return elfFileWidget::sharedPainter();
6888 }
6889 void PythonQtShell_elfFileWidget::showEvent(QShowEvent* arg__1)
6890 {
6891 if (_wrapper) {
6892 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
6893 PyErr_Clear();
6894 if (obj && !PythonQtSlotFunction_Check(obj)) {
6895 static const char* argumentList[] ={"" , "QShowEvent*"};
6896 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6897 void* args[2] = {NULL, (void*)&arg__1};
6898 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6899 if (result) { Py_DECREF(result); }
6900 Py_DECREF(obj);
6901 return;
6902 }
6903 }
6904 elfFileWidget::showEvent(arg__1);
6905 }
6906 QSize PythonQtShell_elfFileWidget::sizeHint() const
6907 {
6908 if (_wrapper) {
6909 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
6910 PyErr_Clear();
6911 if (obj && !PythonQtSlotFunction_Check(obj)) {
6912 static const char* argumentList[] ={"QSize"};
6913 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6914 QSize returnValue;
6915 void* args[1] = {NULL};
6916 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6917 if (result) {
6918 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6919 if (args[0]!=&returnValue) {
6920 if (args[0]==NULL) {
6921 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
6922 } else {
6923 returnValue = *((QSize*)args[0]);
6924 }
6925 }
6926 }
6927 if (result) { Py_DECREF(result); }
6928 Py_DECREF(obj);
6929 return returnValue;
6930 }
6931 }
6932 return elfFileWidget::sizeHint();
6933 }
6934 void PythonQtShell_elfFileWidget::tabletEvent(QTabletEvent* arg__1)
6935 {
6936 if (_wrapper) {
6937 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
6938 PyErr_Clear();
6939 if (obj && !PythonQtSlotFunction_Check(obj)) {
6940 static const char* argumentList[] ={"" , "QTabletEvent*"};
6941 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6942 void* args[2] = {NULL, (void*)&arg__1};
6943 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6944 if (result) { Py_DECREF(result); }
6945 Py_DECREF(obj);
6946 return;
6947 }
6948 }
6949 elfFileWidget::tabletEvent(arg__1);
6950 }
6951 void PythonQtShell_elfFileWidget::timerEvent(QTimerEvent* arg__1)
6952 {
6953 if (_wrapper) {
6954 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
6955 PyErr_Clear();
6956 if (obj && !PythonQtSlotFunction_Check(obj)) {
6957 static const char* argumentList[] ={"" , "QTimerEvent*"};
6958 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6959 void* args[2] = {NULL, (void*)&arg__1};
6960 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6961 if (result) { Py_DECREF(result); }
6962 Py_DECREF(obj);
6963 return;
6964 }
6965 }
6966 elfFileWidget::timerEvent(arg__1);
6967 }
6968 void PythonQtShell_elfFileWidget::wheelEvent(QWheelEvent* arg__1)
6969 {
6970 if (_wrapper) {
6971 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
6972 PyErr_Clear();
6973 if (obj && !PythonQtSlotFunction_Check(obj)) {
6974 static const char* argumentList[] ={"" , "QWheelEvent*"};
6975 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6976 void* args[2] = {NULL, (void*)&arg__1};
6977 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6978 if (result) { Py_DECREF(result); }
6979 Py_DECREF(obj);
6980 return;
6981 }
6982 }
6983 elfFileWidget::wheelEvent(arg__1);
6372 if (result) { Py_DECREF(result); }
6373 Py_DECREF(obj);
6374 return;
6375 }
6376 }
6377 elfFileWidget::reloadFile();
6378 }
6379 void PythonQtShell_elfFileWidget::setFile(abstractBinFile* file)
6380 {
6381 if (_wrapper) {
6382 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
6383 PyErr_Clear();
6384 if (obj && !PythonQtSlotFunction_Check(obj)) {
6385 static const char* argumentList[] ={"" , "abstractBinFile*"};
6386 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6387 void* args[2] = {NULL, (void*)&file};
6388 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6389 if (result) { Py_DECREF(result); }
6390 Py_DECREF(obj);
6391 return;
6392 }
6393 }
6394
6984 6395 }
6985 6396 elfFileWidget* PythonQtWrapper_elfFileWidget::new_elfFileWidget(QWidget* parent)
6986 6397 {
6987 6398 return new PythonQtShell_elfFileWidget(parent); }
6988 6399
6400 void PythonQtWrapper_elfFileWidget::reloadFile(elfFileWidget* theWrappedObject)
6401 {
6402 ( ((PythonQtPublicPromoter_elfFileWidget*)theWrappedObject)->promoted_reloadFile());
6403 }
6404
6989 6405
6990 6406
6991 6407 PythonQtShell_elfInfoWdgt::~PythonQtShell_elfInfoWdgt() {
@@ -8157,6 +7573,62 if (_wrapper) {
8157 7573 }
8158 7574 return srecFile::openFile(File);
8159 7575 }
7576 bool PythonQtShell_srecFile::toBinary(const QString& File)
7577 {
7578 if (_wrapper) {
7579 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
7580 PyErr_Clear();
7581 if (obj && !PythonQtSlotFunction_Check(obj)) {
7582 static const char* argumentList[] ={"bool" , "const QString&"};
7583 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7584 bool returnValue;
7585 void* args[2] = {NULL, (void*)&File};
7586 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7587 if (result) {
7588 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7589 if (args[0]!=&returnValue) {
7590 if (args[0]==NULL) {
7591 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
7592 } else {
7593 returnValue = *((bool*)args[0]);
7594 }
7595 }
7596 }
7597 if (result) { Py_DECREF(result); }
7598 Py_DECREF(obj);
7599 return returnValue;
7600 }
7601 }
7602 return srecFile::toBinary(File);
7603 }
7604 bool PythonQtShell_srecFile::toSrec(const QString& File)
7605 {
7606 if (_wrapper) {
7607 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
7608 PyErr_Clear();
7609 if (obj && !PythonQtSlotFunction_Check(obj)) {
7610 static const char* argumentList[] ={"bool" , "const QString&"};
7611 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7612 bool returnValue;
7613 void* args[2] = {NULL, (void*)&File};
7614 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7615 if (result) {
7616 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7617 if (args[0]!=&returnValue) {
7618 if (args[0]==NULL) {
7619 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
7620 } else {
7621 returnValue = *((bool*)args[0]);
7622 }
7623 }
7624 }
7625 if (result) { Py_DECREF(result); }
7626 Py_DECREF(obj);
7627 return returnValue;
7628 }
7629 }
7630 return srecFile::toSrec(File);
7631 }
8160 7632 srecFile* PythonQtWrapper_srecFile::new_srecFile()
8161 7633 {
8162 7634 return new PythonQtShell_srecFile(); }
@@ -8174,6 +7646,11 int PythonQtWrapper_srecFile::closeFile
8174 7646 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_closeFile());
8175 7647 }
8176 7648
7649 codeFragment* PythonQtWrapper_srecFile::getFragment(srecFile* theWrappedObject, int index)
7650 {
7651 return ( theWrappedObject->getFragment(index));
7652 }
7653
8177 7654 int PythonQtWrapper_srecFile::getFragmentAddress(srecFile* theWrappedObject, int index)
8178 7655 {
8179 7656 return ( theWrappedObject->getFragmentAddress(index));
@@ -8234,921 +7711,73 bool PythonQtWrapper_srecFile::openFile
8234 7711 return ( theWrappedObject->openFiles(Files));
8235 7712 }
8236 7713
7714 bool PythonQtWrapper_srecFile::toBinary(srecFile* theWrappedObject, const QString& File)
7715 {
7716 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_toBinary(File));
7717 }
7718
8237 7719 bool PythonQtWrapper_srecFile::static_srecFile_toSrec(QList<codeFragment* > fragments, const QString& File)
8238 7720 {
8239 7721 return (srecFile::toSrec(fragments, File));
8240 7722 }
8241 7723
7724 bool PythonQtWrapper_srecFile::toSrec(srecFile* theWrappedObject, const QString& File)
7725 {
7726 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_toSrec(File));
7727 }
7728
8242 7729
8243 7730
8244 7731 PythonQtShell_srecFileWidget::~PythonQtShell_srecFileWidget() {
8245 7732 PythonQtPrivate* priv = PythonQt::priv();
8246 7733 if (priv) { priv->shellClassDeleted(this); }
8247 7734 }
8248 void PythonQtShell_srecFileWidget::actionEvent(QActionEvent* arg__1)
8249 {
8250 if (_wrapper) {
8251 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
8252 PyErr_Clear();
8253 if (obj && !PythonQtSlotFunction_Check(obj)) {
8254 static const char* argumentList[] ={"" , "QActionEvent*"};
8255 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8256 void* args[2] = {NULL, (void*)&arg__1};
8257 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8258 if (result) { Py_DECREF(result); }
8259 Py_DECREF(obj);
8260 return;
8261 }
8262 }
8263 srecFileWidget::actionEvent(arg__1);
8264 }
8265 void PythonQtShell_srecFileWidget::changeEvent(QEvent* arg__1)
8266 {
8267 if (_wrapper) {
8268 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
8269 PyErr_Clear();
8270 if (obj && !PythonQtSlotFunction_Check(obj)) {
8271 static const char* argumentList[] ={"" , "QEvent*"};
8272 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8273 void* args[2] = {NULL, (void*)&arg__1};
8274 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8275 if (result) { Py_DECREF(result); }
8276 Py_DECREF(obj);
8277 return;
8278 }
8279 }
8280 srecFileWidget::changeEvent(arg__1);
8281 }
8282 void PythonQtShell_srecFileWidget::childEvent(QChildEvent* arg__1)
8283 {
8284 if (_wrapper) {
8285 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
8286 PyErr_Clear();
8287 if (obj && !PythonQtSlotFunction_Check(obj)) {
8288 static const char* argumentList[] ={"" , "QChildEvent*"};
8289 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8290 void* args[2] = {NULL, (void*)&arg__1};
8291 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8292 if (result) { Py_DECREF(result); }
8293 Py_DECREF(obj);
8294 return;
8295 }
8296 }
8297 srecFileWidget::childEvent(arg__1);
8298 }
8299 void PythonQtShell_srecFileWidget::closeEvent(QCloseEvent* arg__1)
8300 {
8301 if (_wrapper) {
8302 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
8303 PyErr_Clear();
8304 if (obj && !PythonQtSlotFunction_Check(obj)) {
8305 static const char* argumentList[] ={"" , "QCloseEvent*"};
8306 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8307 void* args[2] = {NULL, (void*)&arg__1};
8308 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8309 if (result) { Py_DECREF(result); }
8310 Py_DECREF(obj);
8311 return;
8312 }
8313 }
8314 srecFileWidget::closeEvent(arg__1);
8315 }
8316 void PythonQtShell_srecFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
8317 {
8318 if (_wrapper) {
8319 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
8320 PyErr_Clear();
8321 if (obj && !PythonQtSlotFunction_Check(obj)) {
8322 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
8323 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8324 void* args[2] = {NULL, (void*)&arg__1};
8325 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8326 if (result) { Py_DECREF(result); }
8327 Py_DECREF(obj);
8328 return;
8329 }
8330 }
8331 srecFileWidget::contextMenuEvent(arg__1);
8332 }
8333 void PythonQtShell_srecFileWidget::customEvent(QEvent* arg__1)
8334 {
8335 if (_wrapper) {
8336 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
8337 PyErr_Clear();
8338 if (obj && !PythonQtSlotFunction_Check(obj)) {
8339 static const char* argumentList[] ={"" , "QEvent*"};
8340 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8341 void* args[2] = {NULL, (void*)&arg__1};
8342 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8343 if (result) { Py_DECREF(result); }
8344 Py_DECREF(obj);
8345 return;
8346 }
8347 }
8348 srecFileWidget::customEvent(arg__1);
8349 }
8350 int PythonQtShell_srecFileWidget::devType() const
8351 {
8352 if (_wrapper) {
8353 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
8354 PyErr_Clear();
8355 if (obj && !PythonQtSlotFunction_Check(obj)) {
8356 static const char* argumentList[] ={"int"};
7735 void PythonQtShell_srecFileWidget::reloadFile()
7736 {
7737 if (_wrapper) {
7738 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
7739 PyErr_Clear();
7740 if (obj && !PythonQtSlotFunction_Check(obj)) {
7741 static const char* argumentList[] ={""};
8357 7742 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8358 int returnValue;
8359 void* args[1] = {NULL};
8360 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8361 if (result) {
8362 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8363 if (args[0]!=&returnValue) {
8364 if (args[0]==NULL) {
8365 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
8366 } else {
8367 returnValue = *((int*)args[0]);
8368 }
8369 }
8370 }
8371 if (result) { Py_DECREF(result); }
8372 Py_DECREF(obj);
8373 return returnValue;
8374 }
8375 }
8376 return srecFileWidget::devType();
8377 }
8378 void PythonQtShell_srecFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
8379 {
8380 if (_wrapper) {
8381 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
8382 PyErr_Clear();
8383 if (obj && !PythonQtSlotFunction_Check(obj)) {
8384 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
8385 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8386 void* args[2] = {NULL, (void*)&arg__1};
8387 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8388 if (result) { Py_DECREF(result); }
8389 Py_DECREF(obj);
8390 return;
8391 }
8392 }
8393 srecFileWidget::dragEnterEvent(arg__1);
8394 }
8395 void PythonQtShell_srecFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
8396 {
8397 if (_wrapper) {
8398 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
8399 PyErr_Clear();
8400 if (obj && !PythonQtSlotFunction_Check(obj)) {
8401 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
8402 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8403 void* args[2] = {NULL, (void*)&arg__1};
8404 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8405 if (result) { Py_DECREF(result); }
8406 Py_DECREF(obj);
8407 return;
8408 }
8409 }
8410 srecFileWidget::dragLeaveEvent(arg__1);
8411 }
8412 void PythonQtShell_srecFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
8413 {
8414 if (_wrapper) {
8415 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
8416 PyErr_Clear();
8417 if (obj && !PythonQtSlotFunction_Check(obj)) {
8418 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
8419 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8420 void* args[2] = {NULL, (void*)&arg__1};
8421 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8422 if (result) { Py_DECREF(result); }
8423 Py_DECREF(obj);
8424 return;
8425 }
8426 }
8427 srecFileWidget::dragMoveEvent(arg__1);
8428 }
8429 void PythonQtShell_srecFileWidget::dropEvent(QDropEvent* arg__1)
8430 {
8431 if (_wrapper) {
8432 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
8433 PyErr_Clear();
8434 if (obj && !PythonQtSlotFunction_Check(obj)) {
8435 static const char* argumentList[] ={"" , "QDropEvent*"};
8436 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8437 void* args[2] = {NULL, (void*)&arg__1};
8438 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8439 if (result) { Py_DECREF(result); }
8440 Py_DECREF(obj);
8441 return;
8442 }
8443 }
8444 srecFileWidget::dropEvent(arg__1);
8445 }
8446 void PythonQtShell_srecFileWidget::enterEvent(QEvent* arg__1)
8447 {
8448 if (_wrapper) {
8449 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
8450 PyErr_Clear();
8451 if (obj && !PythonQtSlotFunction_Check(obj)) {
8452 static const char* argumentList[] ={"" , "QEvent*"};
8453 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8454 void* args[2] = {NULL, (void*)&arg__1};
8455 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8456 if (result) { Py_DECREF(result); }
8457 Py_DECREF(obj);
8458 return;
8459 }
8460 }
8461 srecFileWidget::enterEvent(arg__1);
8462 }
8463 bool PythonQtShell_srecFileWidget::event(QEvent* arg__1)
8464 {
8465 if (_wrapper) {
8466 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
8467 PyErr_Clear();
8468 if (obj && !PythonQtSlotFunction_Check(obj)) {
8469 static const char* argumentList[] ={"bool" , "QEvent*"};
8470 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8471 bool returnValue;
8472 void* args[2] = {NULL, (void*)&arg__1};
8473 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8474 if (result) {
8475 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8476 if (args[0]!=&returnValue) {
8477 if (args[0]==NULL) {
8478 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
8479 } else {
8480 returnValue = *((bool*)args[0]);
8481 }
8482 }
8483 }
8484 if (result) { Py_DECREF(result); }
8485 Py_DECREF(obj);
8486 return returnValue;
8487 }
8488 }
8489 return srecFileWidget::event(arg__1);
8490 }
8491 bool PythonQtShell_srecFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
8492 {
8493 if (_wrapper) {
8494 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
8495 PyErr_Clear();
8496 if (obj && !PythonQtSlotFunction_Check(obj)) {
8497 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
8498 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
8499 bool returnValue;
8500 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
8501 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8502 if (result) {
8503 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8504 if (args[0]!=&returnValue) {
8505 if (args[0]==NULL) {
8506 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
8507 } else {
8508 returnValue = *((bool*)args[0]);
8509 }
8510 }
8511 }
8512 if (result) { Py_DECREF(result); }
8513 Py_DECREF(obj);
8514 return returnValue;
8515 }
8516 }
8517 return srecFileWidget::eventFilter(arg__1, arg__2);
8518 }
8519 void PythonQtShell_srecFileWidget::focusInEvent(QFocusEvent* arg__1)
8520 {
8521 if (_wrapper) {
8522 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
8523 PyErr_Clear();
8524 if (obj && !PythonQtSlotFunction_Check(obj)) {
8525 static const char* argumentList[] ={"" , "QFocusEvent*"};
8526 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8527 void* args[2] = {NULL, (void*)&arg__1};
8528 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8529 if (result) { Py_DECREF(result); }
8530 Py_DECREF(obj);
8531 return;
8532 }
8533 }
8534 srecFileWidget::focusInEvent(arg__1);
8535 }
8536 bool PythonQtShell_srecFileWidget::focusNextPrevChild(bool next)
8537 {
8538 if (_wrapper) {
8539 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
8540 PyErr_Clear();
8541 if (obj && !PythonQtSlotFunction_Check(obj)) {
8542 static const char* argumentList[] ={"bool" , "bool"};
8543 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8544 bool returnValue;
8545 void* args[2] = {NULL, (void*)&next};
8546 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8547 if (result) {
8548 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8549 if (args[0]!=&returnValue) {
8550 if (args[0]==NULL) {
8551 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
8552 } else {
8553 returnValue = *((bool*)args[0]);
8554 }
8555 }
8556 }
8557 if (result) { Py_DECREF(result); }
8558 Py_DECREF(obj);
8559 return returnValue;
8560 }
8561 }
8562 return srecFileWidget::focusNextPrevChild(next);
8563 }
8564 void PythonQtShell_srecFileWidget::focusOutEvent(QFocusEvent* arg__1)
8565 {
8566 if (_wrapper) {
8567 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
8568 PyErr_Clear();
8569 if (obj && !PythonQtSlotFunction_Check(obj)) {
8570 static const char* argumentList[] ={"" , "QFocusEvent*"};
8571 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8572 void* args[2] = {NULL, (void*)&arg__1};
8573 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8574 if (result) { Py_DECREF(result); }
8575 Py_DECREF(obj);
8576 return;
8577 }
8578 }
8579 srecFileWidget::focusOutEvent(arg__1);
8580 }
8581 bool PythonQtShell_srecFileWidget::hasHeightForWidth() const
8582 {
8583 if (_wrapper) {
8584 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
8585 PyErr_Clear();
8586 if (obj && !PythonQtSlotFunction_Check(obj)) {
8587 static const char* argumentList[] ={"bool"};
8588 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8589 bool returnValue;
8590 7743 void* args[1] = {NULL};
8591 7744 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8592 if (result) {
8593 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8594 if (args[0]!=&returnValue) {
8595 if (args[0]==NULL) {
8596 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
8597 } else {
8598 returnValue = *((bool*)args[0]);
8599 }
8600 }
8601 }
8602 if (result) { Py_DECREF(result); }
8603 Py_DECREF(obj);
8604 return returnValue;
8605 }
8606 }
8607 return srecFileWidget::hasHeightForWidth();
8608 }
8609 int PythonQtShell_srecFileWidget::heightForWidth(int arg__1) const
8610 {
8611 if (_wrapper) {
8612 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
8613 PyErr_Clear();
8614 if (obj && !PythonQtSlotFunction_Check(obj)) {
8615 static const char* argumentList[] ={"int" , "int"};
8616 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8617 int returnValue;
8618 void* args[2] = {NULL, (void*)&arg__1};
8619 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8620 if (result) {
8621 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8622 if (args[0]!=&returnValue) {
8623 if (args[0]==NULL) {
8624 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
8625 } else {
8626 returnValue = *((int*)args[0]);
8627 }
8628 }
8629 }
8630 if (result) { Py_DECREF(result); }
8631 Py_DECREF(obj);
8632 return returnValue;
8633 }
8634 }
8635 return srecFileWidget::heightForWidth(arg__1);
8636 }
8637 void PythonQtShell_srecFileWidget::hideEvent(QHideEvent* arg__1)
8638 {
8639 if (_wrapper) {
8640 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
8641 PyErr_Clear();
8642 if (obj && !PythonQtSlotFunction_Check(obj)) {
8643 static const char* argumentList[] ={"" , "QHideEvent*"};
8644 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8645 void* args[2] = {NULL, (void*)&arg__1};
8646 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8647 if (result) { Py_DECREF(result); }
8648 Py_DECREF(obj);
8649 return;
8650 }
8651 }
8652 srecFileWidget::hideEvent(arg__1);
8653 }
8654 void PythonQtShell_srecFileWidget::initPainter(QPainter* painter) const
8655 {
8656 if (_wrapper) {
8657 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
8658 PyErr_Clear();
8659 if (obj && !PythonQtSlotFunction_Check(obj)) {
8660 static const char* argumentList[] ={"" , "QPainter*"};
8661 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8662 void* args[2] = {NULL, (void*)&painter};
8663 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8664 if (result) { Py_DECREF(result); }
8665 Py_DECREF(obj);
8666 return;
8667 }
8668 }
8669 srecFileWidget::initPainter(painter);
8670 }
8671 void PythonQtShell_srecFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
8672 {
8673 if (_wrapper) {
8674 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
8675 PyErr_Clear();
8676 if (obj && !PythonQtSlotFunction_Check(obj)) {
8677 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
8678 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8679 void* args[2] = {NULL, (void*)&arg__1};
8680 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8681 if (result) { Py_DECREF(result); }
8682 Py_DECREF(obj);
8683 return;
8684 }
8685 }
8686 srecFileWidget::inputMethodEvent(arg__1);
8687 }
8688 QVariant PythonQtShell_srecFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
8689 {
8690 if (_wrapper) {
8691 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
8692 PyErr_Clear();
8693 if (obj && !PythonQtSlotFunction_Check(obj)) {
8694 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
8695 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8696 QVariant returnValue;
8697 void* args[2] = {NULL, (void*)&arg__1};
8698 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8699 if (result) {
8700 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8701 if (args[0]!=&returnValue) {
8702 if (args[0]==NULL) {
8703 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
8704 } else {
8705 returnValue = *((QVariant*)args[0]);
8706 }
8707 }
8708 }
8709 if (result) { Py_DECREF(result); }
8710 Py_DECREF(obj);
8711 return returnValue;
8712 }
8713 }
8714 return srecFileWidget::inputMethodQuery(arg__1);
8715 }
8716 void PythonQtShell_srecFileWidget::keyPressEvent(QKeyEvent* arg__1)
8717 {
8718 if (_wrapper) {
8719 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
8720 PyErr_Clear();
8721 if (obj && !PythonQtSlotFunction_Check(obj)) {
8722 static const char* argumentList[] ={"" , "QKeyEvent*"};
8723 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8724 void* args[2] = {NULL, (void*)&arg__1};
8725 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8726 if (result) { Py_DECREF(result); }
8727 Py_DECREF(obj);
8728 return;
8729 }
8730 }
8731 srecFileWidget::keyPressEvent(arg__1);
8732 }
8733 void PythonQtShell_srecFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
8734 {
8735 if (_wrapper) {
8736 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
8737 PyErr_Clear();
8738 if (obj && !PythonQtSlotFunction_Check(obj)) {
8739 static const char* argumentList[] ={"" , "QKeyEvent*"};
8740 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8741 void* args[2] = {NULL, (void*)&arg__1};
8742 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8743 if (result) { Py_DECREF(result); }
8744 Py_DECREF(obj);
8745 return;
8746 }
8747 }
8748 srecFileWidget::keyReleaseEvent(arg__1);
8749 }
8750 void PythonQtShell_srecFileWidget::leaveEvent(QEvent* arg__1)
8751 {
8752 if (_wrapper) {
8753 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
8754 PyErr_Clear();
8755 if (obj && !PythonQtSlotFunction_Check(obj)) {
8756 static const char* argumentList[] ={"" , "QEvent*"};
8757 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8758 void* args[2] = {NULL, (void*)&arg__1};
8759 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8760 if (result) { Py_DECREF(result); }
8761 Py_DECREF(obj);
8762 return;
8763 }
8764 }
8765 srecFileWidget::leaveEvent(arg__1);
8766 }
8767 int PythonQtShell_srecFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
8768 {
8769 if (_wrapper) {
8770 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
8771 PyErr_Clear();
8772 if (obj && !PythonQtSlotFunction_Check(obj)) {
8773 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
8774 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8775 int returnValue;
8776 void* args[2] = {NULL, (void*)&arg__1};
8777 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8778 if (result) {
8779 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8780 if (args[0]!=&returnValue) {
8781 if (args[0]==NULL) {
8782 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
8783 } else {
8784 returnValue = *((int*)args[0]);
8785 }
8786 }
8787 }
8788 if (result) { Py_DECREF(result); }
8789 Py_DECREF(obj);
8790 return returnValue;
8791 }
8792 }
8793 return srecFileWidget::metric(arg__1);
8794 }
8795 QSize PythonQtShell_srecFileWidget::minimumSizeHint() const
8796 {
8797 if (_wrapper) {
8798 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
8799 PyErr_Clear();
8800 if (obj && !PythonQtSlotFunction_Check(obj)) {
8801 static const char* argumentList[] ={"QSize"};
8802 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8803 QSize returnValue;
8804 void* args[1] = {NULL};
8805 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8806 if (result) {
8807 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8808 if (args[0]!=&returnValue) {
8809 if (args[0]==NULL) {
8810 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
8811 } else {
8812 returnValue = *((QSize*)args[0]);
8813 }
8814 }
8815 }
8816 if (result) { Py_DECREF(result); }
8817 Py_DECREF(obj);
8818 return returnValue;
8819 }
8820 }
8821 return srecFileWidget::minimumSizeHint();
8822 }
8823 void PythonQtShell_srecFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
8824 {
8825 if (_wrapper) {
8826 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
8827 PyErr_Clear();
8828 if (obj && !PythonQtSlotFunction_Check(obj)) {
8829 static const char* argumentList[] ={"" , "QMouseEvent*"};
8830 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8831 void* args[2] = {NULL, (void*)&arg__1};
8832 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8833 if (result) { Py_DECREF(result); }
8834 Py_DECREF(obj);
8835 return;
8836 }
8837 }
8838 srecFileWidget::mouseDoubleClickEvent(arg__1);
8839 }
8840 void PythonQtShell_srecFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
8841 {
8842 if (_wrapper) {
8843 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
8844 PyErr_Clear();
8845 if (obj && !PythonQtSlotFunction_Check(obj)) {
8846 static const char* argumentList[] ={"" , "QMouseEvent*"};
8847 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8848 void* args[2] = {NULL, (void*)&arg__1};
8849 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8850 if (result) { Py_DECREF(result); }
8851 Py_DECREF(obj);
8852 return;
8853 }
8854 }
8855 srecFileWidget::mouseMoveEvent(arg__1);
8856 }
8857 void PythonQtShell_srecFileWidget::mousePressEvent(QMouseEvent* arg__1)
8858 {
8859 if (_wrapper) {
8860 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
8861 PyErr_Clear();
8862 if (obj && !PythonQtSlotFunction_Check(obj)) {
8863 static const char* argumentList[] ={"" , "QMouseEvent*"};
8864 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8865 void* args[2] = {NULL, (void*)&arg__1};
8866 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8867 if (result) { Py_DECREF(result); }
8868 Py_DECREF(obj);
8869 return;
8870 }
8871 }
8872 srecFileWidget::mousePressEvent(arg__1);
8873 }
8874 void PythonQtShell_srecFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
8875 {
8876 if (_wrapper) {
8877 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
8878 PyErr_Clear();
8879 if (obj && !PythonQtSlotFunction_Check(obj)) {
8880 static const char* argumentList[] ={"" , "QMouseEvent*"};
8881 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8882 void* args[2] = {NULL, (void*)&arg__1};
8883 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8884 if (result) { Py_DECREF(result); }
8885 Py_DECREF(obj);
8886 return;
8887 }
8888 }
8889 srecFileWidget::mouseReleaseEvent(arg__1);
8890 }
8891 void PythonQtShell_srecFileWidget::moveEvent(QMoveEvent* arg__1)
8892 {
8893 if (_wrapper) {
8894 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
8895 PyErr_Clear();
8896 if (obj && !PythonQtSlotFunction_Check(obj)) {
8897 static const char* argumentList[] ={"" , "QMoveEvent*"};
8898 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8899 void* args[2] = {NULL, (void*)&arg__1};
8900 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8901 if (result) { Py_DECREF(result); }
8902 Py_DECREF(obj);
8903 return;
8904 }
8905 }
8906 srecFileWidget::moveEvent(arg__1);
8907 }
8908 bool PythonQtShell_srecFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result)
8909 {
8910 if (_wrapper) {
8911 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
8912 PyErr_Clear();
8913 if (obj && !PythonQtSlotFunction_Check(obj)) {
8914 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
8915 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
8916 bool returnValue;
8917 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
8918 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8919 if (result) {
8920 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8921 if (args[0]!=&returnValue) {
8922 if (args[0]==NULL) {
8923 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
8924 } else {
8925 returnValue = *((bool*)args[0]);
8926 }
8927 }
8928 }
8929 if (result) { Py_DECREF(result); }
8930 Py_DECREF(obj);
8931 return returnValue;
8932 }
8933 }
8934 return srecFileWidget::nativeEvent(eventType, message, result);
8935 }
8936 QPaintEngine* PythonQtShell_srecFileWidget::paintEngine() const
8937 {
8938 if (_wrapper) {
8939 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
8940 PyErr_Clear();
8941 if (obj && !PythonQtSlotFunction_Check(obj)) {
8942 static const char* argumentList[] ={"QPaintEngine*"};
8943 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8944 QPaintEngine* returnValue;
8945 void* args[1] = {NULL};
8946 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8947 if (result) {
8948 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8949 if (args[0]!=&returnValue) {
8950 if (args[0]==NULL) {
8951 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
8952 } else {
8953 returnValue = *((QPaintEngine**)args[0]);
8954 }
8955 }
8956 }
8957 if (result) { Py_DECREF(result); }
8958 Py_DECREF(obj);
8959 return returnValue;
8960 }
8961 }
8962 return srecFileWidget::paintEngine();
8963 }
8964 void PythonQtShell_srecFileWidget::paintEvent(QPaintEvent* arg__1)
8965 {
8966 if (_wrapper) {
8967 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
8968 PyErr_Clear();
8969 if (obj && !PythonQtSlotFunction_Check(obj)) {
8970 static const char* argumentList[] ={"" , "QPaintEvent*"};
8971 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8972 void* args[2] = {NULL, (void*)&arg__1};
8973 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8974 if (result) { Py_DECREF(result); }
8975 Py_DECREF(obj);
8976 return;
8977 }
8978 }
8979 srecFileWidget::paintEvent(arg__1);
8980 }
8981 QPaintDevice* PythonQtShell_srecFileWidget::redirected(QPoint* offset) const
8982 {
8983 if (_wrapper) {
8984 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
8985 PyErr_Clear();
8986 if (obj && !PythonQtSlotFunction_Check(obj)) {
8987 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
8988 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8989 QPaintDevice* returnValue;
8990 void* args[2] = {NULL, (void*)&offset};
8991 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8992 if (result) {
8993 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8994 if (args[0]!=&returnValue) {
8995 if (args[0]==NULL) {
8996 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
8997 } else {
8998 returnValue = *((QPaintDevice**)args[0]);
8999 }
9000 }
9001 }
9002 if (result) { Py_DECREF(result); }
9003 Py_DECREF(obj);
9004 return returnValue;
9005 }
9006 }
9007 return srecFileWidget::redirected(offset);
9008 }
9009 void PythonQtShell_srecFileWidget::resizeEvent(QResizeEvent* arg__1)
9010 {
9011 if (_wrapper) {
9012 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
9013 PyErr_Clear();
9014 if (obj && !PythonQtSlotFunction_Check(obj)) {
9015 static const char* argumentList[] ={"" , "QResizeEvent*"};
9016 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9017 void* args[2] = {NULL, (void*)&arg__1};
9018 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9019 if (result) { Py_DECREF(result); }
9020 Py_DECREF(obj);
9021 return;
9022 }
9023 }
9024 srecFileWidget::resizeEvent(arg__1);
9025 }
9026 QPainter* PythonQtShell_srecFileWidget::sharedPainter() const
9027 {
9028 if (_wrapper) {
9029 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
9030 PyErr_Clear();
9031 if (obj && !PythonQtSlotFunction_Check(obj)) {
9032 static const char* argumentList[] ={"QPainter*"};
9033 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9034 QPainter* returnValue;
9035 void* args[1] = {NULL};
9036 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9037 if (result) {
9038 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9039 if (args[0]!=&returnValue) {
9040 if (args[0]==NULL) {
9041 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
9042 } else {
9043 returnValue = *((QPainter**)args[0]);
9044 }
9045 }
9046 }
9047 if (result) { Py_DECREF(result); }
9048 Py_DECREF(obj);
9049 return returnValue;
9050 }
9051 }
9052 return srecFileWidget::sharedPainter();
9053 }
9054 void PythonQtShell_srecFileWidget::showEvent(QShowEvent* arg__1)
9055 {
9056 if (_wrapper) {
9057 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
9058 PyErr_Clear();
9059 if (obj && !PythonQtSlotFunction_Check(obj)) {
9060 static const char* argumentList[] ={"" , "QShowEvent*"};
9061 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9062 void* args[2] = {NULL, (void*)&arg__1};
9063 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9064 if (result) { Py_DECREF(result); }
9065 Py_DECREF(obj);
9066 return;
9067 }
9068 }
9069 srecFileWidget::showEvent(arg__1);
9070 }
9071 QSize PythonQtShell_srecFileWidget::sizeHint() const
9072 {
9073 if (_wrapper) {
9074 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
9075 PyErr_Clear();
9076 if (obj && !PythonQtSlotFunction_Check(obj)) {
9077 static const char* argumentList[] ={"QSize"};
9078 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9079 QSize returnValue;
9080 void* args[1] = {NULL};
9081 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9082 if (result) {
9083 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9084 if (args[0]!=&returnValue) {
9085 if (args[0]==NULL) {
9086 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
9087 } else {
9088 returnValue = *((QSize*)args[0]);
9089 }
9090 }
9091 }
9092 if (result) { Py_DECREF(result); }
9093 Py_DECREF(obj);
9094 return returnValue;
9095 }
9096 }
9097 return srecFileWidget::sizeHint();
9098 }
9099 void PythonQtShell_srecFileWidget::tabletEvent(QTabletEvent* arg__1)
9100 {
9101 if (_wrapper) {
9102 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
9103 PyErr_Clear();
9104 if (obj && !PythonQtSlotFunction_Check(obj)) {
9105 static const char* argumentList[] ={"" , "QTabletEvent*"};
9106 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9107 void* args[2] = {NULL, (void*)&arg__1};
9108 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9109 if (result) { Py_DECREF(result); }
9110 Py_DECREF(obj);
9111 return;
9112 }
9113 }
9114 srecFileWidget::tabletEvent(arg__1);
9115 }
9116 void PythonQtShell_srecFileWidget::timerEvent(QTimerEvent* arg__1)
9117 {
9118 if (_wrapper) {
9119 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
9120 PyErr_Clear();
9121 if (obj && !PythonQtSlotFunction_Check(obj)) {
9122 static const char* argumentList[] ={"" , "QTimerEvent*"};
9123 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9124 void* args[2] = {NULL, (void*)&arg__1};
9125 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9126 if (result) { Py_DECREF(result); }
9127 Py_DECREF(obj);
9128 return;
9129 }
9130 }
9131 srecFileWidget::timerEvent(arg__1);
9132 }
9133 void PythonQtShell_srecFileWidget::wheelEvent(QWheelEvent* arg__1)
9134 {
9135 if (_wrapper) {
9136 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
9137 PyErr_Clear();
9138 if (obj && !PythonQtSlotFunction_Check(obj)) {
9139 static const char* argumentList[] ={"" , "QWheelEvent*"};
9140 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9141 void* args[2] = {NULL, (void*)&arg__1};
9142 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9143 if (result) { Py_DECREF(result); }
9144 Py_DECREF(obj);
9145 return;
9146 }
9147 }
9148 srecFileWidget::wheelEvent(arg__1);
7745 if (result) { Py_DECREF(result); }
7746 Py_DECREF(obj);
7747 return;
7748 }
7749 }
7750 srecFileWidget::reloadFile();
7751 }
7752 void PythonQtShell_srecFileWidget::setFile(abstractBinFile* file)
7753 {
7754 if (_wrapper) {
7755 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
7756 PyErr_Clear();
7757 if (obj && !PythonQtSlotFunction_Check(obj)) {
7758 static const char* argumentList[] ={"" , "abstractBinFile*"};
7759 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7760 void* args[2] = {NULL, (void*)&file};
7761 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7762 if (result) { Py_DECREF(result); }
7763 Py_DECREF(obj);
7764 return;
7765 }
7766 }
7767 srecFileWidget::setFile(file);
9149 7768 }
9150 7769 srecFileWidget* PythonQtWrapper_srecFileWidget::new_srecFileWidget(QWidget* parent)
9151 7770 {
9152 7771 return new PythonQtShell_srecFileWidget(parent); }
9153 7772
9154
7773 void PythonQtWrapper_srecFileWidget::reloadFile(srecFileWidget* theWrappedObject)
7774 {
7775 ( ((PythonQtPublicPromoter_srecFileWidget*)theWrappedObject)->promoted_reloadFile());
7776 }
7777
7778 void PythonQtWrapper_srecFileWidget::setFile(srecFileWidget* theWrappedObject, abstractBinFile* file)
7779 {
7780 ( ((PythonQtPublicPromoter_srecFileWidget*)theWrappedObject)->promoted_setFile(file));
7781 }
7782
7783
Show file before | Show file after | Hide comments
@@ -70,6 +70,8 virtual int closeFile();
70 70 virtual QList<codeFragment* > getFragments();
71 71 virtual bool isopened();
72 72 virtual bool openFile(const QString& File);
73 virtual bool toBinary(const QString& File);
74 virtual bool toSrec(const QString& File);
73 75
74 76 PythonQtInstanceWrapper* _wrapper;
75 77 };
@@ -80,6 +82,8 inline int promoted_closeFile() { retur
80 82 inline QList<codeFragment* > promoted_getFragments() { return ElfFile::getFragments(); }
81 83 inline bool promoted_isopened() { return ElfFile::isopened(); }
82 84 inline bool promoted_openFile(const QString& File) { return ElfFile::openFile(File); }
85 inline bool promoted_toBinary(const QString& File) { return ElfFile::toBinary(File); }
86 inline bool promoted_toSrec(const QString& File) { return ElfFile::toSrec(File); }
83 87 };
84 88
85 89 class PythonQtWrapper_ElfFile : public QObject
@@ -128,6 +132,7 void delete_ElfFile(ElfFile* obj) { dele
128 132 bool isopened(ElfFile* theWrappedObject);
129 133 bool openFile(ElfFile* theWrappedObject, const QString& File);
130 134 bool sectionIsNobits(ElfFile* theWrappedObject, int index);
135 bool toBinary(ElfFile* theWrappedObject, const QString& File);
131 136 bool toSrec(ElfFile* theWrappedObject, const QString& File);
132 137 };
133 138
@@ -575,6 +580,8 virtual QList<codeFragment* > getFragme
575 580 virtual bool isopened();
576 581 virtual bool openFile(const QString& File);
577 582 virtual void timerEvent(QTimerEvent* arg__1);
583 virtual bool toBinary(const QString& File);
584 virtual bool toSrec(const QString& File);
578 585
579 586 PythonQtInstanceWrapper* _wrapper;
580 587 };
@@ -591,61 +598,12 void delete_abstractBinFile(abstractBinF
591 598
592 599
593 600
594 class PythonQtShell_binaryFile : public binaryFile
601 class PythonQtShell_abstractBinFileWidget : public abstractBinFileWidget
595 602 {
596 603 public:
597 PythonQtShell_binaryFile():binaryFile(),_wrapper(NULL) {};
598 PythonQtShell_binaryFile(const QString& File):binaryFile(File),_wrapper(NULL) {};
599 PythonQtShell_binaryFile(const QStringList& Files):binaryFile(Files),_wrapper(NULL) {};
600
601 ~PythonQtShell_binaryFile();
602
603 virtual int closeFile();
604 virtual QList<codeFragment* > getFragments();
605 virtual bool isopened();
606 virtual bool openFile(const QString& File);
607
608 PythonQtInstanceWrapper* _wrapper;
609 };
610
611 class PythonQtPublicPromoter_binaryFile : public binaryFile
612 { public:
613 inline int promoted_closeFile() { return binaryFile::closeFile(); }
614 inline QList<codeFragment* > promoted_getFragments() { return binaryFile::getFragments(); }
615 inline bool promoted_isopened() { return binaryFile::isopened(); }
616 inline bool promoted_openFile(const QString& File) { return binaryFile::openFile(File); }
617 };
604 PythonQtShell_abstractBinFileWidget(QWidget* parent = 0):abstractBinFileWidget(parent),_wrapper(NULL) {};
618 605
619 class PythonQtWrapper_binaryFile : public QObject
620 { Q_OBJECT
621 public:
622 public slots:
623 binaryFile* new_binaryFile();
624 binaryFile* new_binaryFile(const QString& File);
625 binaryFile* new_binaryFile(const QStringList& Files);
626 void delete_binaryFile(binaryFile* obj) { delete obj; }
627 int closeFile(binaryFile* theWrappedObject);
628 int getFragmentAddress(binaryFile* theWrappedObject, int index);
629 bool getFragmentData(binaryFile* theWrappedObject, int index, char** buffer);
630 QString getFragmentHeader(binaryFile* theWrappedObject, int index);
631 int getFragmentSize(binaryFile* theWrappedObject, int index);
632 QList<codeFragment* > getFragments(binaryFile* theWrappedObject);
633 int getFragmentsCount(binaryFile* theWrappedObject);
634 bool isopened(binaryFile* theWrappedObject);
635 bool openFile(binaryFile* theWrappedObject, const QString& File);
636 bool openFiles(binaryFile* theWrappedObject, const QStringList& Files);
637 };
638
639
640
641
642
643 class PythonQtShell_binaryFileWidget : public binaryFileWidget
644 {
645 public:
646 PythonQtShell_binaryFileWidget(QWidget* parent = 0):binaryFileWidget(parent),_wrapper(NULL) {};
647
648 ~PythonQtShell_binaryFileWidget();
606 ~PythonQtShell_abstractBinFileWidget();
649 607
650 608 virtual void actionEvent(QActionEvent* arg__1);
651 609 virtual void changeEvent(QEvent* arg__1);
@@ -684,7 +642,9 virtual bool nativeEvent(const QByteArr
684 642 virtual QPaintEngine* paintEngine() const;
685 643 virtual void paintEvent(QPaintEvent* arg__1);
686 644 virtual QPaintDevice* redirected(QPoint* offset) const;
645 virtual void reloadFile();
687 646 virtual void resizeEvent(QResizeEvent* arg__1);
647 virtual void setFile(abstractBinFile* file);
688 648 virtual QPainter* sharedPainter() const;
689 649 virtual void showEvent(QShowEvent* arg__1);
690 650 virtual QSize sizeHint() const;
@@ -695,12 +655,102 virtual void wheelEvent(QWheelEvent* ar
695 655 PythonQtInstanceWrapper* _wrapper;
696 656 };
697 657
658 class PythonQtWrapper_abstractBinFileWidget : public QObject
659 { Q_OBJECT
660 public:
661 public slots:
662 abstractBinFileWidget* new_abstractBinFileWidget(QWidget* parent = 0);
663 void delete_abstractBinFileWidget(abstractBinFileWidget* obj) { delete obj; }
664 };
665
666
667
668
669
670 class PythonQtShell_binaryFile : public binaryFile
671 {
672 public:
673 PythonQtShell_binaryFile():binaryFile(),_wrapper(NULL) {};
674 PythonQtShell_binaryFile(const QString& File):binaryFile(File),_wrapper(NULL) {};
675 PythonQtShell_binaryFile(const QStringList& Files):binaryFile(Files),_wrapper(NULL) {};
676
677 ~PythonQtShell_binaryFile();
678
679 virtual int closeFile();
680 virtual QList<codeFragment* > getFragments();
681 virtual bool isopened();
682 virtual bool openFile(const QString& File);
683 virtual bool toBinary(const QString& fileName);
684 virtual bool toSrec(const QString& fileName);
685
686 PythonQtInstanceWrapper* _wrapper;
687 };
688
689 class PythonQtPublicPromoter_binaryFile : public binaryFile
690 { public:
691 inline int promoted_closeFile() { return binaryFile::closeFile(); }
692 inline QList<codeFragment* > promoted_getFragments() { return binaryFile::getFragments(); }
693 inline bool promoted_isopened() { return binaryFile::isopened(); }
694 inline bool promoted_openFile(const QString& File) { return binaryFile::openFile(File); }
695 inline bool promoted_toBinary(const QString& fileName) { return binaryFile::toBinary(fileName); }
696 inline bool promoted_toSrec(const QString& fileName) { return binaryFile::toSrec(fileName); }
697 };
698
699 class PythonQtWrapper_binaryFile : public QObject
700 { Q_OBJECT
701 public:
702 public slots:
703 binaryFile* new_binaryFile();
704 binaryFile* new_binaryFile(const QString& File);
705 binaryFile* new_binaryFile(const QStringList& Files);
706 void delete_binaryFile(binaryFile* obj) { delete obj; }
707 int closeFile(binaryFile* theWrappedObject);
708 codeFragment* getFragment(binaryFile* theWrappedObject, int index);
709 int getFragmentAddress(binaryFile* theWrappedObject, int index);
710 bool getFragmentData(binaryFile* theWrappedObject, int index, char** buffer);
711 QString getFragmentHeader(binaryFile* theWrappedObject, int index);
712 int getFragmentSize(binaryFile* theWrappedObject, int index);
713 QList<codeFragment* > getFragments(binaryFile* theWrappedObject);
714 int getFragmentsCount(binaryFile* theWrappedObject);
715 bool isopened(binaryFile* theWrappedObject);
716 bool openFile(binaryFile* theWrappedObject, const QString& File);
717 bool openFiles(binaryFile* theWrappedObject, const QStringList& Files);
718 bool static_binaryFile_toBinary(QList<codeFragment* > fragments, const QString& File);
719 bool toBinary(binaryFile* theWrappedObject, const QString& fileName);
720 bool toSrec(binaryFile* theWrappedObject, const QString& fileName);
721 };
722
723
724
725
726
727 class PythonQtShell_binaryFileWidget : public binaryFileWidget
728 {
729 public:
730 PythonQtShell_binaryFileWidget(QWidget* parent = 0):binaryFileWidget(parent),_wrapper(NULL) {};
731
732 ~PythonQtShell_binaryFileWidget();
733
734 virtual void reloadFile();
735 virtual void setFile(abstractBinFile* file);
736
737 PythonQtInstanceWrapper* _wrapper;
738 };
739
740 class PythonQtPublicPromoter_binaryFileWidget : public binaryFileWidget
741 { public:
742 inline void promoted_reloadFile() { binaryFileWidget::reloadFile(); }
743 inline void promoted_setFile(abstractBinFile* file) { binaryFileWidget::setFile(file); }
744 };
745
698 746 class PythonQtWrapper_binaryFileWidget : public QObject
699 747 { Q_OBJECT
700 748 public:
701 749 public slots:
702 750 binaryFileWidget* new_binaryFileWidget(QWidget* parent = 0);
703 751 void delete_binaryFileWidget(binaryFileWidget* obj) { delete obj; }
752 void reloadFile(binaryFileWidget* theWrappedObject);
753 void setFile(binaryFileWidget* theWrappedObject, abstractBinFile* file);
704 754 };
705 755
706 756
@@ -747,60 +797,24 public:
747 797
748 798 ~PythonQtShell_elfFileWidget();
749 799
750 virtual void actionEvent(QActionEvent* arg__1);
751 virtual void changeEvent(QEvent* arg__1);
752 virtual void childEvent(QChildEvent* arg__1);
753 virtual void closeEvent(QCloseEvent* arg__1);
754 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
755 virtual void customEvent(QEvent* arg__1);
756 virtual int devType() const;
757 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
758 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
759 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
760 virtual void dropEvent(QDropEvent* arg__1);
761 virtual void enterEvent(QEvent* arg__1);
762 virtual bool event(QEvent* arg__1);
763 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
764 virtual void focusInEvent(QFocusEvent* arg__1);
765 virtual bool focusNextPrevChild(bool next);
766 virtual void focusOutEvent(QFocusEvent* arg__1);
767 virtual bool hasHeightForWidth() const;
768 virtual int heightForWidth(int arg__1) const;
769 virtual void hideEvent(QHideEvent* arg__1);
770 virtual void initPainter(QPainter* painter) const;
771 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
772 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
773 virtual void keyPressEvent(QKeyEvent* arg__1);
774 virtual void keyReleaseEvent(QKeyEvent* arg__1);
775 virtual void leaveEvent(QEvent* arg__1);
776 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
777 virtual QSize minimumSizeHint() const;
778 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
779 virtual void mouseMoveEvent(QMouseEvent* arg__1);
780 virtual void mousePressEvent(QMouseEvent* arg__1);
781 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
782 virtual void moveEvent(QMoveEvent* arg__1);
783 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
784 virtual QPaintEngine* paintEngine() const;
785 virtual void paintEvent(QPaintEvent* arg__1);
786 virtual QPaintDevice* redirected(QPoint* offset) const;
787 virtual void resizeEvent(QResizeEvent* arg__1);
788 virtual QPainter* sharedPainter() const;
789 virtual void showEvent(QShowEvent* arg__1);
790 virtual QSize sizeHint() const;
791 virtual void tabletEvent(QTabletEvent* arg__1);
792 virtual void timerEvent(QTimerEvent* arg__1);
793 virtual void wheelEvent(QWheelEvent* arg__1);
800 virtual void reloadFile();
801 virtual void setFile(abstractBinFile* file);
794 802
795 803 PythonQtInstanceWrapper* _wrapper;
796 804 };
797 805
806 class PythonQtPublicPromoter_elfFileWidget : public elfFileWidget
807 { public:
808 inline void promoted_reloadFile() { elfFileWidget::reloadFile(); }
809 };
810
798 811 class PythonQtWrapper_elfFileWidget : public QObject
799 812 { Q_OBJECT
800 813 public:
801 814 public slots:
802 815 elfFileWidget* new_elfFileWidget(QWidget* parent = 0);
803 816 void delete_elfFileWidget(elfFileWidget* obj) { delete obj; }
817 void reloadFile(elfFileWidget* theWrappedObject);
804 818 };
805 819
806 820
@@ -926,6 +940,8 virtual int closeFile();
926 940 virtual QList<codeFragment* > getFragments();
927 941 virtual bool isopened();
928 942 virtual bool openFile(const QString& File);
943 virtual bool toBinary(const QString& File);
944 virtual bool toSrec(const QString& File);
929 945
930 946 PythonQtInstanceWrapper* _wrapper;
931 947 };
@@ -936,6 +952,8 inline int promoted_closeFile() { retur
936 952 inline QList<codeFragment* > promoted_getFragments() { return srecFile::getFragments(); }
937 953 inline bool promoted_isopened() { return srecFile::isopened(); }
938 954 inline bool promoted_openFile(const QString& File) { return srecFile::openFile(File); }
955 inline bool promoted_toBinary(const QString& File) { return srecFile::toBinary(File); }
956 inline bool promoted_toSrec(const QString& File) { return srecFile::toSrec(File); }
939 957 };
940 958
941 959 class PythonQtWrapper_srecFile : public QObject
@@ -947,6 +965,7 srecFile* new_srecFile(const QString& F
947 965 srecFile* new_srecFile(const QStringList& Files);
948 966 void delete_srecFile(srecFile* obj) { delete obj; }
949 967 int closeFile(srecFile* theWrappedObject);
968 codeFragment* getFragment(srecFile* theWrappedObject, int index);
950 969 int getFragmentAddress(srecFile* theWrappedObject, int index);
951 970 bool getFragmentData(srecFile* theWrappedObject, int index, char** buffer);
952 971 QString getFragmentHeader(srecFile* theWrappedObject, int index);
@@ -959,7 +978,9 void delete_srecFile(srecFile* obj) { de
959 978 int lineCount(srecFile* theWrappedObject);
960 979 bool openFile(srecFile* theWrappedObject, const QString& File);
961 980 bool openFiles(srecFile* theWrappedObject, const QStringList& Files);
981 bool toBinary(srecFile* theWrappedObject, const QString& File);
962 982 bool static_srecFile_toSrec(QList<codeFragment* > fragments, const QString& File);
983 bool toSrec(srecFile* theWrappedObject, const QString& File);
963 984 };
964 985
965 986
@@ -973,60 +994,26 public:
973 994
974 995 ~PythonQtShell_srecFileWidget();
975 996
976 virtual void actionEvent(QActionEvent* arg__1);
977 virtual void changeEvent(QEvent* arg__1);
978 virtual void childEvent(QChildEvent* arg__1);
979 virtual void closeEvent(QCloseEvent* arg__1);
980 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
981 virtual void customEvent(QEvent* arg__1);
982 virtual int devType() const;
983 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
984 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
985 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
986 virtual void dropEvent(QDropEvent* arg__1);
987 virtual void enterEvent(QEvent* arg__1);
988 virtual bool event(QEvent* arg__1);
989 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
990 virtual void focusInEvent(QFocusEvent* arg__1);
991 virtual bool focusNextPrevChild(bool next);
992 virtual void focusOutEvent(QFocusEvent* arg__1);
993 virtual bool hasHeightForWidth() const;
994 virtual int heightForWidth(int arg__1) const;
995 virtual void hideEvent(QHideEvent* arg__1);
996 virtual void initPainter(QPainter* painter) const;
997 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
998 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
999 virtual void keyPressEvent(QKeyEvent* arg__1);
1000 virtual void keyReleaseEvent(QKeyEvent* arg__1);
1001 virtual void leaveEvent(QEvent* arg__1);
1002 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
1003 virtual QSize minimumSizeHint() const;
1004 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
1005 virtual void mouseMoveEvent(QMouseEvent* arg__1);
1006 virtual void mousePressEvent(QMouseEvent* arg__1);
1007 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
1008 virtual void moveEvent(QMoveEvent* arg__1);
1009 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
1010 virtual QPaintEngine* paintEngine() const;
1011 virtual void paintEvent(QPaintEvent* arg__1);
1012 virtual QPaintDevice* redirected(QPoint* offset) const;
1013 virtual void resizeEvent(QResizeEvent* arg__1);
1014 virtual QPainter* sharedPainter() const;
1015 virtual void showEvent(QShowEvent* arg__1);
1016 virtual QSize sizeHint() const;
1017 virtual void tabletEvent(QTabletEvent* arg__1);
1018 virtual void timerEvent(QTimerEvent* arg__1);
1019 virtual void wheelEvent(QWheelEvent* arg__1);
997 virtual void reloadFile();
998 virtual void setFile(abstractBinFile* file);
1020 999
1021 1000 PythonQtInstanceWrapper* _wrapper;
1022 1001 };
1023 1002
1003 class PythonQtPublicPromoter_srecFileWidget : public srecFileWidget
1004 { public:
1005 inline void promoted_reloadFile() { srecFileWidget::reloadFile(); }
1006 inline void promoted_setFile(abstractBinFile* file) { srecFileWidget::setFile(file); }
1007 };
1008
1024 1009 class PythonQtWrapper_srecFileWidget : public QObject
1025 1010 { Q_OBJECT
1026 1011 public:
1027 1012 public slots:
1028 1013 srecFileWidget* new_srecFileWidget(QWidget* parent = 0);
1029 1014 void delete_srecFileWidget(srecFileWidget* obj) { delete obj; }
1015 void reloadFile(srecFileWidget* theWrappedObject);
1016 void setFile(srecFileWidget* theWrappedObject, abstractBinFile* file);
1030 1017 };
1031 1018
1032 1019
Show file before | Show file after | Hide comments
@@ -12,15 +12,19 PythonQt::priv()->registerClass(&SocExpl
12 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(&abstractBinFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_abstractBinFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_abstractBinFile>, module, 0);
15 PythonQt::priv()->registerClass(&abstractBinFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_abstractBinFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_abstractBinFileWidget>, module, 0);
15 16 PythonQt::priv()->registerClass(&binaryFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_binaryFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_binaryFile>, module, 0);
16 17 PythonQt::self()->addParentClass("binaryFile", "abstractBinFile",PythonQtUpcastingOffset<binaryFile,abstractBinFile>());
17 18 PythonQt::priv()->registerClass(&binaryFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_binaryFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_binaryFileWidget>, module, 0);
19 PythonQt::self()->addParentClass("binaryFileWidget", "abstractBinFileWidget",PythonQtUpcastingOffset<binaryFileWidget,abstractBinFileWidget>());
18 20 PythonQt::priv()->registerCPPClass("codeFragment", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_codeFragment>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_codeFragment>, module, 0);
19 21 PythonQt::priv()->registerClass(&elfFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_elfFileWidget>, module, 0);
22 PythonQt::self()->addParentClass("elfFileWidget", "abstractBinFileWidget",PythonQtUpcastingOffset<elfFileWidget,abstractBinFileWidget>());
20 23 PythonQt::priv()->registerClass(&elfInfoWdgt::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfInfoWdgt>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_elfInfoWdgt>, module, 0);
21 24 PythonQt::priv()->registerCPPClass("elfparser", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfparser>, NULL, module, 0);
22 25 PythonQt::priv()->registerClass(&srecFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_srecFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_srecFile>, module, 0);
23 26 PythonQt::self()->addParentClass("srecFile", "abstractBinFile",PythonQtUpcastingOffset<srecFile,abstractBinFile>());
24 27 PythonQt::priv()->registerClass(&srecFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_srecFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_srecFileWidget>, module, 0);
28 PythonQt::self()->addParentClass("srecFileWidget", "abstractBinFileWidget",PythonQtUpcastingOffset<srecFileWidget,abstractBinFileWidget>());
25 29
26 30 }
Show file before | Show file after | Hide comments
@@ -33,6 +33,12
33 33 <include file-name="QObject" location="global"/>
34 34 </extra-includes>
35 35 </object-type>
36 <interface-type name="abstractBinFileWidget">
37 <extra-includes>
38 <include file-name="QWidget" location="global"/>
39 <include file-name="QObject" location="global"/>
40 </extra-includes>
41 </interface-type>
36 42 <object-type name="elfFileWidget">
37 43 <extra-includes>
38 44 <include file-name="QWidget" location="global"/>
Show file before | Show file after | Hide comments
@@ -21,6 +21,7
21 21 ----------------------------------------------------------------------------*/
22 22 #include "srecfile.h"
23 23 #include <QTextStream>
24 #include "binaryfile.h"
24 25
25 26 srecFile::srecFile()
26 27 {
@@ -48,13 +49,6 bool srecFile::openFile(const QString &F
48 49
49 50 bool srecFile::openFiles(const QStringList &Files)
50 51 {
51 this->p_fileNames.clear();
52 this->p_fileNames.append(Files);
53 for(int i=0;i<p_files.count();i++)
54 {
55 delete p_files.at(i);
56 }
57 this->p_files.clear();
58 52 for(int i=0;i<Files.count();i++)
59 53 {
60 54 this->p_isSrec=true;
@@ -81,7 +75,10 int srecFile::closeFile()
81 75 for(int i=0;i<p_files.count();i++)
82 76 {
83 77 delete p_files.at(i);
78 free(p_fragments.at(i)->data);
79 delete p_fragments.at(i);
84 80 }
81 p_fragments.clear();
85 82 p_files.clear();
86 83 p_fileName.clear();
87 84 return 0;
@@ -156,6 +153,16 bool srecFile::toSrec(QList<codeFragment
156 153 return false;
157 154 }
158 155
156 bool srecFile::toSrec(const QString &File)
157 {
158 return toSrec(p_fragments,File);
159 }
160
161 bool srecFile::toBinary(const QString &File)
162 {
163 return binaryFile::toBinary(p_fragments,File);
164 }
165
159 166 int srecFile::lineCount()
160 167 {
161 168 return p_lineCount;
@@ -184,6 +191,15 int srecFile::getFragmentSize(int index)
184 191 return 0;
185 192 }
186 193
194 codeFragment *srecFile::getFragment(int index)
195 {
196 if((index < p_fragments.count()) && (index>=0))
197 {
198 return p_fragments.at(index);
199 }
200 return NULL;
201 }
202
187 203 QString srecFile::getFragmentHeader(int index)
188 204 {
189 205 if((index < p_fragments.count()) && (index>=0))
Show file before | Show file after | Hide comments
@@ -41,10 +41,13 public:
41 41 int closeFile();
42 42 QList<codeFragment*> getFragments();
43 43 static bool toSrec(QList<codeFragment*> fragments,const QString& File);
44 bool toSrec(const QString &File);
45 bool toBinary(const QString& File);
44 46 int lineCount();
45 47 int getFragmentsCount();
46 48 int getFragmentAddress(int index);
47 49 int getFragmentSize(int index);
50 codeFragment *getFragment(int index);
48 51 QString getFragmentHeader(int index);
49 52 bool getFragmentData(int index, char **buffer);
50 53
Show file before | Show file after | Hide comments
@@ -23,14 +23,22
23 23 #include "ui_srecfilewidget.h"
24 24 #include <QTableWidgetItem>
25 25 #include <qtablewidgetintitem.h>
26 #include <QtWidgets/QFileDialog>
27 #include "binaryfile.h"
26 28
27 29 srecFileWidget::srecFileWidget(QWidget *parent) :
28 QWidget(parent),
30 abstractBinFileWidget(parent),
29 31 ui(new Ui::srecFileWidget)
30 32 {
31 33 ui->setupUi(this);
32 34 connect(this->ui->fragmentsList,SIGNAL(cellActivated(int,int)),this,SLOT(recordCellActivated(int,int)));
33 35 this->setWindowTitle("SocExplorer SREC viewer");
36 exportToSREC_action = new QAction(tr("Export to SREC"),this);
37 exportToBIN_action = new QAction(tr("Export to Binary"),this);
38 this->ui->fragmentsList->addAction(exportToBIN_action);
39 this->ui->fragmentsList->addAction(exportToSREC_action);
40 connect(this->exportToBIN_action,SIGNAL(triggered()),this,SLOT(exportToBIN()));
41 connect(this->exportToSREC_action,SIGNAL(triggered()),this,SLOT(exportToSREC()));
34 42 }
35 43
36 44 srecFileWidget::~srecFileWidget()
@@ -38,16 +46,16 srecFileWidget::~srecFileWidget()
38 46 delete ui;
39 47 }
40 48
41 void srecFileWidget::updatSrecFile(srecFile *file)
49 void srecFileWidget::setFile(abstractBinFile *file)
42 50 {
43 this->p_srec = file;
51 this->p_srec = (srecFile*)file;
44 52 if(p_srec->isopened() && p_srec->isSREC())
45 53 {
46 updateRecords();
54 reloadFile();
47 55 }
48 56 }
49 57
50 void srecFileWidget::updateRecords()
58 void srecFileWidget::reloadFile()
51 59 {
52 60 this->ui->fragmentsList->clear();
53 61 this->ui->fragmentsList->setRowCount(p_srec->getFragmentsCount());
@@ -88,4 +96,49 void srecFileWidget::recordCellActivated
88 96
89 97 }
90 98
99 void srecFileWidget::exportToSREC()
100 {
101 QList<codeFragment *> SelectedFragmentsList=getSelectedFragments();
102 if(SelectedFragmentsList.count()>0)
103 {
104 QString fileName = QFileDialog::getSaveFileName(this, tr("Save File"),
105 NULL,
106 tr("SREC Files (*.srec)"));
107 if(!fileName.isEmpty())
108 {
109 srecFile::toSrec(SelectedFragmentsList,fileName);
110 }
111 }
112 }
91 113
114 void srecFileWidget::exportToBIN()
115 {
116 QList<codeFragment *> SelectedFragmentsList=getSelectedFragments();
117 if(SelectedFragmentsList.count()>0)
118 {
119 QString fileName = QFileDialog::getSaveFileName(this, tr("Save File"),
120 NULL,
121 tr("Binary Files (*.bin)"));
122 if(!fileName.isEmpty())
123 {
124 binaryFile::toBinary(SelectedFragmentsList,fileName);
125 }
126 }
127 }
128
129 QList<codeFragment *> srecFileWidget::getSelectedFragments()
130 {
131 QList<codeFragment *> SelectedFragmentsList;
132 QList<QTableWidgetItem*> items = this->ui->fragmentsList->selectedItems();
133 for(int i=0;i<items.count();i++)
134 {
135 codeFragment * fragment = p_srec->getFragment(items.at(i)->row());
136 if(!SelectedFragmentsList.contains(fragment))
137 {
138 SelectedFragmentsList.append(fragment);
139 }
140 }
141 return SelectedFragmentsList;
142 }
143
144
Show file before | Show file after | Hide comments
@@ -24,12 +24,13
24 24
25 25 #include <QWidget>
26 26 #include "srecfile.h"
27 #include <QAction>
27 28
28 29 namespace Ui {
29 30 class srecFileWidget;
30 31 }
31 32
32 class srecFileWidget : public QWidget
33 class srecFileWidget : public abstractBinFileWidget
33 34 {
34 35 Q_OBJECT
35 36
@@ -38,15 +39,20 public:
38 39 ~srecFileWidget();
39 40
40 41 public slots:
41 void updatSrecFile(srecFile* file);
42 void updateRecords();
42 void setFile(abstractBinFile* file);
43 void reloadFile();
43 44
44 45 private slots:
45 46 void recordCellActivated(int row, int column);
47 void exportToSREC();
48 void exportToBIN();
46 49
47 50 private:
51 QList<codeFragment *> getSelectedFragments();
48 52 Ui::srecFileWidget *ui;
49 53 srecFile* p_srec;
54 QAction* exportToSREC_action;
55 QAction* exportToBIN_action;
50 56 };
51 57
52 58 #endif // SRECFILEWIDGET_H
Show file before | Show file after | Hide comments
@@ -43,6 +43,9
43 43 <layout class="QVBoxLayout" name="verticalLayout_2">
44 44 <item>
45 45 <widget class="QTableWidget" name="fragmentsList">
46 <property name="contextMenuPolicy">
47 <enum>Qt::ActionsContextMenu</enum>
48 </property>
46 49 <column>
47 50 <property name="text">
48 51 <string>Index</string>
General Comments 0
You need to be logged in to leave comments. Login now