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