##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » SocExplorer
RSS
SREC File parser working....
Jeandet Alexis -
r45:c6b44a3b51fa default
parent child
Show More
Show file before | Show file after | Hide comments
@@ -0,0 +1,68
1 #include "srecfilewidget.h"
2 #include "ui_srecfilewidget.h"
3 #include <QTableWidgetItem>
4 #include <qtablewidgetintitem.h>
5
6 srecFileWidget::srecFileWidget(QWidget *parent) :
7 QWidget(parent),
8 ui(new Ui::srecFileWidget)
9 {
10 ui->setupUi(this);
11 connect(this->ui->fragmentsList,SIGNAL(cellActivated(int,int)),this,SLOT(recordCellActivated(int,int)));
12 }
13
14 srecFileWidget::~srecFileWidget()
15 {
16 delete ui;
17 }
18
19 void srecFileWidget::updatSrecFile(srecFile *file)
20 {
21 this->p_srec = file;
22 if(p_srec->isopened() && p_srec->isSREC())
23 {
24 updateRecords();
25 }
26 }
27
28 void srecFileWidget::updateRecords()
29 {
30 this->ui->fragmentsList->clear();
31 this->ui->fragmentsList->setRowCount(p_srec->getFragmentsCount());
32 this->ui->fragmentsList->setHorizontalHeaderLabels(QStringList()<<"Index"<<"Address"<<"Size"<<"Header");
33 for(int i=0;i<p_srec->getFragmentsCount();i++)
34 {
35 QTableWidgetItem *newItem = (QTableWidgetItem*)new QTableWidgetIntItem(QString("%1").arg(i),DecimalItem);
36 newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
37 this->ui->fragmentsList->setItem(i, 0, newItem);
38
39 newItem = (QTableWidgetItem*)new QTableWidgetIntItem(QString("0x%1").arg(p_srec->getFragmentAddress(i),8,16).replace(" ","0"),HexaDecimalItem);
40 newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
41 this->ui->fragmentsList->setItem(i, 1, newItem);
42
43 newItem = (QTableWidgetItem*)new QTableWidgetIntItem(QString("%1").arg(p_srec->getFragmentSize(i)),DecimalItem);
44 newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
45 this->ui->fragmentsList->setItem(i, 2, newItem);
46
47 newItem = new QTableWidgetItem(p_srec->getFragmentHeader(i));
48 newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
49 this->ui->fragmentsList->setItem(i, 3, newItem);
50
51 }
52 this->ui->fragmentsList->resizeColumnsToContents();
53 }
54
55 void srecFileWidget::recordCellActivated(int row, int column)
56 {
57 Q_UNUSED(column)
58 char* buff=NULL;
59 int index = this->ui->fragmentsList->item(row,0)->text().toInt();
60 if(index!=-1)
61 {
62 this->p_srec->getFragmentData(index,&buff);
63 this->ui->fragmentHexView->setData(QByteArray(buff,this->p_srec->getFragmentSize(index)));
64 }
65
66 }
67
68
Show file before | Show file after | Hide comments
@@ -0,0 +1,31
1 #ifndef SRECFILEWIDGET_H
2 #define SRECFILEWIDGET_H
3
4 #include <QWidget>
5 #include "srecfile.h"
6
7 namespace Ui {
8 class srecFileWidget;
9 }
10
11 class srecFileWidget : public QWidget
12 {
13 Q_OBJECT
14
15 public:
16 explicit srecFileWidget(QWidget *parent = 0);
17 ~srecFileWidget();
18
19 public slots:
20 void updatSrecFile(srecFile* file);
21 void updateRecords();
22
23 private slots:
24 void recordCellActivated(int row, int column);
25
26 private:
27 Ui::srecFileWidget *ui;
28 srecFile* p_srec;
29 };
30
31 #endif // SRECFILEWIDGET_H
Show file before | Show file after | Hide comments
@@ -0,0 +1,81
1 <?xml version="1.0" encoding="UTF-8"?>
2 <ui version="4.0">
3 <class>srecFileWidget</class>
4 <widget class="QWidget" name="srecFileWidget">
5 <property name="geometry">
6 <rect>
7 <x>0</x>
8 <y>0</y>
9 <width>740</width>
10 <height>516</height>
11 </rect>
12 </property>
13 <property name="windowTitle">
14 <string>Form</string>
15 </property>
16 <layout class="QGridLayout" name="gridLayout">
17 <item row="0" column="1">
18 <widget class="QGroupBox" name="groupBox_2">
19 <property name="title">
20 <string>SREC records list</string>
21 </property>
22 <layout class="QVBoxLayout" name="verticalLayout_2">
23 <item>
24 <widget class="QTableWidget" name="fragmentsList">
25 <column>
26 <property name="text">
27 <string>Index</string>
28 </property>
29 </column>
30 <column>
31 <property name="text">
32 <string>Address</string>
33 </property>
34 </column>
35 <column>
36 <property name="text">
37 <string>Size</string>
38 </property>
39 </column>
40 <column>
41 <property name="text">
42 <string>Header</string>
43 </property>
44 </column>
45 </widget>
46 </item>
47 </layout>
48 </widget>
49 </item>
50 <item row="0" column="0">
51 <widget class="QGroupBox" name="groupBox">
52 <property name="title">
53 <string>Hexadecimal Viewer</string>
54 </property>
55 <layout class="QVBoxLayout" name="verticalLayout">
56 <item>
57 <widget class="QHexEdit" name="fragmentHexView" native="true">
58 <property name="minimumSize">
59 <size>
60 <width>256</width>
61 <height>0</height>
62 </size>
63 </property>
64 </widget>
65 </item>
66 </layout>
67 </widget>
68 </item>
69 </layout>
70 </widget>
71 <customwidgets>
72 <customwidget>
73 <class>QHexEdit</class>
74 <extends>QWidget</extends>
75 <header location="global">qhexedit.h</header>
76 <container>1</container>
77 </customwidget>
78 </customwidgets>
79 <resources/>
80 <connections/>
81 </ui>
Show file before | Show file after | Hide comments
@@ -1,14 +1,15
1 #include <QtCore/QObject>
1 #include <QtCore/QObject>
2 #include <QtWidgets/QtWidgets>
2 #include <QtWidgets/QtWidgets>
3 #include "qhexspinbox.h"
3 #include "qhexspinbox.h"
4 #include "memsizewdgt.h"
4 #include "memsizewdgt.h"
5 #include "qhexedit/qhexedit.h"
5 #include "qhexedit/qhexedit.h"
6 #include "SocExplorerPlot.h"
6 #include "SocExplorerPlot.h"
7 #include "tcp_terminal_client.h"
7 #include "tcp_terminal_client.h"
8 #include "elf/elfparser.h"
8 #include "elf/elfparser.h"
9 #include "abstractexecfile.h"
9 #include "abstractbinfile.h"
10 #include "elf/elffile.h"
10 #include "elf/elffile.h"
11 #include "elf/elffilewidget.h"
11 #include "elf/elffilewidget.h"
12 #include "elf/elfinfowdgt.h"
12 #include "elf/elfinfowdgt.h"
13 #include "QCustomPlot/qcustomplot.h"
13 #include "QCustomPlot/qcustomplot.h"
14 #include "srec/srecfile.h"
14 #include "srec/srecfile.h"
15 #include "srec/srecfilewidget.h"
Show file before | Show file after | Hide comments
@@ -1,30 +1,30
1 /*------------------------------------------------------------------------------
1 /*------------------------------------------------------------------------------
2 -- This file is a part of the SocExplorer Software
2 -- This file is a part of the SocExplorer Software
3 -- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
3 -- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
4 --
4 --
5 -- This program is free software; you can redistribute it and/or modify
5 -- This program is free software; you can redistribute it and/or modify
6 -- it under the terms of the GNU General Public License as published by
6 -- it under the terms of the GNU General Public License as published by
7 -- the Free Software Foundation; either version 2 of the License, or
7 -- the Free Software Foundation; either version 2 of the License, or
8 -- (at your option) any later version.
8 -- (at your option) any later version.
9 --
9 --
10 -- This program is distributed in the hope that it will be useful,
10 -- This program is distributed in the hope that it will be useful,
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 -- GNU General Public License for more details.
13 -- GNU General Public License for more details.
14 --
14 --
15 -- You should have received a copy of the GNU General Public License
15 -- You should have received a copy of the GNU General Public License
16 -- along with this program; if not, write to the Free Software
16 -- along with this program; if not, write to the Free Software
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 -------------------------------------------------------------------------------*/
18 -------------------------------------------------------------------------------*/
19 /*-- Author : Alexis Jeandet
19 /*-- Author : Alexis Jeandet
20 -- Mail : alexis.jeandet@member.fsf.org
20 -- Mail : alexis.jeandet@member.fsf.org
21 ----------------------------------------------------------------------------*/
21 ----------------------------------------------------------------------------*/
22 #include "abstractexecfile.h"
22 #include "abstractbinfile.h"
23
23
24
24
25 codeFragment::codeFragment()
25 codeFragment::codeFragment()
26 {
26 {
27 data = NULL;
27 data = NULL;
28 size = 0;
28 size = 0;
29 address = 0;
29 address = 0;
30 }
30 }
Show file before | Show file after | Hide comments
@@ -1,51 +1,52
1 /*------------------------------------------------------------------------------
1 /*------------------------------------------------------------------------------
2 -- This file is a part of the SocExplorer Software
2 -- This file is a part of the SocExplorer Software
3 -- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
3 -- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
4 --
4 --
5 -- This program is free software; you can redistribute it and/or modify
5 -- This program is free software; you can redistribute it and/or modify
6 -- it under the terms of the GNU General Public License as published by
6 -- it under the terms of the GNU General Public License as published by
7 -- the Free Software Foundation; either version 2 of the License, or
7 -- the Free Software Foundation; either version 2 of the License, or
8 -- (at your option) any later version.
8 -- (at your option) any later version.
9 --
9 --
10 -- This program is distributed in the hope that it will be useful,
10 -- This program is distributed in the hope that it will be useful,
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 -- GNU General Public License for more details.
13 -- GNU General Public License for more details.
14 --
14 --
15 -- You should have received a copy of the GNU General Public License
15 -- You should have received a copy of the GNU General Public License
16 -- along with this program; if not, write to the Free Software
16 -- along with this program; if not, write to the Free Software
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 -------------------------------------------------------------------------------*/
18 -------------------------------------------------------------------------------*/
19 /*-- Author : Alexis Jeandet
19 /*-- Author : Alexis Jeandet
20 -- Mail : alexis.jeandet@member.fsf.org
20 -- Mail : alexis.jeandet@member.fsf.org
21 ----------------------------------------------------------------------------*/
21 ----------------------------------------------------------------------------*/
22 #ifndef ABSTRACTEXECFILE_H
22 #ifndef ABSTRACTBINFILE_H
23 #define ABSTRACTEXECFILE_H
23 #define ABSTRACTBINFILE_H
24
24
25 #include <QtCore/QObject>
25 #include <QtCore/QObject>
26
26
27 class codeFragment
27 class codeFragment
28 {
28 {
29 public:
29 public:
30 codeFragment();
30 codeFragment();
31 codeFragment(char* data, quint32 size, quint32 address):data(data),size(size),address(address){}
31 codeFragment(char* data, quint64 size, quint64 address):data(data),size(size),address(address){}
32 QString header;
32 char* data;
33 char* data;
33 quint32 size;
34 quint64 size;
34 quint32 address;
35 quint64 address;
35 };
36 };
36
37
37 class abstractExecFile : public QObject
38 class abstractBinFile : public QObject
38 {
39 {
39 Q_OBJECT
40 Q_OBJECT
40 public:
41 public:
41 // virtual abstractExecFile()=0;
42 // virtual abstractExecFile()=0;
42 virtual bool openFile(const QString& File)=0;
43 virtual bool openFile(const QString& File)=0;
43 virtual bool isopened()=0;
44 virtual bool isopened()=0;
44 virtual int closeFile()=0;
45 virtual int closeFile()=0;
45 virtual QList<codeFragment*> getFragments()=0;
46 virtual QList<codeFragment*> getFragments()=0;
46
47
47 protected:
48 protected:
48 QString p_fileName;
49 QString p_fileName;
49 };
50 };
50
51
51 #endif // ABSTRACTEXECFILE_H
52 #endif // ABSTRACTBINFILE_H
Show file before | Show file after | Hide comments
@@ -1,123 +1,128
1 SOCEXPLORER_ROOT = \"$${PWD}/../..\"
1 SOCEXPLORER_ROOT = \"$${PWD}/../..\"
2 include($${PWD}/../../build_cfg/socexplorer.pri)
2 include($${PWD}/../../build_cfg/socexplorer.pri)
3 include($${PWD}/lppserial/lppserial.pri)
3 include($${PWD}/lppserial/lppserial.pri)
4
4
5 TEMPLATE = lib
5 TEMPLATE = lib
6 TARGET = socexplorercommon$${DEBUG_EXT}
6 TARGET = socexplorercommon$${DEBUG_EXT}
7
7
8 win32:CONFIG += dll
8 win32:CONFIG += dll
9 win32:CONFIG -= static
9 win32:CONFIG -= static
10
10
11 win32:INCLUDEPATH += $${PWD}/elf/libelfWin32/include
11 win32:INCLUDEPATH += $${PWD}/elf/libelfWin32/include
12 win32:INCLUDEPATH += $${PWD}/elf/libelfWin32/include/libelf
12 win32:INCLUDEPATH += $${PWD}/elf/libelfWin32/include/libelf
13 win32:DEFINES+=_ELF_WINDOWS_
13 win32:DEFINES+=_ELF_WINDOWS_
14 DEFINES+=RS232_debug
14 DEFINES+=RS232_debug
15
15
16 win32:LIBS += $${PWD}/elf/libelfWin32/bin/libelf.a
16 win32:LIBS += $${PWD}/elf/libelfWin32/bin/libelf.a
17 unix:LIBS += -lelf
17 unix:LIBS += -lelf
18
18
19 QMAKE_LFLAGS_RELEASE += --enable-auto-import
19 QMAKE_LFLAGS_RELEASE += --enable-auto-import
20 QMAKE_LFLAGS_DEBUG += --enable-auto-import
20 QMAKE_LFLAGS_DEBUG += --enable-auto-import
21
21
22 target.path = $$[QT_INSTALL_LIBS]
22 target.path = $$[QT_INSTALL_LIBS]
23 isEmpty(target.path) {
23 isEmpty(target.path) {
24 error(can\'t get QT_INSTALL_LIBS)
24 error(can\'t get QT_INSTALL_LIBS)
25 }
25 }
26
26
27 header.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common
27 header.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common
28 header.files = \
28 header.files = \
29 memsizewdgt.h \
29 memsizewdgt.h \
30 qhexspinbox.h \
30 qhexspinbox.h \
31 qsvgicon.h \
31 qsvgicon.h \
32 qhexedit/qhexedit_p.h \
32 qhexedit/qhexedit_p.h \
33 qhexedit/qhexedit.h \
33 qhexedit/qhexedit.h \
34 qhexedit/xbytearray.h \
34 qhexedit/xbytearray.h \
35 QCustomPlot/qcustomplot.h \
35 QCustomPlot/qcustomplot.h \
36 SocExplorerPlot.h \
36 SocExplorerPlot.h \
37 tcp_terminal_client.h \
37 tcp_terminal_client.h \
38 elf/elfinfowdgt.h \
38 elf/elfinfowdgt.h \
39 elf/elfparser.h \
39 elf/elfparser.h \
40 elf/elffile.h \
40 elf/elffile.h \
41 elf/elffilewidget.h \
41 elf/elffilewidget.h \
42 qipdialogbox.h \
42 qipdialogbox.h \
43 lppserial/src/RS232.h \
43 lppserial/src/RS232.h \
44 qtablewidgetintitem.h \
44 qtablewidgetintitem.h \
45 srec/srecfile.h
45 srec/srecfile.h \
46 srec/srecfilewidget.h \
47 abstractbinfile.cpp
46
48
47 win32{
49 win32{
48 elfheader.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common/libelf
50 elfheader.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common/libelf
49 elfheader.files += \
51 elfheader.files += \
50 elf/libelfWin32/include/libelf/byteswap.h \
52 elf/libelfWin32/include/libelf/byteswap.h \
51 elf/libelfWin32/include/libelf/errors.h \
53 elf/libelfWin32/include/libelf/errors.h \
52 elf/libelfWin32/include/libelf/gelf.h \
54 elf/libelfWin32/include/libelf/gelf.h \
53 elf/libelfWin32/include/libelf/nlist.h \
55 elf/libelfWin32/include/libelf/nlist.h \
54 elf/libelfWin32/include/libelf/sys_elf.h \
56 elf/libelfWin32/include/libelf/sys_elf.h \
55 elf/libelfWin32/include/libelf/verneed.h \
57 elf/libelfWin32/include/libelf/verneed.h \
56 elf/libelfWin32/include/libelf/elf_repl.h \
58 elf/libelfWin32/include/libelf/elf_repl.h \
57 elf/libelfWin32/include/libelf/ext_types.h \
59 elf/libelfWin32/include/libelf/ext_types.h \
58 elf/libelfWin32/include/libelf/libelf.h \
60 elf/libelfWin32/include/libelf/libelf.h \
59 elf/libelfWin32/include/libelf/private.h \
61 elf/libelfWin32/include/libelf/private.h \
60 elf/libelfWin32/include/libelf/verdef.h
62 elf/libelfWin32/include/libelf/verdef.h
61 INSTALLS += elfheader
63 INSTALLS += elfheader
62 }
64 }
63
65
64
66
65 isEmpty(header.path) {
67 isEmpty(header.path) {
66 error(can\'t get QT_INSTALL_HEADERS)
68 error(can\'t get QT_INSTALL_HEADERS)
67 }
69 }
68
70
69 INSTALLS += target header
71 INSTALLS += target header
70
72
71 INCLUDEPATH += QCustomPlot qhexedit
73 INCLUDEPATH += QCustomPlot qhexedit srec
72
74
73 HEADERS += \
75 HEADERS += \
74 memsizewdgt.h \
76 memsizewdgt.h \
75 qhexspinbox.h \
77 qhexspinbox.h \
76 qsvgicon.h \
78 qsvgicon.h \
77 qhexedit/qhexedit_p.h \
79 qhexedit/qhexedit_p.h \
78 qhexedit/qhexedit.h \
80 qhexedit/qhexedit.h \
79 qhexedit/xbytearray.h \
81 qhexedit/xbytearray.h \
80 qhexedit/commands.h \
82 qhexedit/commands.h \
81 QCustomPlot/qcustomplot.h \
83 QCustomPlot/qcustomplot.h \
82 tcp_terminal_client.h \
84 tcp_terminal_client.h \
83 elf/elfinfowdgt.h \
85 elf/elfinfowdgt.h \
84 elf/elfparser.h \
86 elf/elfparser.h \
85 abstractexecfile.h \
86 elf/elffile.h \
87 elf/elffile.h \
87 qipdialogbox.h \
88 qipdialogbox.h \
88 PySocExplorer.h \
89 PySocExplorer.h \
89 SocExplorerPlot.h \
90 SocExplorerPlot.h \
90 elf/elffilewidget.h \
91 elf/elffilewidget.h \
91 qtablewidgetintitem.h \
92 qtablewidgetintitem.h \
92 srec/srecfile.h
93 srec/srecfile.h \
94 srec/srecfilewidget.h \
95 abstractbinfile.h
93
96
94
97
95 SOURCES += \
98 SOURCES += \
96 memsizewdgt.cpp \
99 memsizewdgt.cpp \
97 qhexspinbox.cpp \
100 qhexspinbox.cpp \
98 qsvgicon.cpp \
101 qsvgicon.cpp \
99 qhexedit/qhexedit_p.cpp \
102 qhexedit/qhexedit_p.cpp \
100 qhexedit/qhexedit.cpp \
103 qhexedit/qhexedit.cpp \
101 qhexedit/xbytearray.cpp \
104 qhexedit/xbytearray.cpp \
102 qhexedit/commands.cpp \
105 qhexedit/commands.cpp \
103 QCustomPlot/qcustomplot.cpp \
106 QCustomPlot/qcustomplot.cpp \
104 tcp_terminal_client.cpp \
107 tcp_terminal_client.cpp \
105 elf/elfinfowdgt.cpp \
108 elf/elfinfowdgt.cpp \
106 elf/elfparser.cpp \
109 elf/elfparser.cpp \
107 abstractexecfile.cpp \
108 elf/elffile.cpp \
110 elf/elffile.cpp \
109 qipdialogbox.cpp \
111 qipdialogbox.cpp \
110 SocExplorerPlot.cpp \
112 SocExplorerPlot.cpp \
111 elf/elffilewidget.cpp \
113 elf/elffilewidget.cpp \
112 qtablewidgetintitem.cpp \
114 qtablewidgetintitem.cpp \
113 srec/srecfile.cpp
115 srec/srecfile.cpp \
116 srec/srecfilewidget.cpp \
117 abstractbinfile.cpp
114
118
115 FORMS += \
119 FORMS += \
116 elf/elffilewidget.ui
120 elf/elffilewidget.ui \
121 srec/srecfilewidget.ui
117
122
118 OTHER_FILES += \
123 OTHER_FILES += \
119 ./pythongenerator.sh \
124 ./pythongenerator.sh \
120 ./pythonQtgeneratorCfg.txt
125 ./pythonQtgeneratorCfg.txt
121
126
122
127
123
128
Show file before | Show file after | Hide comments
@@ -1,1041 +1,1047
1 /*------------------------------------------------------------------------------
1 /*------------------------------------------------------------------------------
2 -- This file is a part of the SocExplorer Software
2 -- This file is a part of the SocExplorer Software
3 -- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
3 -- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
4 --
4 --
5 -- This program is free software; you can redistribute it and/or modify
5 -- This program is free software; you can redistribute it and/or modify
6 -- it under the terms of the GNU General Public License as published by
6 -- it under the terms of the GNU General Public License as published by
7 -- the Free Software Foundation; either version 2 of the License, or
7 -- the Free Software Foundation; either version 2 of the License, or
8 -- (at your option) any later version.
8 -- (at your option) any later version.
9 --
9 --
10 -- This program is distributed in the hope that it will be useful,
10 -- This program is distributed in the hope that it will be useful,
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 -- GNU General Public License for more details.
13 -- GNU General Public License for more details.
14 --
14 --
15 -- You should have received a copy of the GNU General Public License
15 -- You should have received a copy of the GNU General Public License
16 -- along with this program; if not, write to the Free Software
16 -- along with this program; if not, write to the Free Software
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 -------------------------------------------------------------------------------*/
18 -------------------------------------------------------------------------------*/
19 /*-- Author :
19 /*-- Author :
20 Alexis Jeandet
20 Alexis Jeandet
21 -- Mail :
21 -- Mail :
22 alexis.jeandet@member.fsf.org
22 alexis.jeandet@member.fsf.org
23 ----------------------------------------------------------------------------*/
23 ----------------------------------------------------------------------------*/
24 #include "elffile.h"
24 #include "elffile.h"
25 #include "srec/srecfile.h"
25
26
26 ElfFile::ElfFile()
27 ElfFile::ElfFile()
27 :abstractExecFile()
28 :abstractBinFile()
28 {
29 {
29 this->opened = false;
30 this->opened = false;
30 this->type_elf = false;
31 this->type_elf = false;
31 this->elfFile = NULL;
32 this->elfFile = NULL;
32 this->e = NULL;
33 this->e = NULL;
33 }
34 }
34
35
35 ElfFile::ElfFile(const QString &File)
36 ElfFile::ElfFile(const QString &File)
36 :abstractExecFile()
37 :abstractBinFile()
37 {
38 {
38 this->opened = false;
39 this->opened = false;
39 this->type_elf = false;
40 this->type_elf = false;
40 this->elfFile = NULL;
41 this->elfFile = NULL;
41 this->e = NULL;
42 this->e = NULL;
42 this->p_fileName = File;
43 this->p_fileName = File;
43 openFile(File);
44 openFile(File);
44 }
45 }
45
46
46 ElfFile::~ElfFile()
47 ElfFile::~ElfFile()
47 {
48 {
48 closeFile();
49 closeFile();
49 if(scn)free(scn);
50 if(scn)free(scn);
50 if(data)free(data);
51 if(data)free(data);
51 for(int i=0;i<this->sections.count();i++)
52 for(int i=0;i<this->sections.count();i++)
52 {
53 {
53 delete this->sections.at(i);
54 delete this->sections.at(i);
54 }
55 }
55 this->sections.clear();
56 this->sections.clear();
56 for(int i=0;i<this->Segments.count();i++)
57 for(int i=0;i<this->Segments.count();i++)
57 {
58 {
58 free(this->Segments.at(i));
59 free(this->Segments.at(i));
59 }
60 }
60 this->Segments.clear();
61 this->Segments.clear();
61 for(int i=0;i<symbols.count();i++)
62 for(int i=0;i<symbols.count();i++)
62 {
63 {
63 delete this->symbols.at(i);
64 delete this->symbols.at(i);
64 }
65 }
65 this->symbols.clear();
66 this->symbols.clear();
66 }
67 }
67
68
68 bool ElfFile::openFile(const QString &File)
69 bool ElfFile::openFile(const QString &File)
69 {
70 {
70 this->p_fileName = File;
71 this->p_fileName = File;
71 this->closeFile();
72 this->closeFile();
72 if(elf_version(EV_CURRENT)==EV_NONE)return 0;
73 if(elf_version(EV_CURRENT)==EV_NONE)return 0;
73 #ifdef _ELF_WINDOWS_
74 #ifdef _ELF_WINDOWS_
74 this->elfFile = open(File.toStdString().c_str(),O_RDONLY|O_BINARY ,0);
75 this->elfFile = open(File.toStdString().c_str(),O_RDONLY|O_BINARY ,0);
75 #else
76 #else
76 this->elfFile = open(File.toStdString().c_str(),O_RDONLY ,0);
77 this->elfFile = open(File.toStdString().c_str(),O_RDONLY ,0);
77 #endif
78 #endif
78 if(this->elfFile==NULL)return 0;
79 if(this->elfFile==NULL)return 0;
79 this->e = elf_begin(this->elfFile,ELF_C_READ,NULL);
80 this->e = elf_begin(this->elfFile,ELF_C_READ,NULL);
80 if(this->e==NULL)return 0;
81 if(this->e==NULL)return 0;
81 this->ek = elf_kind(this->e);
82 this->ek = elf_kind(this->e);
82 gelf_getehdr (this->e, &this->ehdr );
83 gelf_getehdr (this->e, &this->ehdr );
83 elf_getshdrstrndx (this->e, &this->shstrndx);
84 elf_getshdrstrndx (this->e, &this->shstrndx);
84 this->updateSegments();
85 this->updateSegments();
85 this->updateSections();
86 this->updateSections();
86 this->updateSymbols();
87 this->updateSymbols();
87 this->opened = true;
88 this->opened = true;
88 return 1;
89 return 1;
89 }
90 }
90
91
91 bool ElfFile::isopened()
92 bool ElfFile::isopened()
92 {
93 {
93 return this->opened;
94 return this->opened;
94 }
95 }
95
96
96 int ElfFile::closeFile()
97 int ElfFile::closeFile()
97 {
98 {
98 if(this->elfFile!=NULL)
99 if(this->elfFile!=NULL)
99 {
100 {
100 if(this->e!=NULL)
101 if(this->e!=NULL)
101 {
102 {
102 elf_end(this->e);
103 elf_end(this->e);
103 this->e = NULL;
104 this->e = NULL;
104 }
105 }
105 close(this->elfFile);
106 close(this->elfFile);
106 this->elfFile = NULL;
107 this->elfFile = NULL;
107 }
108 }
108 this->opened = false;
109 this->opened = false;
109 return 0;
110 return 0;
110 }
111 }
111
112
112
113
113 QList<codeFragment*> ElfFile::getFragments(QStringList fragmentList)
114 QList<codeFragment*> ElfFile::getFragments(QStringList fragmentList)
114 {
115 {
115 QList<codeFragment*> fragments;
116 QList<codeFragment*> fragments;
116 if (isopened())
117 if (isopened())
117 {
118 {
118 for(int i =0;i<fragmentList.count();i++)
119 for(int i =0;i<fragmentList.count();i++)
119 {
120 {
120 fragments.append(getFragment(fragmentList.at(i)));
121 fragments.append(getFragment(fragmentList.at(i)));
121 }
122 }
122 }
123 }
123 return fragments;
124 return fragments;
124 }
125 }
125
126
126 QList<codeFragment*> ElfFile::getFragments()
127 QList<codeFragment*> ElfFile::getFragments()
127 {
128 {
128 return getFragments(QStringList()<<".data"<<".text");
129 return getFragments(QStringList()<<".data"<<".text");
129 }
130 }
130
131
131 codeFragment *ElfFile::getFragment(const QString &name)
132 codeFragment *ElfFile::getFragment(const QString &name)
132 {
133 {
133 codeFragment* fragment= new codeFragment();
134 codeFragment* fragment= new codeFragment();
134 for(int i=0;i<getSectionCount();i++)
135 for(int i=0;i<getSectionCount();i++)
135 {
136 {
136 if(getSectionName(i) == name)
137 if(getSectionName(i) == name)
137 {
138 {
138 fragment->data =NULL;
139 fragment->data =NULL;
139 fragment->size = getSectionDatasz(i);
140 fragment->size = getSectionDatasz(i);
140 fragment->address = getSectionPaddr(i);
141 fragment->address = getSectionPaddr(i);
141 getSectionData(i,&fragment->data);
142 getSectionData(i,&fragment->data);
142 }
143 }
143 }
144 }
144
145 return fragment;
145 }
146 }
146
147
147
148
148
149
149
150
150
151
151
152
152
153
153 QString elfresolveMachine(Elf64_Half e_machine)
154 QString elfresolveMachine(Elf64_Half e_machine)
154 {
155 {
155 QString machineName;
156 QString machineName;
156 //Update from with bash script don't write it by yourself!
157 //Update from with bash script don't write it by yourself!
157 switch(e_machine)
158 switch(e_machine)
158 {
159 {
159 case EM_NONE:
160 case EM_NONE:
160 machineName = " No machine ";
161 machineName = " No machine ";
161 break;
162 break;
162 case EM_M32:
163 case EM_M32:
163 machineName = " AT&T WE 32100 ";
164 machineName = " AT&T WE 32100 ";
164 break;
165 break;
165 case EM_SPARC:
166 case EM_SPARC:
166 machineName = " SUN SPARC ";
167 machineName = " SUN SPARC ";
167 break;
168 break;
168 case EM_386:
169 case EM_386:
169 machineName = " Intel 80386 ";
170 machineName = " Intel 80386 ";
170 break;
171 break;
171 case EM_68K:
172 case EM_68K:
172 machineName = " Motorola m68k family ";
173 machineName = " Motorola m68k family ";
173 break;
174 break;
174 case EM_88K:
175 case EM_88K:
175 machineName = " Motorola m88k family ";
176 machineName = " Motorola m88k family ";
176 break;
177 break;
177 case EM_860:
178 case EM_860:
178 machineName = " Intel 80860 ";
179 machineName = " Intel 80860 ";
179 break;
180 break;
180 case EM_MIPS:
181 case EM_MIPS:
181 machineName = " MIPS R3000 big-endian ";
182 machineName = " MIPS R3000 big-endian ";
182 break;
183 break;
183 case EM_S370:
184 case EM_S370:
184 machineName = " IBM System/370 ";
185 machineName = " IBM System/370 ";
185 break;
186 break;
186 case EM_MIPS_RS3_LE:
187 case EM_MIPS_RS3_LE:
187 machineName = " MIPS R3000 little-endian ";
188 machineName = " MIPS R3000 little-endian ";
188 break;
189 break;
189 case EM_PARISC:
190 case EM_PARISC:
190 machineName = " HPPA ";
191 machineName = " HPPA ";
191 break;
192 break;
192 case EM_VPP500:
193 case EM_VPP500:
193 machineName = " Fujitsu VPP500 ";
194 machineName = " Fujitsu VPP500 ";
194 break;
195 break;
195 case EM_SPARC32PLUS:
196 case EM_SPARC32PLUS:
196 machineName = " Sun's \"v8plus\" ";
197 machineName = " Sun's \"v8plus\" ";
197 break;
198 break;
198 case EM_960:
199 case EM_960:
199 machineName = " Intel 80960 ";
200 machineName = " Intel 80960 ";
200 break;
201 break;
201 case EM_PPC:
202 case EM_PPC:
202 machineName = " PowerPC ";
203 machineName = " PowerPC ";
203 break;
204 break;
204 case EM_PPC64:
205 case EM_PPC64:
205 machineName = " PowerPC 64-bit ";
206 machineName = " PowerPC 64-bit ";
206 break;
207 break;
207 case EM_S390:
208 case EM_S390:
208 machineName = " IBM S390 ";
209 machineName = " IBM S390 ";
209 break;
210 break;
210 case EM_V800:
211 case EM_V800:
211 machineName = " NEC V800 series ";
212 machineName = " NEC V800 series ";
212 break;
213 break;
213 case EM_FR20:
214 case EM_FR20:
214 machineName = " Fujitsu FR20 ";
215 machineName = " Fujitsu FR20 ";
215 break;
216 break;
216 case EM_RH32:
217 case EM_RH32:
217 machineName = " TRW RH-32 ";
218 machineName = " TRW RH-32 ";
218 break;
219 break;
219 case EM_RCE:
220 case EM_RCE:
220 machineName = " Motorola RCE ";
221 machineName = " Motorola RCE ";
221 break;
222 break;
222 case EM_ARM:
223 case EM_ARM:
223 machineName = " ARM ";
224 machineName = " ARM ";
224 break;
225 break;
225 case EM_FAKE_ALPHA:
226 case EM_FAKE_ALPHA:
226 machineName = " Digital Alpha ";
227 machineName = " Digital Alpha ";
227 break;
228 break;
228 case EM_SH:
229 case EM_SH:
229 machineName = " Hitachi SH ";
230 machineName = " Hitachi SH ";
230 break;
231 break;
231 case EM_SPARCV9:
232 case EM_SPARCV9:
232 machineName = " SPARC v9 64-bit ";
233 machineName = " SPARC v9 64-bit ";
233 break;
234 break;
234 case EM_TRICORE:
235 case EM_TRICORE:
235 machineName = " Siemens Tricore ";
236 machineName = " Siemens Tricore ";
236 break;
237 break;
237 case EM_ARC:
238 case EM_ARC:
238 machineName = " Argonaut RISC Core ";
239 machineName = " Argonaut RISC Core ";
239 break;
240 break;
240 case EM_H8_300:
241 case EM_H8_300:
241 machineName = " Hitachi H8/300 ";
242 machineName = " Hitachi H8/300 ";
242 break;
243 break;
243 case EM_H8_300H:
244 case EM_H8_300H:
244 machineName = " Hitachi H8/300H ";
245 machineName = " Hitachi H8/300H ";
245 break;
246 break;
246 case EM_H8S:
247 case EM_H8S:
247 machineName = " Hitachi H8S ";
248 machineName = " Hitachi H8S ";
248 break;
249 break;
249 case EM_H8_500:
250 case EM_H8_500:
250 machineName = " Hitachi H8/500 ";
251 machineName = " Hitachi H8/500 ";
251 break;
252 break;
252 case EM_IA_64:
253 case EM_IA_64:
253 machineName = " Intel Merced ";
254 machineName = " Intel Merced ";
254 break;
255 break;
255 case EM_MIPS_X:
256 case EM_MIPS_X:
256 machineName = " Stanford MIPS-X ";
257 machineName = " Stanford MIPS-X ";
257 break;
258 break;
258 case EM_COLDFIRE:
259 case EM_COLDFIRE:
259 machineName = " Motorola Coldfire ";
260 machineName = " Motorola Coldfire ";
260 break;
261 break;
261 case EM_68HC12:
262 case EM_68HC12:
262 machineName = " Motorola M68HC12 ";
263 machineName = " Motorola M68HC12 ";
263 break;
264 break;
264 case EM_MMA:
265 case EM_MMA:
265 machineName = " Fujitsu MMA Multimedia Accelerator";
266 machineName = " Fujitsu MMA Multimedia Accelerator";
266 break;
267 break;
267 case EM_PCP:
268 case EM_PCP:
268 machineName = " Siemens PCP ";
269 machineName = " Siemens PCP ";
269 break;
270 break;
270 case EM_NCPU:
271 case EM_NCPU:
271 machineName = " Sony nCPU embeeded RISC ";
272 machineName = " Sony nCPU embeeded RISC ";
272 break;
273 break;
273 case EM_NDR1:
274 case EM_NDR1:
274 machineName = " Denso NDR1 microprocessor ";
275 machineName = " Denso NDR1 microprocessor ";
275 break;
276 break;
276 case EM_STARCORE:
277 case EM_STARCORE:
277 machineName = " Motorola Start*Core processor ";
278 machineName = " Motorola Start*Core processor ";
278 break;
279 break;
279 case EM_ME16:
280 case EM_ME16:
280 machineName = " Toyota ME16 processor ";
281 machineName = " Toyota ME16 processor ";
281 break;
282 break;
282 case EM_ST100:
283 case EM_ST100:
283 machineName = " STMicroelectronic ST100 processor ";
284 machineName = " STMicroelectronic ST100 processor ";
284 break;
285 break;
285 case EM_TINYJ:
286 case EM_TINYJ:
286 machineName = " Advanced Logic Corp. Tinyj emb.fam";
287 machineName = " Advanced Logic Corp. Tinyj emb.fam";
287 break;
288 break;
288 case EM_X86_64:
289 case EM_X86_64:
289 machineName = " AMD x86-64 architecture ";
290 machineName = " AMD x86-64 architecture ";
290 break;
291 break;
291 case EM_PDSP:
292 case EM_PDSP:
292 machineName = " Sony DSP Processor ";
293 machineName = " Sony DSP Processor ";
293 break;
294 break;
294 case EM_FX66:
295 case EM_FX66:
295 machineName = " Siemens FX66 microcontroller ";
296 machineName = " Siemens FX66 microcontroller ";
296 break;
297 break;
297 case EM_ST9PLUS:
298 case EM_ST9PLUS:
298 machineName = " STMicroelectronics ST9+ 8/16 mc ";
299 machineName = " STMicroelectronics ST9+ 8/16 mc ";
299 break;
300 break;
300 case EM_ST7:
301 case EM_ST7:
301 machineName = " STmicroelectronics ST7 8 bit mc ";
302 machineName = " STmicroelectronics ST7 8 bit mc ";
302 break;
303 break;
303 case EM_68HC16:
304 case EM_68HC16:
304 machineName = " Motorola MC68HC16 microcontroller ";
305 machineName = " Motorola MC68HC16 microcontroller ";
305 break;
306 break;
306 case EM_68HC11:
307 case EM_68HC11:
307 machineName = " Motorola MC68HC11 microcontroller ";
308 machineName = " Motorola MC68HC11 microcontroller ";
308 break;
309 break;
309 case EM_68HC08:
310 case EM_68HC08:
310 machineName = " Motorola MC68HC08 microcontroller ";
311 machineName = " Motorola MC68HC08 microcontroller ";
311 break;
312 break;
312 case EM_68HC05:
313 case EM_68HC05:
313 machineName = " Motorola MC68HC05 microcontroller ";
314 machineName = " Motorola MC68HC05 microcontroller ";
314 break;
315 break;
315 case EM_SVX:
316 case EM_SVX:
316 machineName = " Silicon Graphics SVx ";
317 machineName = " Silicon Graphics SVx ";
317 break;
318 break;
318 case EM_ST19:
319 case EM_ST19:
319 machineName = " STMicroelectronics ST19 8 bit mc ";
320 machineName = " STMicroelectronics ST19 8 bit mc ";
320 break;
321 break;
321 case EM_VAX:
322 case EM_VAX:
322 machineName = " Digital VAX ";
323 machineName = " Digital VAX ";
323 break;
324 break;
324 case EM_CRIS:
325 case EM_CRIS:
325 machineName = " Axis Communications 32-bit embedded processor ";
326 machineName = " Axis Communications 32-bit embedded processor ";
326 break;
327 break;
327 case EM_JAVELIN:
328 case EM_JAVELIN:
328 machineName = " Infineon Technologies 32-bit embedded processor ";
329 machineName = " Infineon Technologies 32-bit embedded processor ";
329 break;
330 break;
330 case EM_FIREPATH:
331 case EM_FIREPATH:
331 machineName = " Element 14 64-bit DSP Processor ";
332 machineName = " Element 14 64-bit DSP Processor ";
332 break;
333 break;
333 case EM_ZSP:
334 case EM_ZSP:
334 machineName = " LSI Logic 16-bit DSP Processor ";
335 machineName = " LSI Logic 16-bit DSP Processor ";
335 break;
336 break;
336 case EM_MMIX:
337 case EM_MMIX:
337 machineName = " Donald Knuth's educational 64-bit processor ";
338 machineName = " Donald Knuth's educational 64-bit processor ";
338 break;
339 break;
339 case EM_HUANY:
340 case EM_HUANY:
340 machineName = " Harvard University machine-independent object files ";
341 machineName = " Harvard University machine-independent object files ";
341 break;
342 break;
342 case EM_PRISM:
343 case EM_PRISM:
343 machineName = " SiTera Prism ";
344 machineName = " SiTera Prism ";
344 break;
345 break;
345 case EM_AVR:
346 case EM_AVR:
346 machineName = " Atmel AVR 8-bit microcontroller ";
347 machineName = " Atmel AVR 8-bit microcontroller ";
347 break;
348 break;
348 case EM_FR30:
349 case EM_FR30:
349 machineName = " Fujitsu FR30 ";
350 machineName = " Fujitsu FR30 ";
350 break;
351 break;
351 case EM_D10V:
352 case EM_D10V:
352 machineName = " Mitsubishi D10V ";
353 machineName = " Mitsubishi D10V ";
353 break;
354 break;
354 case EM_D30V:
355 case EM_D30V:
355 machineName = " Mitsubishi D30V ";
356 machineName = " Mitsubishi D30V ";
356 break;
357 break;
357 case EM_V850:
358 case EM_V850:
358 machineName = " NEC v850 ";
359 machineName = " NEC v850 ";
359 break;
360 break;
360 case EM_M32R:
361 case EM_M32R:
361 machineName = " Mitsubishi M32R ";
362 machineName = " Mitsubishi M32R ";
362 break;
363 break;
363 case EM_MN10300:
364 case EM_MN10300:
364 machineName = " Matsushita MN10300 ";
365 machineName = " Matsushita MN10300 ";
365 break;
366 break;
366 case EM_MN10200:
367 case EM_MN10200:
367 machineName = " Matsushita MN10200 ";
368 machineName = " Matsushita MN10200 ";
368 break;
369 break;
369 case EM_PJ:
370 case EM_PJ:
370 machineName = " picoJava ";
371 machineName = " picoJava ";
371 break;
372 break;
372 case EM_OPENRISC:
373 case EM_OPENRISC:
373 machineName = " OpenRISC 32-bit embedded processor ";
374 machineName = " OpenRISC 32-bit embedded processor ";
374 break;
375 break;
375 case EM_ARC_A5:
376 case EM_ARC_A5:
376 machineName = " ARC Cores Tangent-A5 ";
377 machineName = " ARC Cores Tangent-A5 ";
377 break;
378 break;
378 case EM_XTENSA:
379 case EM_XTENSA:
379 machineName = " Tensilica Xtensa Architecture ";
380 machineName = " Tensilica Xtensa Architecture ";
380 break;
381 break;
381 case EM_AARCH64:
382 case EM_AARCH64:
382 machineName = " ARM AARCH64 ";
383 machineName = " ARM AARCH64 ";
383 break;
384 break;
384 case EM_TILEPRO:
385 case EM_TILEPRO:
385 machineName = " Tilera TILEPro ";
386 machineName = " Tilera TILEPro ";
386 break;
387 break;
387 case EM_MICROBLAZE:
388 case EM_MICROBLAZE:
388 machineName = " Xilinx MicroBlaze ";
389 machineName = " Xilinx MicroBlaze ";
389 break;
390 break;
390 case EM_TILEGX:
391 case EM_TILEGX:
391 machineName = " Tilera TILE-Gx ";
392 machineName = " Tilera TILE-Gx ";
392 break;
393 break;
393 case EM_NUM:
394 case EM_NUM:
394 machineName = "";
395 machineName = "";
395 break;
396 break;
396 default:
397 default:
397 machineName ="Unknow Machine";
398 machineName ="Unknow Machine";
398 break;
399 break;
399 }
400 }
400 return machineName;
401 return machineName;
401 }
402 }
402
403
403
404
404
405
405
406
406 QString ElfFile::getClass()
407 QString ElfFile::getClass()
407 {
408 {
408 if(this->e!=NULL)
409 if(this->e!=NULL)
409 {
410 {
410 int eclass = gelf_getclass(this->e);
411 int eclass = gelf_getclass(this->e);
411 if(eclass==ELFCLASS32)return "ELF32";
412 if(eclass==ELFCLASS32)return "ELF32";
412 if(eclass==ELFCLASS64)return "ELF64";
413 if(eclass==ELFCLASS64)return "ELF64";
413 }
414 }
414 return "none";
415 return "none";
415 }
416 }
416
417
417
418
418 bool ElfFile::iself()
419 bool ElfFile::iself()
419 {
420 {
420 return (this->getType()!="Unknow");
421 return (this->getType()!="Unknow");
421 }
422 }
422
423
423 QString ElfFile::getArchitecture()
424 QString ElfFile::getArchitecture()
424 {
425 {
425 if(this->e!=NULL)
426 if(this->e!=NULL)
426 {
427 {
427 return elfresolveMachine(this->ehdr.e_machine);
428 return elfresolveMachine(this->ehdr.e_machine);
428 }
429 }
429 return "";
430 return "";
430 }
431 }
431
432
432
433
433 QString ElfFile::getType()
434 QString ElfFile::getType()
434 {
435 {
435 QString kind("");
436 QString kind("");
436 if(this->e!=NULL)
437 if(this->e!=NULL)
437 {
438 {
438 switch(this->ek)
439 switch(this->ek)
439 {
440 {
440 case ELF_K_AR:
441 case ELF_K_AR:
441 kind = "Archive";
442 kind = "Archive";
442 break;
443 break;
443 case ELF_K_ELF:
444 case ELF_K_ELF:
444 kind = "Elf";
445 kind = "Elf";
445 break;
446 break;
446 case ELF_K_COFF:
447 case ELF_K_COFF:
447 kind = "COFF";
448 kind = "COFF";
448 break;
449 break;
449 case ELF_K_NUM:
450 case ELF_K_NUM:
450 kind = "NUM";
451 kind = "NUM";
451 break;
452 break;
452 case ELF_K_NONE:
453 case ELF_K_NONE:
453 kind = "Data";
454 kind = "Data";
454 break;
455 break;
455 default:
456 default:
456 kind = "Unknow";
457 kind = "Unknow";
457 break;
458 break;
458 }
459 }
459 }
460 }
460 return kind;
461 return kind;
461 }
462 }
462
463
463 QString ElfFile::getEndianness()
464 QString ElfFile::getEndianness()
464 {
465 {
465 if(this->e!=NULL)
466 if(this->e!=NULL)
466 {
467 {
467 if(this->ehdr.e_ident[EI_DATA]==ELFDATA2LSB)return "2's complement, little endian";
468 if(this->ehdr.e_ident[EI_DATA]==ELFDATA2LSB)return "2's complement, little endian";
468 if(this->ehdr.e_ident[EI_DATA]==ELFDATA2MSB)return "2's complement, big endian";
469 if(this->ehdr.e_ident[EI_DATA]==ELFDATA2MSB)return "2's complement, big endian";
469 }
470 }
470 return "none";
471 return "none";
471 }
472 }
472
473
473 QString ElfFile::getABI()
474 QString ElfFile::getABI()
474 {
475 {
475 if(this->e!=NULL)
476 if(this->e!=NULL)
476 {
477 {
477 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_NONE)return "UNIX System V ABI";
478 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_NONE)return "UNIX System V ABI";
478 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_SYSV)return "Alias";
479 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_SYSV)return "Alias";
479 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_HPUX)return "HP-UX";
480 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_HPUX)return "HP-UX";
480 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_NETBSD)return "NetBSD";
481 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_NETBSD)return "NetBSD";
481 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_GNU)return "Object uses GNU ELF extensions";
482 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_GNU)return "Object uses GNU ELF extensions";
482 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_LINUX)return "Compatibility alias";
483 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_LINUX)return "Compatibility alias";
483 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_SOLARIS)return "Sun Solaris";
484 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_SOLARIS)return "Sun Solaris";
484 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_AIX)return "IBM AIX";
485 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_AIX)return "IBM AIX";
485 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_IRIX)return "SGI Irix";
486 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_IRIX)return "SGI Irix";
486 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_FREEBSD)return "FreeBSD";
487 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_FREEBSD)return "FreeBSD";
487 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_TRU64)return "Compaq TRU64 UNIX";
488 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_TRU64)return "Compaq TRU64 UNIX";
488 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_MODESTO)return " Novell Modesto";
489 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_MODESTO)return " Novell Modesto";
489 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_OPENBSD)return "OpenBSD";
490 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_OPENBSD)return "OpenBSD";
490 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_ARM_AEABI)return "ARM EABI";
491 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_ARM_AEABI)return "ARM EABI";
491 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_ARM)return "ARM";
492 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_ARM)return "ARM";
492 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_STANDALONE)return "Standalone (embedded) application";
493 if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_STANDALONE)return "Standalone (embedded) application";
493 }
494 }
494 return "none";
495 return "none";
495 }
496 }
496
497
497
498
498 qint64 ElfFile::getVersion()
499 qint64 ElfFile::getVersion()
499 {
500 {
500 if(this->e!=NULL)
501 if(this->e!=NULL)
501 {
502 {
502 return this->ehdr.e_version;
503 return this->ehdr.e_version;
503 }
504 }
504 }
505 }
505
506
506 qint64 ElfFile::getEntryPointAddress()
507 qint64 ElfFile::getEntryPointAddress()
507 {
508 {
508 if(this->e!=NULL)
509 if(this->e!=NULL)
509 {
510 {
510 return this->ehdr.e_entry;
511 return this->ehdr.e_entry;
511 }
512 }
512 }
513 }
513
514
514
515
515 int ElfFile::getSectionCount()
516 int ElfFile::getSectionCount()
516 {
517 {
517 return (int)this->SectionCount;
518 return (int)this->SectionCount;
518 }
519 }
519
520
520 int ElfFile::getSymbolCount()
521 int ElfFile::getSymbolCount()
521 {
522 {
522 return (int)this->SymbolCount;
523 return (int)this->SymbolCount;
523 }
524 }
524
525
525
526
526 int ElfFile::getSegmentCount()
527 int ElfFile::getSegmentCount()
527 {
528 {
528 return (int)this->SegmentCount;
529 return (int)this->SegmentCount;
529 }
530 }
530
531
531
532
532 QString ElfFile::getSegmentType(int index)
533 QString ElfFile::getSegmentType(int index)
533 {
534 {
534 QString type("");
535 QString type("");
535 if(this->e!=NULL)
536 if(this->e!=NULL)
536 {
537 {
537 if(index < this->Segments.count())
538 if(index < this->Segments.count())
538 {
539 {
539 switch(this->Segments.at(index)->p_type)
540 switch(this->Segments.at(index)->p_type)
540 {
541 {
541 case PT_NULL:
542 case PT_NULL:
542 type = "Program header table entry unused";
543 type = "Program header table entry unused";
543 break;
544 break;
544 case PT_LOAD:
545 case PT_LOAD:
545 type = "Loadable program segment";
546 type = "Loadable program segment";
546 break;
547 break;
547 case PT_DYNAMIC :
548 case PT_DYNAMIC :
548 type = "Dynamic linking information";
549 type = "Dynamic linking information";
549 break;
550 break;
550 case PT_INTERP:
551 case PT_INTERP:
551 type ="Program interpreter";
552 type ="Program interpreter";
552 break;
553 break;
553 case PT_NOTE:
554 case PT_NOTE:
554 type = "Auxiliary information";
555 type = "Auxiliary information";
555 break;
556 break;
556 case PT_SHLIB:
557 case PT_SHLIB:
557 type = "Reserved";
558 type = "Reserved";
558 break;
559 break;
559 case PT_PHDR:
560 case PT_PHDR:
560 type = "Entry for header table itself";
561 type = "Entry for header table itself";
561 break;
562 break;
562 case PT_TLS:
563 case PT_TLS:
563 type = "Thread-local storage segment";
564 type = "Thread-local storage segment";
564 break;
565 break;
565 case PT_NUM:
566 case PT_NUM:
566 type = "Number of defined types";
567 type = "Number of defined types";
567 break;
568 break;
568 case PT_LOOS:
569 case PT_LOOS:
569 type = "Start of OS-specific";
570 type = "Start of OS-specific";
570 break;
571 break;
571 case PT_SUNWSTACK:
572 case PT_SUNWSTACK:
572 type = "Stack segment";
573 type = "Stack segment";
573 break;
574 break;
574 case PT_LOPROC:
575 case PT_LOPROC:
575 type = "Start of processor-specific";
576 type = "Start of processor-specific";
576 break;
577 break;
577 case PT_HIPROC:
578 case PT_HIPROC:
578 type = "End of processor-specific";
579 type = "End of processor-specific";
579 break;
580 break;
580 default:
581 default:
581 type = "Unknow Section Type";
582 type = "Unknow Section Type";
582 break;
583 break;
583 }
584 }
584 }
585 }
585 }
586 }
586
587
587 return type;
588 return type;
588 }
589 }
589
590
590
591
591 qint64 ElfFile::getSegmentOffset(int index)
592 qint64 ElfFile::getSegmentOffset(int index)
592 {
593 {
593 int64_t Offset;
594 int64_t Offset;
594 if(this->e!=NULL)
595 if(this->e!=NULL)
595 {
596 {
596 if(index < this->Segments.count())
597 if(index < this->Segments.count())
597 {
598 {
598 Offset = (int64_t)this->Segments.at(index)->p_offset;
599 Offset = (int64_t)this->Segments.at(index)->p_offset;
599 }
600 }
600 }
601 }
601 return Offset;
602 return Offset;
602 }
603 }
603
604
604
605
605 qint64 ElfFile::getSegmentVaddr(int index)
606 qint64 ElfFile::getSegmentVaddr(int index)
606 {
607 {
607 int64_t Vaddr = 0;
608 int64_t Vaddr = 0;
608 if(this->e!=NULL)
609 if(this->e!=NULL)
609 {
610 {
610 if(index < this->Segments.count())
611 if(index < this->Segments.count())
611 {
612 {
612 Vaddr = (int64_t)this->Segments.at(index)->p_vaddr;
613 Vaddr = (int64_t)this->Segments.at(index)->p_vaddr;
613 }
614 }
614 }
615 }
615 return Vaddr;
616 return Vaddr;
616 }
617 }
617
618
618
619
619 qint64 ElfFile::getSegmentPaddr(int index)
620 qint64 ElfFile::getSegmentPaddr(int index)
620 {
621 {
621 int64_t Paddr=0;
622 int64_t Paddr=0;
622 if(this->e!=NULL)
623 if(this->e!=NULL)
623 {
624 {
624 if(index < this->Segments.count())
625 if(index < this->Segments.count())
625 {
626 {
626 Paddr = (int64_t)this->Segments.at(index)->p_paddr;
627 Paddr = (int64_t)this->Segments.at(index)->p_paddr;
627 }
628 }
628 }
629 }
629 return Paddr;
630 return Paddr;
630 }
631 }
631
632
632 qint64 ElfFile::getSectionPaddr(int index)
633 qint64 ElfFile::getSectionPaddr(int index)
633 {
634 {
634 int64_t Paddr=0;
635 int64_t Paddr=0;
635 if(this->e!=NULL)
636 if(this->e!=NULL)
636 {
637 {
637 if(index < this->sections.count())
638 if(index < this->sections.count())
638 {
639 {
639 Paddr = (int64_t)this->sections.at(index)->section_header->sh_addr;
640 Paddr = (int64_t)this->sections.at(index)->section_header->sh_addr;
640 }
641 }
641 }
642 }
642 return Paddr;
643 return Paddr;
643 }
644 }
644
645
645
646
646 qint64 ElfFile::getSegmentFilesz(int index)
647 qint64 ElfFile::getSegmentFilesz(int index)
647 {
648 {
648 int64_t FileSz=0;
649 int64_t FileSz=0;
649 if(this->e!=NULL)
650 if(this->e!=NULL)
650 {
651 {
651 if(index < this->Segments.count())
652 if(index < this->Segments.count())
652 {
653 {
653 FileSz = (int64_t)this->Segments.at(index)->p_filesz;
654 FileSz = (int64_t)this->Segments.at(index)->p_filesz;
654 }
655 }
655 }
656 }
656 return FileSz;
657 return FileSz;
657 }
658 }
658
659
659 qint64 ElfFile::getSectionDatasz(int index)
660 qint64 ElfFile::getSectionDatasz(int index)
660 {
661 {
661 int64_t DataSz=0;
662 int64_t DataSz=0;
662 if(this->e!=NULL)
663 if(this->e!=NULL)
663 {
664 {
664 if(index < this->sections.count())
665 if(index < this->sections.count())
665 {
666 {
666 DataSz = (int64_t)this->sections.at(index)->data->d_size;
667 DataSz = (int64_t)this->sections.at(index)->data->d_size;
667 }
668 }
668 }
669 }
669 return DataSz;
670 return DataSz;
670 }
671 }
671
672
672 bool ElfFile::getSectionData(int index, char **buffer)
673 bool ElfFile::getSectionData(int index, char **buffer)
673 {
674 {
674 if(this->e!=NULL)
675 if(this->e!=NULL)
675 {
676 {
676 if(index < this->sections.count())
677 if(index < this->sections.count())
677 {
678 {
678 *buffer = (char *)this->sections.at(index)->data->d_buf;
679 *buffer = (char *)this->sections.at(index)->data->d_buf;
679 return true;
680 return true;
680 }
681 }
681 }
682 }
682 return false;
683 return false;
683 }
684 }
684
685
685
686
686 qint64 ElfFile::getSegmentMemsz(int index)
687 qint64 ElfFile::getSegmentMemsz(int index)
687 {
688 {
688 int64_t MemSz=0;
689 int64_t MemSz=0;
689 if(this->e!=NULL)
690 if(this->e!=NULL)
690 {
691 {
691 if(index < this->Segments.count())
692 if(index < this->Segments.count())
692 {
693 {
693 MemSz = (int64_t)this->Segments.at(index)->p_memsz;
694 MemSz = (int64_t)this->Segments.at(index)->p_memsz;
694 }
695 }
695 }
696 }
696 return MemSz;
697 return MemSz;
697 }
698 }
698
699
699 qint64 ElfFile::getSectionMemsz(int index)
700 qint64 ElfFile::getSectionMemsz(int index)
700 {
701 {
701 int64_t MemSz=0;
702 int64_t MemSz=0;
702 if(this->e!=NULL)
703 if(this->e!=NULL)
703 {
704 {
704 if(index < this->sections.count())
705 if(index < this->sections.count())
705 {
706 {
706 MemSz = (int64_t)this->sections.at(index)->section_header->sh_size;
707 MemSz = (int64_t)this->sections.at(index)->section_header->sh_size;
707 }
708 }
708 }
709 }
709 return MemSz;
710 return MemSz;
710 }
711 }
711
712
712
713
713 QString ElfFile::getSegmentFlags(int index)
714 QString ElfFile::getSegmentFlags(int index)
714 {
715 {
715 QString flags("");
716 QString flags("");
716 if(this->e!=NULL)
717 if(this->e!=NULL)
717 {
718 {
718 if(index < this->Segments.count())
719 if(index < this->Segments.count())
719 {
720 {
720 if((this->Segments.at(index)->p_flags&PF_X) == PF_X)flags+="x";
721 if((this->Segments.at(index)->p_flags&PF_X) == PF_X)flags+="x";
721 if((this->Segments.at(index)->p_flags&PF_W) == PF_W)flags+="w";
722 if((this->Segments.at(index)->p_flags&PF_W) == PF_W)flags+="w";
722 if((this->Segments.at(index)->p_flags&PF_R) == PF_R)flags+="r";
723 if((this->Segments.at(index)->p_flags&PF_R) == PF_R)flags+="r";
723 if((this->Segments.at(index)->p_flags&PF_MASKOS) == PF_MASKOS)flags+=" OS-specific";
724 if((this->Segments.at(index)->p_flags&PF_MASKOS) == PF_MASKOS)flags+=" OS-specific";
724 if((this->Segments.at(index)->p_flags&PF_MASKPROC) == PF_MASKPROC)flags+=" Processor-specific";
725 if((this->Segments.at(index)->p_flags&PF_MASKPROC) == PF_MASKPROC)flags+=" Processor-specific";
725 }
726 }
726 }
727 }
727 return flags;
728 return flags;
728 }
729 }
729
730
730
731
731 QString ElfFile::getSectionName(int index)
732 QString ElfFile::getSectionName(int index)
732 {
733 {
733 if((index<sections.count()) && (index>=0))
734 if((index<sections.count()) && (index>=0))
734 {
735 {
735 char* nameChr = elf_strptr(this->e , this->shstrndx , this->sections.at(index)->section_header->sh_name);
736 char* nameChr = elf_strptr(this->e , this->shstrndx , this->sections.at(index)->section_header->sh_name);
736 return QString(nameChr);
737 return QString(nameChr);
737 }
738 }
738 return "";
739 return "";
739 }
740 }
740
741
741
742
742 void ElfFile::updateSections()
743 void ElfFile::updateSections()
743 {
744 {
744 for(int i=0;i<this->sections.count();i++)
745 for(int i=0;i<this->sections.count();i++)
745 {
746 {
746 delete this->sections.at(i);
747 delete this->sections.at(i);
747 }
748 }
748 this->sections.clear();
749 this->sections.clear();
749 this->scn = elf_nextscn (this->e , NULL );
750 this->scn = elf_nextscn (this->e , NULL );
750 this->SectionCount = 0;
751 this->SectionCount = 0;
751 while( this->scn != NULL )
752 while( this->scn != NULL )
752 {
753 {
753 GElf_Shdr* shdr = (GElf_Shdr*)malloc(sizeof(GElf_Shdr));
754 GElf_Shdr* shdr = (GElf_Shdr*)malloc(sizeof(GElf_Shdr));
754 gelf_getshdr ( this->scn , shdr );
755 gelf_getshdr ( this->scn , shdr );
755 Elf_Data* data = elf_getdata(this->scn, NULL);
756 Elf_Data* data = elf_getdata(this->scn, NULL);
756 this->sections.append(new Elf_Section(data,shdr));
757 this->sections.append(new Elf_Section(data,shdr));
757 this->SectionCount+=1;
758 this->SectionCount+=1;
758 this->scn = elf_nextscn(e , scn);
759 this->scn = elf_nextscn(e , scn);
759 }
760 }
760 }
761 }
761
762
762
763
763 void ElfFile::updateSegments()
764 void ElfFile::updateSegments()
764 {
765 {
765 elf_getphdrnum (this->e , &this->SegmentCount);
766 elf_getphdrnum (this->e , &this->SegmentCount);
766 for(int i=0;i<this->Segments.count();i++)
767 for(int i=0;i<this->Segments.count();i++)
767 {
768 {
768 free(this->Segments.at(i));
769 free(this->Segments.at(i));
769 }
770 }
770 this->Segments.clear();
771 this->Segments.clear();
771 for(int i=0;i<this->SegmentCount;i++)
772 for(int i=0;i<this->SegmentCount;i++)
772 {
773 {
773 GElf_Phdr* header=(GElf_Phdr*)malloc(sizeof(GElf_Phdr));
774 GElf_Phdr* header=(GElf_Phdr*)malloc(sizeof(GElf_Phdr));
774 gelf_getphdr (this->e , i , header );
775 gelf_getphdr (this->e , i , header );
775 this->Segments.append(header);
776 this->Segments.append(header);
776 }
777 }
777 }
778 }
778
779
779 void ElfFile::updateSymbols()
780 void ElfFile::updateSymbols()
780 {
781 {
781 for(int i=0;i<symbols.count();i++)
782 for(int i=0;i<symbols.count();i++)
782 {
783 {
783 delete this->symbols.at(i);
784 delete this->symbols.at(i);
784 }
785 }
785 this->symbols.clear();
786 this->symbols.clear();
786 updateSections(); //Useless in most case but safer to do it
787 updateSections(); //Useless in most case but safer to do it
787 for(int i=0;i<SectionCount;i++)
788 for(int i=0;i<SectionCount;i++)
788 {
789 {
789 //First find Symbol table
790 //First find Symbol table
790 if(this->getSectionName(i)==".symtab")
791 if(this->getSectionName(i)==".symtab")
791 {
792 {
792 Elf_Section* sec = sections.at(i);
793 Elf_Section* sec = sections.at(i);
793 this->SymbolCount = sec->section_header->sh_size / sec->section_header->sh_entsize;
794 this->SymbolCount = sec->section_header->sh_size / sec->section_header->sh_entsize;
794 //Then list all symbols
795 //Then list all symbols
795 for(int j=0;j<this->SymbolCount;j++)
796 for(int j=0;j<this->SymbolCount;j++)
796 {
797 {
797 GElf_Sym* esym = (GElf_Sym*)malloc(sizeof(GElf_Sym));
798 GElf_Sym* esym = (GElf_Sym*)malloc(sizeof(GElf_Sym));
798 gelf_getsym(sec->data, j, esym);
799 gelf_getsym(sec->data, j, esym);
799 QString name = elf_strptr(this->e,sec->section_header->sh_link,esym->st_name);
800 QString name = elf_strptr(this->e,sec->section_header->sh_link,esym->st_name);
800 Elf_Symbol* sym = new Elf_Symbol(name,esym);
801 Elf_Symbol* sym = new Elf_Symbol(name,esym);
801 symbols.append(sym);
802 symbols.append(sym);
802 }
803 }
803 }
804 }
804 }
805 }
805
806
806 }
807 }
807
808
808
809
809
810
810 QString ElfFile::getSectionType(int index)
811 QString ElfFile::getSectionType(int index)
811 {
812 {
812 QString type("");
813 QString type("");
813 if(this->e!=NULL)
814 if(this->e!=NULL)
814 {
815 {
815 if(index < this->Segments.count())
816 if(index < this->Segments.count())
816 {
817 {
817 switch(this->Segments.at(index)->p_type)
818 switch(this->Segments.at(index)->p_type)
818 {
819 {
819 case SHT_NULL : type = "Section header table entry unused"; break;
820 case SHT_NULL : type = "Section header table entry unused"; break;
820 case SHT_PROGBITS : type = "Program data"; break;
821 case SHT_PROGBITS : type = "Program data"; break;
821 case SHT_SYMTAB : type = "Symbol table"; break;
822 case SHT_SYMTAB : type = "Symbol table"; break;
822 case SHT_STRTAB : type = "String table"; break;
823 case SHT_STRTAB : type = "String table"; break;
823 case SHT_RELA : type = "Relocation entries with addends"; break;
824 case SHT_RELA : type = "Relocation entries with addends"; break;
824 case SHT_HASH : type = "Symbol hash table"; break;
825 case SHT_HASH : type = "Symbol hash table"; break;
825 case SHT_DYNAMIC : type = "Dynamic linking information"; break;
826 case SHT_DYNAMIC : type = "Dynamic linking information"; break;
826 case SHT_NOTE : type = "Notes"; break;
827 case SHT_NOTE : type = "Notes"; break;
827 case SHT_NOBITS :type = "Program space with no data (bss)"; break;
828 case SHT_NOBITS :type = "Program space with no data (bss)"; break;
828 case SHT_REL :type = "Relocation entries, no addends"; break;
829 case SHT_REL :type = "Relocation entries, no addends"; break;
829 case SHT_SHLIB : type = "Reserved"; break;
830 case SHT_SHLIB : type = "Reserved"; break;
830 case SHT_DYNSYM : type = "Dynamic linker symbol table"; break;
831 case SHT_DYNSYM : type = "Dynamic linker symbol table"; break;
831 case SHT_INIT_ARRAY : type = "Array of constructors"; break;
832 case SHT_INIT_ARRAY : type = "Array of constructors"; break;
832 case SHT_FINI_ARRAY : type = "Array of destructors"; break;
833 case SHT_FINI_ARRAY : type = "Array of destructors"; break;
833 case SHT_PREINIT_ARRAY : type = "Array of pre-constructors"; break;
834 case SHT_PREINIT_ARRAY : type = "Array of pre-constructors"; break;
834 case SHT_GROUP : type = "Section group"; break;
835 case SHT_GROUP : type = "Section group"; break;
835 case SHT_SYMTAB_SHNDX : type = "Extended section indeces"; break;
836 case SHT_SYMTAB_SHNDX : type = "Extended section indeces"; break;
836 case SHT_NUM : type = "Number of defined types. "; break;
837 case SHT_NUM : type = "Number of defined types. "; break;
837 case SHT_LOOS : type = "Start OS-specific. "; break;
838 case SHT_LOOS : type = "Start OS-specific. "; break;
838 case SHT_LOSUNW : type = "Sun-specific low bound. "; break;
839 case SHT_LOSUNW : type = "Sun-specific low bound. "; break;
839 case SHT_SUNW_COMDAT : type = " "; break;
840 case SHT_SUNW_COMDAT : type = " "; break;
840 case SHT_SUNW_syminfo : type = " "; break;
841 case SHT_SUNW_syminfo : type = " "; break;
841 case SHT_GNU_verdef : type = "Version definition section. "; break;
842 case SHT_GNU_verdef : type = "Version definition section. "; break;
842 case SHT_GNU_verneed : type = "Version needs section. "; break;
843 case SHT_GNU_verneed : type = "Version needs section. "; break;
843 case SHT_GNU_versym : type = "Version symbol table. "; break;
844 case SHT_GNU_versym : type = "Version symbol table. "; break;
844 case SHT_LOPROC : type = "Start of processor-specific"; break;
845 case SHT_LOPROC : type = "Start of processor-specific"; break;
845 case SHT_HIPROC : type = "End of processor-specific"; break;
846 case SHT_HIPROC : type = "End of processor-specific"; break;
846 case SHT_HIUSER : type = "End of application-specific"; break;
847 case SHT_HIUSER : type = "End of application-specific"; break;
847 }
848 }
848 }
849 }
849 }
850 }
850 return type;
851 return type;
851 }
852 }
852
853
853 int ElfFile::getSectionIndex(QString name)
854 int ElfFile::getSectionIndex(QString name)
854 {
855 {
855 if(this->e!=NULL)
856 if(this->e!=NULL)
856 {
857 {
857 for(int i=0;i<sections.count();i++)
858 for(int i=0;i<sections.count();i++)
858 {
859 {
859 if(getSectionName(i)==name)
860 if(getSectionName(i)==name)
860 return i;
861 return i;
861 }
862 }
862 }
863 }
863 return -1;
864 return -1;
864 }
865 }
865
866
866 QString ElfFile::getSymbolName(int index)
867 QString ElfFile::getSymbolName(int index)
867 {
868 {
868 if(this->e!=NULL)
869 if(this->e!=NULL)
869 {
870 {
870 if(index < this->symbols.count())
871 if(index < this->symbols.count())
871 {
872 {
872 return symbols.at(index)->name;
873 return symbols.at(index)->name;
873 }
874 }
874 }
875 }
875 return "";
876 return "";
876 }
877 }
877
878
878 QString ElfFile::getSymbolType(int index)
879 QString ElfFile::getSymbolType(int index)
879 {
880 {
880 if(this->e!=NULL)
881 if(this->e!=NULL)
881 {
882 {
882 if(index < this->symbols.count())
883 if(index < this->symbols.count())
883 {
884 {
884 int type = GELF_ST_TYPE(symbols.at(index)->sym->st_info);
885 int type = GELF_ST_TYPE(symbols.at(index)->sym->st_info);
885 switch(type)
886 switch(type)
886 {
887 {
887 case STT_NOTYPE:
888 case STT_NOTYPE:
888 return "No Type";
889 return "No Type";
889 break;
890 break;
890 case STT_OBJECT:
891 case STT_OBJECT:
891 return "Object";
892 return "Object";
892 break;
893 break;
893 case STT_FUNC:
894 case STT_FUNC:
894 return "Function";
895 return "Function";
895 break;
896 break;
896 case STT_SECTION:
897 case STT_SECTION:
897 return "Section";
898 return "Section";
898 break;
899 break;
899 case STT_FILE:
900 case STT_FILE:
900 return "File";
901 return "File";
901 break;
902 break;
902 case STT_COMMON:
903 case STT_COMMON:
903 return "Common data object";
904 return "Common data object";
904 break;
905 break;
905 case STT_TLS:
906 case STT_TLS:
906 return "Thread-local data object";
907 return "Thread-local data object";
907 break;
908 break;
908 case STT_NUM:
909 case STT_NUM:
909 return "Number of defined types";
910 return "Number of defined types";
910 break;
911 break;
911 case STT_LOOS:
912 case STT_LOOS:
912 return "Start of OS-specific";
913 return "Start of OS-specific";
913 break;
914 break;
914 case STT_HIOS:
915 case STT_HIOS:
915 return "End of OS-specific";
916 return "End of OS-specific";
916 break;
917 break;
917 case STT_LOPROC:
918 case STT_LOPROC:
918 return "Start of processor-specific";
919 return "Start of processor-specific";
919 break;
920 break;
920 case STT_HIPROC:
921 case STT_HIPROC:
921 return "End of processor-specific";
922 return "End of processor-specific";
922 break;
923 break;
923 default:
924 default:
924 return "none";
925 return "none";
925 break;
926 break;
926 }
927 }
927 }
928 }
928 }
929 }
929 return "none";
930 return "none";
930 }
931 }
931
932
932 quint64 ElfFile::getSymbolSize(int index)
933 quint64 ElfFile::getSymbolSize(int index)
933 {
934 {
934 if(this->e!=NULL)
935 if(this->e!=NULL)
935 {
936 {
936 if((index < this->symbols.count()) && (index>=0))
937 if((index < this->symbols.count()) && (index>=0))
937 {
938 {
938 return symbols.at(index)->sym->st_size;
939 return symbols.at(index)->sym->st_size;
939 }
940 }
940 }
941 }
941 return 0;
942 return 0;
942 }
943 }
943
944
944 QString ElfFile::getSymbolSectionName(int index)
945 QString ElfFile::getSymbolSectionName(int index)
945 {
946 {
946 if(this->e!=NULL)
947 if(this->e!=NULL)
947 {
948 {
948 if((index < this->symbols.count()) && (index>=0))
949 if((index < this->symbols.count()) && (index>=0))
949 {
950 {
950 return getSectionName(symbols.at(index)->sym->st_shndx-1);
951 return getSectionName(symbols.at(index)->sym->st_shndx-1);
951 }
952 }
952 }
953 }
953 return "none";
954 return "none";
954 }
955 }
955
956
956 int ElfFile::getSymbolSectionIndex(int index)
957 int ElfFile::getSymbolSectionIndex(int index)
957 {
958 {
958 if(this->e!=NULL)
959 if(this->e!=NULL)
959 {
960 {
960 if((index < this->symbols.count()) && (index>=0))
961 if((index < this->symbols.count()) && (index>=0))
961 {
962 {
962 return symbols.at(index)->sym->st_shndx;
963 return symbols.at(index)->sym->st_shndx;
963 }
964 }
964 }
965 }
965 return 0;
966 return 0;
966 }
967 }
967
968
968 quint64 ElfFile::getSymbolAddress(int index)
969 quint64 ElfFile::getSymbolAddress(int index)
969 {
970 {
970 if(this->e!=NULL)
971 if(this->e!=NULL)
971 {
972 {
972 if((index < this->symbols.count()) && (index>=0))
973 if((index < this->symbols.count()) && (index>=0))
973 {
974 {
974 return symbols.at(index)->sym->st_value;
975 return symbols.at(index)->sym->st_value;
975 }
976 }
976 }
977 }
977 return 0;
978 return 0;
978 }
979 }
979
980
980 QString ElfFile::getSymbolLinkType(int index)
981 QString ElfFile::getSymbolLinkType(int index)
981 {
982 {
982 if(this->e!=NULL)
983 if(this->e!=NULL)
983 {
984 {
984 if(index < this->symbols.count())
985 if(index < this->symbols.count())
985 {
986 {
986 int btype = GELF_ST_BIND(symbols.at(index)->sym->st_info);
987 int btype = GELF_ST_BIND(symbols.at(index)->sym->st_info);
987 switch(btype)
988 switch(btype)
988 {
989 {
989 case STB_LOCAL:
990 case STB_LOCAL:
990 return "Local";
991 return "Local";
991 break;
992 break;
992 case STB_GLOBAL:
993 case STB_GLOBAL:
993 return "Global";
994 return "Global";
994 break;
995 break;
995 case STB_WEAK:
996 case STB_WEAK:
996 return "Weak";
997 return "Weak";
997 break;
998 break;
998 case STB_NUM:
999 case STB_NUM:
999 return "Number of defined types";
1000 return "Number of defined types";
1000 break;
1001 break;
1001 case STB_LOOS:
1002 case STB_LOOS:
1002 return "Start of OS-specific";
1003 return "Start of OS-specific";
1003 break;
1004 break;
1004 case STB_HIOS:
1005 case STB_HIOS:
1005 return "End of OS-specific";
1006 return "End of OS-specific";
1006 break;
1007 break;
1007 case STB_LOPROC:
1008 case STB_LOPROC:
1008 return "Start of processor-specific";
1009 return "Start of processor-specific";
1009 break;
1010 break;
1010 case STB_HIPROC:
1011 case STB_HIPROC:
1011 return "End of processor-specific";
1012 return "End of processor-specific";
1012 break;
1013 break;
1013 default:
1014 default:
1014 return "none";
1015 return "none";
1015 break;
1016 break;
1016 }
1017 }
1017 }
1018 }
1018 }
1019 }
1019 return "none";
1020 return "none";
1020 }
1021 }
1021
1022
1022 bool ElfFile::isElf(const QString &File)
1023 bool ElfFile::isElf(const QString &File)
1023 {
1024 {
1024 int file =0;
1025 int file =0;
1025 #ifdef _ELF_WINDOWS_
1026 #ifdef _ELF_WINDOWS_
1026 file = open(File.toStdString().c_str(),O_RDONLY|O_BINARY ,0);
1027 file = open(File.toStdString().c_str(),O_RDONLY|O_BINARY ,0);
1027 #else
1028 #else
1028 file = open(File.toStdString().c_str(),O_RDONLY ,0);
1029 file = open(File.toStdString().c_str(),O_RDONLY ,0);
1029 #endif
1030 #endif
1030 char Magic[4];
1031 char Magic[4];
1031 if(file!=-1)
1032 if(file!=-1)
1032 {
1033 {
1033 read(file,Magic,4);
1034 read(file,Magic,4);
1034 close(file);
1035 close(file);
1035 if(Magic[0]==0x7f && Magic[1]==0x45 && Magic[2]==0x4c && Magic[3]==0x46)
1036 if(Magic[0]==0x7f && Magic[1]==0x45 && Magic[2]==0x4c && Magic[3]==0x46)
1036 {
1037 {
1037 return true;
1038 return true;
1038 }
1039 }
1039 }
1040 }
1040 return false;
1041 return false;
1041 }
1042 }
1043
1044 bool ElfFile::toSrec(const QString &File)
1045 {
1046 return srecFile::toSrec(this->getFragments(),File);
1047 }
Show file before | Show file after | Hide comments
@@ -1,132 +1,134
1 /*------------------------------------------------------------------------------
1 /*------------------------------------------------------------------------------
2 -- This file is a part of the SocExplorer Software
2 -- This file is a part of the SocExplorer Software
3 -- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
3 -- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
4 --
4 --
5 -- This program is free software; you can redistribute it and/or modify
5 -- This program is free software; you can redistribute it and/or modify
6 -- it under the terms of the GNU General Public License as published by
6 -- it under the terms of the GNU General Public License as published by
7 -- the Free Software Foundation; either version 2 of the License, or
7 -- the Free Software Foundation; either version 2 of the License, or
8 -- (at your option) any later version.
8 -- (at your option) any later version.
9 --
9 --
10 -- This program is distributed in the hope that it will be useful,
10 -- This program is distributed in the hope that it will be useful,
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 -- GNU General Public License for more details.
13 -- GNU General Public License for more details.
14 --
14 --
15 -- You should have received a copy of the GNU General Public License
15 -- You should have received a copy of the GNU General Public License
16 -- along with this program; if not, write to the Free Software
16 -- along with this program; if not, write to the Free Software
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 -------------------------------------------------------------------------------*/
18 -------------------------------------------------------------------------------*/
19 /*-- Author : Alexis Jeandet
19 /*-- Author : Alexis Jeandet
20 -- Mail : alexis.jeandet@member.fsf.org
20 -- Mail : alexis.jeandet@member.fsf.org
21 ----------------------------------------------------------------------------*/
21 ----------------------------------------------------------------------------*/
22 #include <abstractexecfile.h>
22 #include <abstractbinfile.h>
23 #include <QtCore/QObject>
23 #include <QtCore/QObject>
24 #include <QtCore/QStringList>
24 #include <QtCore/QStringList>
25 #include <libelf.h>
25 #include <libelf.h>
26 #include <gelf.h>
26 #include <gelf.h>
27 #include <sys/types.h>
27 #include <sys/types.h>
28 #include <sys/stat.h>
28 #include <sys/stat.h>
29 #include <fcntl.h>
29 #include <fcntl.h>
30 #include <unistd.h>
30 #include <unistd.h>
31 #ifndef ELFFILE_H
31 #ifndef ELFFILE_H
32 #define ELFFILE_H
32 #define ELFFILE_H
33
33
34 class Elf_Section
34 class Elf_Section
35 {
35 {
36 public:
36 public:
37 Elf_Section(){}
37 Elf_Section(){}
38 Elf_Section(Elf_Data* data,GElf_Shdr* section_header)
38 Elf_Section(Elf_Data* data,GElf_Shdr* section_header)
39 {
39 {
40 this->data = data;
40 this->data = data;
41 this->section_header = section_header;
41 this->section_header = section_header;
42 }
42 }
43 ~Elf_Section()
43 ~Elf_Section()
44 {
44 {
45 free(section_header);
45 free(section_header);
46 }
46 }
47 Elf_Data* data;
47 Elf_Data* data;
48 GElf_Shdr* section_header;
48 GElf_Shdr* section_header;
49 };
49 };
50
50
51 class Elf_Symbol
51 class Elf_Symbol
52 {
52 {
53 public:
53 public:
54 Elf_Symbol(){}
54 Elf_Symbol(){}
55 Elf_Symbol(const QString& name,GElf_Sym* sym):name(name),sym(sym){}
55 Elf_Symbol(const QString& name,GElf_Sym* sym):name(name),sym(sym){}
56 ~Elf_Symbol(){free(sym);}
56 ~Elf_Symbol(){free(sym);}
57 QString name;
57 QString name;
58 GElf_Sym* sym;
58 GElf_Sym* sym;
59 };
59 };
60
60
61 class ElfFile : public abstractExecFile
61 class ElfFile : public abstractBinFile
62 {
62 {
63 Q_OBJECT
63 Q_OBJECT
64 public:
64 public:
65 ElfFile();
65 ElfFile();
66 ElfFile(const QString& File);
66 ElfFile(const QString& File);
67 ~ElfFile();
67 ~ElfFile();
68 bool openFile(const QString& File);
68 bool openFile(const QString& File);
69 bool isopened();
69 bool isopened();
70 int closeFile();
70 int closeFile();
71 QList<codeFragment*> getFragments();
71 QList<codeFragment*> getFragments();
72 QList<codeFragment*> getFragments(QStringList fragmentList);
72 QList<codeFragment*> getFragments(QStringList fragmentList);
73
73
74 QString getClass();
74 QString getClass();
75 QString getArchitecture();
75 QString getArchitecture();
76 QString getType();
76 QString getType();
77 QString getEndianness();
77 QString getEndianness();
78 QString getABI();
78 QString getABI();
79 qint64 getVersion();
79 qint64 getVersion();
80 qint64 getEntryPointAddress();
80 qint64 getEntryPointAddress();
81
81
82 int getSectionCount();
82 int getSectionCount();
83 int getSymbolCount();
83 int getSymbolCount();
84 int getSegmentCount();
84 int getSegmentCount();
85
85
86 QString getSegmentType(int index);
86 QString getSegmentType(int index);
87 qint64 getSegmentOffset(int index);
87 qint64 getSegmentOffset(int index);
88 qint64 getSegmentVaddr(int index);
88 qint64 getSegmentVaddr(int index);
89 qint64 getSegmentPaddr(int index);
89 qint64 getSegmentPaddr(int index);
90 qint64 getSegmentFilesz(int index);
90 qint64 getSegmentFilesz(int index);
91 qint64 getSectionDatasz(int index);
91 qint64 getSectionDatasz(int index);
92 qint64 getSegmentMemsz(int index);
92 qint64 getSegmentMemsz(int index);
93 QString getSegmentFlags(int index);
93 QString getSegmentFlags(int index);
94
94
95 bool getSectionData(int index, char **buffer);
95 bool getSectionData(int index, char **buffer);
96 qint64 getSectionPaddr(int index);
96 qint64 getSectionPaddr(int index);
97 qint64 getSectionMemsz(int index);
97 qint64 getSectionMemsz(int index);
98 QString getSectionName(int index);
98 QString getSectionName(int index);
99 QString getSectionType(int index);
99 QString getSectionType(int index);
100 int getSectionIndex(QString name);
100 int getSectionIndex(QString name);
101
101
102 QString getSymbolName(int index);
102 QString getSymbolName(int index);
103 QString getSymbolType(int index);
103 QString getSymbolType(int index);
104 quint64 getSymbolSize(int index);
104 quint64 getSymbolSize(int index);
105 QString getSymbolSectionName(int index);
105 QString getSymbolSectionName(int index);
106 int getSymbolSectionIndex(int index);
106 int getSymbolSectionIndex(int index);
107 quint64 getSymbolAddress(int index);
107 quint64 getSymbolAddress(int index);
108 QString getSymbolLinkType(int index);
108 QString getSymbolLinkType(int index);
109 bool iself();
109 bool iself();
110 static bool isElf(const QString& File);
110 static bool isElf(const QString& File);
111
111
112 bool toSrec(const QString& File);
113
112 private:
114 private:
113 codeFragment* getFragment(const QString& name);
115 codeFragment* getFragment(const QString& name);
114 void updateSections();
116 void updateSections();
115 void updateSegments();
117 void updateSegments();
116 void updateSymbols();
118 void updateSymbols();
117 int elfFile;
119 int elfFile;
118 bool opened;
120 bool opened;
119 bool type_elf;
121 bool type_elf;
120 Elf* e;
122 Elf* e;
121 Elf_Kind ek;
123 Elf_Kind ek;
122 GElf_Ehdr ehdr;
124 GElf_Ehdr ehdr;
123 Elf_Scn * scn;
125 Elf_Scn * scn;
124 Elf_Data * data;
126 Elf_Data * data;
125 size_t SymbolCount,SectionCount,SegmentCount, shstrndx;
127 size_t SymbolCount,SectionCount,SegmentCount, shstrndx;
126 QList<GElf_Phdr*> Segments;
128 QList<GElf_Phdr*> Segments;
127 QList<Elf_Section*> sections;
129 QList<Elf_Section*> sections;
128 QList<Elf_Symbol*> symbols;
130 QList<Elf_Symbol*> symbols;
129
131
130 };
132 };
131
133
132 #endif // ELFFILE_H
134 #endif // ELFFILE_H
Show file before | Show file after | Hide comments
This diff has been collapsed as it changes many lines, (1013 lines changed) Show them Hide them
@@ -1,7068 +1,8031
1 #include "PySocExplorer0.h"
1 #include "PySocExplorer0.h"
2 #include <PythonQtConversion.h>
2 #include <PythonQtConversion.h>
3 #include <PythonQtMethodInfo.h>
3 #include <PythonQtMethodInfo.h>
4 #include <PythonQtSignalReceiver.h>
4 #include <PythonQtSignalReceiver.h>
5 #include <QIconEngine>
5 #include <QIconEngine>
6 #include <QObject>
6 #include <QObject>
7 #include <QSpinBox>
7 #include <QSpinBox>
8 #include <QVariant>
8 #include <QVariant>
9 #include <QWidget>
9 #include <QWidget>
10 #include <abstractexecfile.h>
10 #include <abstractbinfile.h>
11 #include <elffile.h>
11 #include <elffile.h>
12 #include <elfparser.h>
12 #include <elfparser.h>
13 #include <qaction.h>
13 #include <qaction.h>
14 #include <qbitmap.h>
14 #include <qbitmap.h>
15 #include <qbytearray.h>
15 #include <qbytearray.h>
16 #include <qcolor.h>
16 #include <qcolor.h>
17 #include <qcoreevent.h>
17 #include <qcoreevent.h>
18 #include <qcursor.h>
18 #include <qcursor.h>
19 #include <qevent.h>
19 #include <qevent.h>
20 #include <qfile.h>
20 #include <qfile.h>
21 #include <qfont.h>
21 #include <qfont.h>
22 #include <qgraphicseffect.h>
22 #include <qgraphicseffect.h>
23 #include <qgraphicsproxywidget.h>
23 #include <qgraphicsproxywidget.h>
24 #include <qkeysequence.h>
24 #include <qkeysequence.h>
25 #include <qlayout.h>
25 #include <qlayout.h>
26 #include <qlineedit.h>
26 #include <qlineedit.h>
27 #include <qlist.h>
27 #include <qlist.h>
28 #include <qlocale.h>
28 #include <qlocale.h>
29 #include <qmargins.h>
29 #include <qmargins.h>
30 #include <qobject.h>
30 #include <qobject.h>
31 #include <qpaintdevice.h>
31 #include <qpaintdevice.h>
32 #include <qpaintengine.h>
32 #include <qpaintengine.h>
33 #include <qpainter.h>
33 #include <qpainter.h>
34 #include <qpalette.h>
34 #include <qpalette.h>
35 #include <qpen.h>
35 #include <qpen.h>
36 #include <qpixmap.h>
36 #include <qpixmap.h>
37 #include <qpoint.h>
37 #include <qpoint.h>
38 #include <qrect.h>
38 #include <qrect.h>
39 #include <qregion.h>
39 #include <qregion.h>
40 #include <qscrollarea.h>
40 #include <qscrollarea.h>
41 #include <qscrollbar.h>
41 #include <qscrollbar.h>
42 #include <qsize.h>
42 #include <qsize.h>
43 #include <qsizepolicy.h>
43 #include <qsizepolicy.h>
44 #include <qspinbox.h>
44 #include <qspinbox.h>
45 #include <qstringlist.h>
45 #include <qstringlist.h>
46 #include <qstyle.h>
46 #include <qstyle.h>
47 #include <qstyleoption.h>
47 #include <qstyleoption.h>
48 #include <qwidget.h>
48 #include <qwidget.h>
49 #include <srecfile.h>
49
50
50 PythonQtShell_ElfFile::~PythonQtShell_ElfFile() {
51 PythonQtShell_ElfFile::~PythonQtShell_ElfFile() {
51 PythonQtPrivate* priv = PythonQt::priv();
52 PythonQtPrivate* priv = PythonQt::priv();
52 if (priv) { priv->shellClassDeleted(this); }
53 if (priv) { priv->shellClassDeleted(this); }
53 }
54 }
54 int PythonQtShell_ElfFile::closeFile()
55 int PythonQtShell_ElfFile::closeFile()
55 {
56 {
56 if (_wrapper) {
57 if (_wrapper) {
57 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
58 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
58 PyErr_Clear();
59 PyErr_Clear();
59 if (obj && !PythonQtSlotFunction_Check(obj)) {
60 if (obj && !PythonQtSlotFunction_Check(obj)) {
60 static const char* argumentList[] ={"int"};
61 static const char* argumentList[] ={"int"};
61 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
62 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
62 int returnValue;
63 int returnValue;
63 void* args[1] = {NULL};
64 void* args[1] = {NULL};
64 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
65 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
65 if (result) {
66 if (result) {
66 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
67 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
67 if (args[0]!=&returnValue) {
68 if (args[0]!=&returnValue) {
68 if (args[0]==NULL) {
69 if (args[0]==NULL) {
69 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
70 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
70 } else {
71 } else {
71 returnValue = *((int*)args[0]);
72 returnValue = *((int*)args[0]);
72 }
73 }
73 }
74 }
74 }
75 }
75 if (result) { Py_DECREF(result); }
76 if (result) { Py_DECREF(result); }
76 Py_DECREF(obj);
77 Py_DECREF(obj);
77 return returnValue;
78 return returnValue;
78 }
79 }
79 }
80 }
80 return ElfFile::closeFile();
81 return ElfFile::closeFile();
81 }
82 }
82 QList<codeFragment* > PythonQtShell_ElfFile::getFragments()
83 QList<codeFragment* > PythonQtShell_ElfFile::getFragments()
83 {
84 {
84 if (_wrapper) {
85 if (_wrapper) {
85 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
86 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
86 PyErr_Clear();
87 PyErr_Clear();
87 if (obj && !PythonQtSlotFunction_Check(obj)) {
88 if (obj && !PythonQtSlotFunction_Check(obj)) {
88 static const char* argumentList[] ={"QList<codeFragment* >"};
89 static const char* argumentList[] ={"QList<codeFragment* >"};
89 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
90 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
90 QList<codeFragment* > returnValue;
91 QList<codeFragment* > returnValue;
91 void* args[1] = {NULL};
92 void* args[1] = {NULL};
92 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
93 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
93 if (result) {
94 if (result) {
94 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
95 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
95 if (args[0]!=&returnValue) {
96 if (args[0]!=&returnValue) {
96 if (args[0]==NULL) {
97 if (args[0]==NULL) {
97 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
98 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
98 } else {
99 } else {
99 returnValue = *((QList<codeFragment* >*)args[0]);
100 returnValue = *((QList<codeFragment* >*)args[0]);
100 }
101 }
101 }
102 }
102 }
103 }
103 if (result) { Py_DECREF(result); }
104 if (result) { Py_DECREF(result); }
104 Py_DECREF(obj);
105 Py_DECREF(obj);
105 return returnValue;
106 return returnValue;
106 }
107 }
107 }
108 }
108 return ElfFile::getFragments();
109 return ElfFile::getFragments();
109 }
110 }
110 bool PythonQtShell_ElfFile::isopened()
111 bool PythonQtShell_ElfFile::isopened()
111 {
112 {
112 if (_wrapper) {
113 if (_wrapper) {
113 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
114 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
114 PyErr_Clear();
115 PyErr_Clear();
115 if (obj && !PythonQtSlotFunction_Check(obj)) {
116 if (obj && !PythonQtSlotFunction_Check(obj)) {
116 static const char* argumentList[] ={"bool"};
117 static const char* argumentList[] ={"bool"};
117 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
118 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
118 bool returnValue;
119 bool returnValue;
119 void* args[1] = {NULL};
120 void* args[1] = {NULL};
120 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
121 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
121 if (result) {
122 if (result) {
122 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
123 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
123 if (args[0]!=&returnValue) {
124 if (args[0]!=&returnValue) {
124 if (args[0]==NULL) {
125 if (args[0]==NULL) {
125 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
126 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
126 } else {
127 } else {
127 returnValue = *((bool*)args[0]);
128 returnValue = *((bool*)args[0]);
128 }
129 }
129 }
130 }
130 }
131 }
131 if (result) { Py_DECREF(result); }
132 if (result) { Py_DECREF(result); }
132 Py_DECREF(obj);
133 Py_DECREF(obj);
133 return returnValue;
134 return returnValue;
134 }
135 }
135 }
136 }
136 return ElfFile::isopened();
137 return ElfFile::isopened();
137 }
138 }
138 bool PythonQtShell_ElfFile::openFile(const QString& File)
139 bool PythonQtShell_ElfFile::openFile(const QString& File)
139 {
140 {
140 if (_wrapper) {
141 if (_wrapper) {
141 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
142 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
142 PyErr_Clear();
143 PyErr_Clear();
143 if (obj && !PythonQtSlotFunction_Check(obj)) {
144 if (obj && !PythonQtSlotFunction_Check(obj)) {
144 static const char* argumentList[] ={"bool" , "const QString&"};
145 static const char* argumentList[] ={"bool" , "const QString&"};
145 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
146 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
146 bool returnValue;
147 bool returnValue;
147 void* args[2] = {NULL, (void*)&File};
148 void* args[2] = {NULL, (void*)&File};
148 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
149 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
149 if (result) {
150 if (result) {
150 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
151 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
151 if (args[0]!=&returnValue) {
152 if (args[0]!=&returnValue) {
152 if (args[0]==NULL) {
153 if (args[0]==NULL) {
153 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
154 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
154 } else {
155 } else {
155 returnValue = *((bool*)args[0]);
156 returnValue = *((bool*)args[0]);
156 }
157 }
157 }
158 }
158 }
159 }
159 if (result) { Py_DECREF(result); }
160 if (result) { Py_DECREF(result); }
160 Py_DECREF(obj);
161 Py_DECREF(obj);
161 return returnValue;
162 return returnValue;
162 }
163 }
163 }
164 }
164 return ElfFile::openFile(File);
165 return ElfFile::openFile(File);
165 }
166 }
166 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile()
167 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile()
167 {
168 {
168 return new PythonQtShell_ElfFile(); }
169 return new PythonQtShell_ElfFile(); }
169
170
170 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile(const QString& File)
171 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile(const QString& File)
171 {
172 {
172 return new PythonQtShell_ElfFile(File); }
173 return new PythonQtShell_ElfFile(File); }
173
174
174 int PythonQtWrapper_ElfFile::closeFile(ElfFile* theWrappedObject)
175 int PythonQtWrapper_ElfFile::closeFile(ElfFile* theWrappedObject)
175 {
176 {
176 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_closeFile());
177 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_closeFile());
177 }
178 }
178
179
179 QString PythonQtWrapper_ElfFile::getABI(ElfFile* theWrappedObject)
180 QString PythonQtWrapper_ElfFile::getABI(ElfFile* theWrappedObject)
180 {
181 {
181 return ( theWrappedObject->getABI());
182 return ( theWrappedObject->getABI());
182 }
183 }
183
184
184 QString PythonQtWrapper_ElfFile::getArchitecture(ElfFile* theWrappedObject)
185 QString PythonQtWrapper_ElfFile::getArchitecture(ElfFile* theWrappedObject)
185 {
186 {
186 return ( theWrappedObject->getArchitecture());
187 return ( theWrappedObject->getArchitecture());
187 }
188 }
188
189
189 QString PythonQtWrapper_ElfFile::getClass(ElfFile* theWrappedObject)
190 QString PythonQtWrapper_ElfFile::getClass(ElfFile* theWrappedObject)
190 {
191 {
191 return ( theWrappedObject->getClass());
192 return ( theWrappedObject->getClass());
192 }
193 }
193
194
194 QString PythonQtWrapper_ElfFile::getEndianness(ElfFile* theWrappedObject)
195 QString PythonQtWrapper_ElfFile::getEndianness(ElfFile* theWrappedObject)
195 {
196 {
196 return ( theWrappedObject->getEndianness());
197 return ( theWrappedObject->getEndianness());
197 }
198 }
198
199
199 qint64 PythonQtWrapper_ElfFile::getEntryPointAddress(ElfFile* theWrappedObject)
200 qint64 PythonQtWrapper_ElfFile::getEntryPointAddress(ElfFile* theWrappedObject)
200 {
201 {
201 return ( theWrappedObject->getEntryPointAddress());
202 return ( theWrappedObject->getEntryPointAddress());
202 }
203 }
203
204
204 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject)
205 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject)
205 {
206 {
206 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_getFragments());
207 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_getFragments());
207 }
208 }
208
209
209 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject, QStringList fragmentList)
210 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject, QStringList fragmentList)
210 {
211 {
211 return ( theWrappedObject->getFragments(fragmentList));
212 return ( theWrappedObject->getFragments(fragmentList));
212 }
213 }
213
214
214 int PythonQtWrapper_ElfFile::getSectionCount(ElfFile* theWrappedObject)
215 int PythonQtWrapper_ElfFile::getSectionCount(ElfFile* theWrappedObject)
215 {
216 {
216 return ( theWrappedObject->getSectionCount());
217 return ( theWrappedObject->getSectionCount());
217 }
218 }
218
219
219 bool PythonQtWrapper_ElfFile::getSectionData(ElfFile* theWrappedObject, int index, char** buffer)
220 bool PythonQtWrapper_ElfFile::getSectionData(ElfFile* theWrappedObject, int index, char** buffer)
220 {
221 {
221 return ( theWrappedObject->getSectionData(index, buffer));
222 return ( theWrappedObject->getSectionData(index, buffer));
222 }
223 }
223
224
224 qint64 PythonQtWrapper_ElfFile::getSectionDatasz(ElfFile* theWrappedObject, int index)
225 qint64 PythonQtWrapper_ElfFile::getSectionDatasz(ElfFile* theWrappedObject, int index)
225 {
226 {
226 return ( theWrappedObject->getSectionDatasz(index));
227 return ( theWrappedObject->getSectionDatasz(index));
227 }
228 }
228
229
229 int PythonQtWrapper_ElfFile::getSectionIndex(ElfFile* theWrappedObject, QString name)
230 int PythonQtWrapper_ElfFile::getSectionIndex(ElfFile* theWrappedObject, QString name)
230 {
231 {
231 return ( theWrappedObject->getSectionIndex(name));
232 return ( theWrappedObject->getSectionIndex(name));
232 }
233 }
233
234
234 qint64 PythonQtWrapper_ElfFile::getSectionMemsz(ElfFile* theWrappedObject, int index)
235 qint64 PythonQtWrapper_ElfFile::getSectionMemsz(ElfFile* theWrappedObject, int index)
235 {
236 {
236 return ( theWrappedObject->getSectionMemsz(index));
237 return ( theWrappedObject->getSectionMemsz(index));
237 }
238 }
238
239
239 QString PythonQtWrapper_ElfFile::getSectionName(ElfFile* theWrappedObject, int index)
240 QString PythonQtWrapper_ElfFile::getSectionName(ElfFile* theWrappedObject, int index)
240 {
241 {
241 return ( theWrappedObject->getSectionName(index));
242 return ( theWrappedObject->getSectionName(index));
242 }
243 }
243
244
244 qint64 PythonQtWrapper_ElfFile::getSectionPaddr(ElfFile* theWrappedObject, int index)
245 qint64 PythonQtWrapper_ElfFile::getSectionPaddr(ElfFile* theWrappedObject, int index)
245 {
246 {
246 return ( theWrappedObject->getSectionPaddr(index));
247 return ( theWrappedObject->getSectionPaddr(index));
247 }
248 }
248
249
249 QString PythonQtWrapper_ElfFile::getSectionType(ElfFile* theWrappedObject, int index)
250 QString PythonQtWrapper_ElfFile::getSectionType(ElfFile* theWrappedObject, int index)
250 {
251 {
251 return ( theWrappedObject->getSectionType(index));
252 return ( theWrappedObject->getSectionType(index));
252 }
253 }
253
254
254 int PythonQtWrapper_ElfFile::getSegmentCount(ElfFile* theWrappedObject)
255 int PythonQtWrapper_ElfFile::getSegmentCount(ElfFile* theWrappedObject)
255 {
256 {
256 return ( theWrappedObject->getSegmentCount());
257 return ( theWrappedObject->getSegmentCount());
257 }
258 }
258
259
259 qint64 PythonQtWrapper_ElfFile::getSegmentFilesz(ElfFile* theWrappedObject, int index)
260 qint64 PythonQtWrapper_ElfFile::getSegmentFilesz(ElfFile* theWrappedObject, int index)
260 {
261 {
261 return ( theWrappedObject->getSegmentFilesz(index));
262 return ( theWrappedObject->getSegmentFilesz(index));
262 }
263 }
263
264
264 QString PythonQtWrapper_ElfFile::getSegmentFlags(ElfFile* theWrappedObject, int index)
265 QString PythonQtWrapper_ElfFile::getSegmentFlags(ElfFile* theWrappedObject, int index)
265 {
266 {
266 return ( theWrappedObject->getSegmentFlags(index));
267 return ( theWrappedObject->getSegmentFlags(index));
267 }
268 }
268
269
269 qint64 PythonQtWrapper_ElfFile::getSegmentMemsz(ElfFile* theWrappedObject, int index)
270 qint64 PythonQtWrapper_ElfFile::getSegmentMemsz(ElfFile* theWrappedObject, int index)
270 {
271 {
271 return ( theWrappedObject->getSegmentMemsz(index));
272 return ( theWrappedObject->getSegmentMemsz(index));
272 }
273 }
273
274
274 qint64 PythonQtWrapper_ElfFile::getSegmentOffset(ElfFile* theWrappedObject, int index)
275 qint64 PythonQtWrapper_ElfFile::getSegmentOffset(ElfFile* theWrappedObject, int index)
275 {
276 {
276 return ( theWrappedObject->getSegmentOffset(index));
277 return ( theWrappedObject->getSegmentOffset(index));
277 }
278 }
278
279
279 qint64 PythonQtWrapper_ElfFile::getSegmentPaddr(ElfFile* theWrappedObject, int index)
280 qint64 PythonQtWrapper_ElfFile::getSegmentPaddr(ElfFile* theWrappedObject, int index)
280 {
281 {
281 return ( theWrappedObject->getSegmentPaddr(index));
282 return ( theWrappedObject->getSegmentPaddr(index));
282 }
283 }
283
284
284 QString PythonQtWrapper_ElfFile::getSegmentType(ElfFile* theWrappedObject, int index)
285 QString PythonQtWrapper_ElfFile::getSegmentType(ElfFile* theWrappedObject, int index)
285 {
286 {
286 return ( theWrappedObject->getSegmentType(index));
287 return ( theWrappedObject->getSegmentType(index));
287 }
288 }
288
289
289 qint64 PythonQtWrapper_ElfFile::getSegmentVaddr(ElfFile* theWrappedObject, int index)
290 qint64 PythonQtWrapper_ElfFile::getSegmentVaddr(ElfFile* theWrappedObject, int index)
290 {
291 {
291 return ( theWrappedObject->getSegmentVaddr(index));
292 return ( theWrappedObject->getSegmentVaddr(index));
292 }
293 }
293
294
294 quint64 PythonQtWrapper_ElfFile::getSymbolAddress(ElfFile* theWrappedObject, int index)
295 quint64 PythonQtWrapper_ElfFile::getSymbolAddress(ElfFile* theWrappedObject, int index)
295 {
296 {
296 return ( theWrappedObject->getSymbolAddress(index));
297 return ( theWrappedObject->getSymbolAddress(index));
297 }
298 }
298
299
299 int PythonQtWrapper_ElfFile::getSymbolCount(ElfFile* theWrappedObject)
300 int PythonQtWrapper_ElfFile::getSymbolCount(ElfFile* theWrappedObject)
300 {
301 {
301 return ( theWrappedObject->getSymbolCount());
302 return ( theWrappedObject->getSymbolCount());
302 }
303 }
303
304
304 QString PythonQtWrapper_ElfFile::getSymbolLinkType(ElfFile* theWrappedObject, int index)
305 QString PythonQtWrapper_ElfFile::getSymbolLinkType(ElfFile* theWrappedObject, int index)
305 {
306 {
306 return ( theWrappedObject->getSymbolLinkType(index));
307 return ( theWrappedObject->getSymbolLinkType(index));
307 }
308 }
308
309
309 QString PythonQtWrapper_ElfFile::getSymbolName(ElfFile* theWrappedObject, int index)
310 QString PythonQtWrapper_ElfFile::getSymbolName(ElfFile* theWrappedObject, int index)
310 {
311 {
311 return ( theWrappedObject->getSymbolName(index));
312 return ( theWrappedObject->getSymbolName(index));
312 }
313 }
313
314
314 int PythonQtWrapper_ElfFile::getSymbolSectionIndex(ElfFile* theWrappedObject, int index)
315 int PythonQtWrapper_ElfFile::getSymbolSectionIndex(ElfFile* theWrappedObject, int index)
315 {
316 {
316 return ( theWrappedObject->getSymbolSectionIndex(index));
317 return ( theWrappedObject->getSymbolSectionIndex(index));
317 }
318 }
318
319
319 QString PythonQtWrapper_ElfFile::getSymbolSectionName(ElfFile* theWrappedObject, int index)
320 QString PythonQtWrapper_ElfFile::getSymbolSectionName(ElfFile* theWrappedObject, int index)
320 {
321 {
321 return ( theWrappedObject->getSymbolSectionName(index));
322 return ( theWrappedObject->getSymbolSectionName(index));
322 }
323 }
323
324
324 quint64 PythonQtWrapper_ElfFile::getSymbolSize(ElfFile* theWrappedObject, int index)
325 quint64 PythonQtWrapper_ElfFile::getSymbolSize(ElfFile* theWrappedObject, int index)
325 {
326 {
326 return ( theWrappedObject->getSymbolSize(index));
327 return ( theWrappedObject->getSymbolSize(index));
327 }
328 }
328
329
329 QString PythonQtWrapper_ElfFile::getSymbolType(ElfFile* theWrappedObject, int index)
330 QString PythonQtWrapper_ElfFile::getSymbolType(ElfFile* theWrappedObject, int index)
330 {
331 {
331 return ( theWrappedObject->getSymbolType(index));
332 return ( theWrappedObject->getSymbolType(index));
332 }
333 }
333
334
334 QString PythonQtWrapper_ElfFile::getType(ElfFile* theWrappedObject)
335 QString PythonQtWrapper_ElfFile::getType(ElfFile* theWrappedObject)
335 {
336 {
336 return ( theWrappedObject->getType());
337 return ( theWrappedObject->getType());
337 }
338 }
338
339
339 qint64 PythonQtWrapper_ElfFile::getVersion(ElfFile* theWrappedObject)
340 qint64 PythonQtWrapper_ElfFile::getVersion(ElfFile* theWrappedObject)
340 {
341 {
341 return ( theWrappedObject->getVersion());
342 return ( theWrappedObject->getVersion());
342 }
343 }
343
344
344 bool PythonQtWrapper_ElfFile::static_ElfFile_isElf(const QString& File)
345 bool PythonQtWrapper_ElfFile::static_ElfFile_isElf(const QString& File)
345 {
346 {
346 return (ElfFile::isElf(File));
347 return (ElfFile::isElf(File));
347 }
348 }
348
349
349 bool PythonQtWrapper_ElfFile::iself(ElfFile* theWrappedObject)
350 bool PythonQtWrapper_ElfFile::iself(ElfFile* theWrappedObject)
350 {
351 {
351 return ( theWrappedObject->iself());
352 return ( theWrappedObject->iself());
352 }
353 }
353
354
354 bool PythonQtWrapper_ElfFile::isopened(ElfFile* theWrappedObject)
355 bool PythonQtWrapper_ElfFile::isopened(ElfFile* theWrappedObject)
355 {
356 {
356 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_isopened());
357 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_isopened());
357 }
358 }
358
359
359 bool PythonQtWrapper_ElfFile::openFile(ElfFile* theWrappedObject, const QString& File)
360 bool PythonQtWrapper_ElfFile::openFile(ElfFile* theWrappedObject, const QString& File)
360 {
361 {
361 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_openFile(File));
362 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_openFile(File));
362 }
363 }
363
364
365 bool PythonQtWrapper_ElfFile::toSrec(ElfFile* theWrappedObject, const QString& File)
366 {
367 return ( theWrappedObject->toSrec(File));
368 }
369
364
370
365
371
366 PythonQtShell_MemSizeWdgt::~PythonQtShell_MemSizeWdgt() {
372 PythonQtShell_MemSizeWdgt::~PythonQtShell_MemSizeWdgt() {
367 PythonQtPrivate* priv = PythonQt::priv();
373 PythonQtPrivate* priv = PythonQt::priv();
368 if (priv) { priv->shellClassDeleted(this); }
374 if (priv) { priv->shellClassDeleted(this); }
369 }
375 }
370 void PythonQtShell_MemSizeWdgt::actionEvent(QActionEvent* arg__1)
376 void PythonQtShell_MemSizeWdgt::actionEvent(QActionEvent* arg__1)
371 {
377 {
372 if (_wrapper) {
378 if (_wrapper) {
373 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
379 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
374 PyErr_Clear();
380 PyErr_Clear();
375 if (obj && !PythonQtSlotFunction_Check(obj)) {
381 if (obj && !PythonQtSlotFunction_Check(obj)) {
376 static const char* argumentList[] ={"" , "QActionEvent*"};
382 static const char* argumentList[] ={"" , "QActionEvent*"};
377 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
383 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
378 void* args[2] = {NULL, (void*)&arg__1};
384 void* args[2] = {NULL, (void*)&arg__1};
379 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
385 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
380 if (result) { Py_DECREF(result); }
386 if (result) { Py_DECREF(result); }
381 Py_DECREF(obj);
387 Py_DECREF(obj);
382 return;
388 return;
383 }
389 }
384 }
390 }
385 MemSizeWdgt::actionEvent(arg__1);
391 MemSizeWdgt::actionEvent(arg__1);
386 }
392 }
387 void PythonQtShell_MemSizeWdgt::changeEvent(QEvent* arg__1)
393 void PythonQtShell_MemSizeWdgt::changeEvent(QEvent* arg__1)
388 {
394 {
389 if (_wrapper) {
395 if (_wrapper) {
390 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
396 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
391 PyErr_Clear();
397 PyErr_Clear();
392 if (obj && !PythonQtSlotFunction_Check(obj)) {
398 if (obj && !PythonQtSlotFunction_Check(obj)) {
393 static const char* argumentList[] ={"" , "QEvent*"};
399 static const char* argumentList[] ={"" , "QEvent*"};
394 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
400 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
395 void* args[2] = {NULL, (void*)&arg__1};
401 void* args[2] = {NULL, (void*)&arg__1};
396 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
402 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
397 if (result) { Py_DECREF(result); }
403 if (result) { Py_DECREF(result); }
398 Py_DECREF(obj);
404 Py_DECREF(obj);
399 return;
405 return;
400 }
406 }
401 }
407 }
402 MemSizeWdgt::changeEvent(arg__1);
408 MemSizeWdgt::changeEvent(arg__1);
403 }
409 }
404 void PythonQtShell_MemSizeWdgt::childEvent(QChildEvent* arg__1)
410 void PythonQtShell_MemSizeWdgt::childEvent(QChildEvent* arg__1)
405 {
411 {
406 if (_wrapper) {
412 if (_wrapper) {
407 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
413 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
408 PyErr_Clear();
414 PyErr_Clear();
409 if (obj && !PythonQtSlotFunction_Check(obj)) {
415 if (obj && !PythonQtSlotFunction_Check(obj)) {
410 static const char* argumentList[] ={"" , "QChildEvent*"};
416 static const char* argumentList[] ={"" , "QChildEvent*"};
411 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
417 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
412 void* args[2] = {NULL, (void*)&arg__1};
418 void* args[2] = {NULL, (void*)&arg__1};
413 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
419 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
414 if (result) { Py_DECREF(result); }
420 if (result) { Py_DECREF(result); }
415 Py_DECREF(obj);
421 Py_DECREF(obj);
416 return;
422 return;
417 }
423 }
418 }
424 }
419 MemSizeWdgt::childEvent(arg__1);
425 MemSizeWdgt::childEvent(arg__1);
420 }
426 }
421 void PythonQtShell_MemSizeWdgt::closeEvent(QCloseEvent* arg__1)
427 void PythonQtShell_MemSizeWdgt::closeEvent(QCloseEvent* arg__1)
422 {
428 {
423 if (_wrapper) {
429 if (_wrapper) {
424 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
430 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
425 PyErr_Clear();
431 PyErr_Clear();
426 if (obj && !PythonQtSlotFunction_Check(obj)) {
432 if (obj && !PythonQtSlotFunction_Check(obj)) {
427 static const char* argumentList[] ={"" , "QCloseEvent*"};
433 static const char* argumentList[] ={"" , "QCloseEvent*"};
428 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
434 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
429 void* args[2] = {NULL, (void*)&arg__1};
435 void* args[2] = {NULL, (void*)&arg__1};
430 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
436 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
431 if (result) { Py_DECREF(result); }
437 if (result) { Py_DECREF(result); }
432 Py_DECREF(obj);
438 Py_DECREF(obj);
433 return;
439 return;
434 }
440 }
435 }
441 }
436 MemSizeWdgt::closeEvent(arg__1);
442 MemSizeWdgt::closeEvent(arg__1);
437 }
443 }
438 void PythonQtShell_MemSizeWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
444 void PythonQtShell_MemSizeWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
439 {
445 {
440 if (_wrapper) {
446 if (_wrapper) {
441 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
447 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
442 PyErr_Clear();
448 PyErr_Clear();
443 if (obj && !PythonQtSlotFunction_Check(obj)) {
449 if (obj && !PythonQtSlotFunction_Check(obj)) {
444 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
450 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
445 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
451 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
446 void* args[2] = {NULL, (void*)&arg__1};
452 void* args[2] = {NULL, (void*)&arg__1};
447 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
453 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
448 if (result) { Py_DECREF(result); }
454 if (result) { Py_DECREF(result); }
449 Py_DECREF(obj);
455 Py_DECREF(obj);
450 return;
456 return;
451 }
457 }
452 }
458 }
453 MemSizeWdgt::contextMenuEvent(arg__1);
459 MemSizeWdgt::contextMenuEvent(arg__1);
454 }
460 }
455 void PythonQtShell_MemSizeWdgt::customEvent(QEvent* arg__1)
461 void PythonQtShell_MemSizeWdgt::customEvent(QEvent* arg__1)
456 {
462 {
457 if (_wrapper) {
463 if (_wrapper) {
458 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
464 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
459 PyErr_Clear();
465 PyErr_Clear();
460 if (obj && !PythonQtSlotFunction_Check(obj)) {
466 if (obj && !PythonQtSlotFunction_Check(obj)) {
461 static const char* argumentList[] ={"" , "QEvent*"};
467 static const char* argumentList[] ={"" , "QEvent*"};
462 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
468 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
463 void* args[2] = {NULL, (void*)&arg__1};
469 void* args[2] = {NULL, (void*)&arg__1};
464 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
470 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
465 if (result) { Py_DECREF(result); }
471 if (result) { Py_DECREF(result); }
466 Py_DECREF(obj);
472 Py_DECREF(obj);
467 return;
473 return;
468 }
474 }
469 }
475 }
470 MemSizeWdgt::customEvent(arg__1);
476 MemSizeWdgt::customEvent(arg__1);
471 }
477 }
472 int PythonQtShell_MemSizeWdgt::devType() const
478 int PythonQtShell_MemSizeWdgt::devType() const
473 {
479 {
474 if (_wrapper) {
480 if (_wrapper) {
475 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
481 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
476 PyErr_Clear();
482 PyErr_Clear();
477 if (obj && !PythonQtSlotFunction_Check(obj)) {
483 if (obj && !PythonQtSlotFunction_Check(obj)) {
478 static const char* argumentList[] ={"int"};
484 static const char* argumentList[] ={"int"};
479 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
485 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
480 int returnValue;
486 int returnValue;
481 void* args[1] = {NULL};
487 void* args[1] = {NULL};
482 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
488 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
483 if (result) {
489 if (result) {
484 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
490 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
485 if (args[0]!=&returnValue) {
491 if (args[0]!=&returnValue) {
486 if (args[0]==NULL) {
492 if (args[0]==NULL) {
487 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
493 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
488 } else {
494 } else {
489 returnValue = *((int*)args[0]);
495 returnValue = *((int*)args[0]);
490 }
496 }
491 }
497 }
492 }
498 }
493 if (result) { Py_DECREF(result); }
499 if (result) { Py_DECREF(result); }
494 Py_DECREF(obj);
500 Py_DECREF(obj);
495 return returnValue;
501 return returnValue;
496 }
502 }
497 }
503 }
498 return MemSizeWdgt::devType();
504 return MemSizeWdgt::devType();
499 }
505 }
500 void PythonQtShell_MemSizeWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
506 void PythonQtShell_MemSizeWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
501 {
507 {
502 if (_wrapper) {
508 if (_wrapper) {
503 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
509 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
504 PyErr_Clear();
510 PyErr_Clear();
505 if (obj && !PythonQtSlotFunction_Check(obj)) {
511 if (obj && !PythonQtSlotFunction_Check(obj)) {
506 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
512 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
507 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
513 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
508 void* args[2] = {NULL, (void*)&arg__1};
514 void* args[2] = {NULL, (void*)&arg__1};
509 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
515 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
510 if (result) { Py_DECREF(result); }
516 if (result) { Py_DECREF(result); }
511 Py_DECREF(obj);
517 Py_DECREF(obj);
512 return;
518 return;
513 }
519 }
514 }
520 }
515 MemSizeWdgt::dragEnterEvent(arg__1);
521 MemSizeWdgt::dragEnterEvent(arg__1);
516 }
522 }
517 void PythonQtShell_MemSizeWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
523 void PythonQtShell_MemSizeWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
518 {
524 {
519 if (_wrapper) {
525 if (_wrapper) {
520 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
526 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
521 PyErr_Clear();
527 PyErr_Clear();
522 if (obj && !PythonQtSlotFunction_Check(obj)) {
528 if (obj && !PythonQtSlotFunction_Check(obj)) {
523 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
529 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
524 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
530 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
525 void* args[2] = {NULL, (void*)&arg__1};
531 void* args[2] = {NULL, (void*)&arg__1};
526 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
532 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
527 if (result) { Py_DECREF(result); }
533 if (result) { Py_DECREF(result); }
528 Py_DECREF(obj);
534 Py_DECREF(obj);
529 return;
535 return;
530 }
536 }
531 }
537 }
532 MemSizeWdgt::dragLeaveEvent(arg__1);
538 MemSizeWdgt::dragLeaveEvent(arg__1);
533 }
539 }
534 void PythonQtShell_MemSizeWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
540 void PythonQtShell_MemSizeWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
535 {
541 {
536 if (_wrapper) {
542 if (_wrapper) {
537 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
543 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
538 PyErr_Clear();
544 PyErr_Clear();
539 if (obj && !PythonQtSlotFunction_Check(obj)) {
545 if (obj && !PythonQtSlotFunction_Check(obj)) {
540 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
546 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
541 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
547 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
542 void* args[2] = {NULL, (void*)&arg__1};
548 void* args[2] = {NULL, (void*)&arg__1};
543 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
549 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
544 if (result) { Py_DECREF(result); }
550 if (result) { Py_DECREF(result); }
545 Py_DECREF(obj);
551 Py_DECREF(obj);
546 return;
552 return;
547 }
553 }
548 }
554 }
549 MemSizeWdgt::dragMoveEvent(arg__1);
555 MemSizeWdgt::dragMoveEvent(arg__1);
550 }
556 }
551 void PythonQtShell_MemSizeWdgt::dropEvent(QDropEvent* arg__1)
557 void PythonQtShell_MemSizeWdgt::dropEvent(QDropEvent* arg__1)
552 {
558 {
553 if (_wrapper) {
559 if (_wrapper) {
554 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
560 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
555 PyErr_Clear();
561 PyErr_Clear();
556 if (obj && !PythonQtSlotFunction_Check(obj)) {
562 if (obj && !PythonQtSlotFunction_Check(obj)) {
557 static const char* argumentList[] ={"" , "QDropEvent*"};
563 static const char* argumentList[] ={"" , "QDropEvent*"};
558 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
564 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
559 void* args[2] = {NULL, (void*)&arg__1};
565 void* args[2] = {NULL, (void*)&arg__1};
560 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
566 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
561 if (result) { Py_DECREF(result); }
567 if (result) { Py_DECREF(result); }
562 Py_DECREF(obj);
568 Py_DECREF(obj);
563 return;
569 return;
564 }
570 }
565 }
571 }
566 MemSizeWdgt::dropEvent(arg__1);
572 MemSizeWdgt::dropEvent(arg__1);
567 }
573 }
568 void PythonQtShell_MemSizeWdgt::enterEvent(QEvent* arg__1)
574 void PythonQtShell_MemSizeWdgt::enterEvent(QEvent* arg__1)
569 {
575 {
570 if (_wrapper) {
576 if (_wrapper) {
571 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
577 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
572 PyErr_Clear();
578 PyErr_Clear();
573 if (obj && !PythonQtSlotFunction_Check(obj)) {
579 if (obj && !PythonQtSlotFunction_Check(obj)) {
574 static const char* argumentList[] ={"" , "QEvent*"};
580 static const char* argumentList[] ={"" , "QEvent*"};
575 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
581 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
576 void* args[2] = {NULL, (void*)&arg__1};
582 void* args[2] = {NULL, (void*)&arg__1};
577 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
583 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
578 if (result) { Py_DECREF(result); }
584 if (result) { Py_DECREF(result); }
579 Py_DECREF(obj);
585 Py_DECREF(obj);
580 return;
586 return;
581 }
587 }
582 }
588 }
583 MemSizeWdgt::enterEvent(arg__1);
589 MemSizeWdgt::enterEvent(arg__1);
584 }
590 }
585 bool PythonQtShell_MemSizeWdgt::event(QEvent* arg__1)
591 bool PythonQtShell_MemSizeWdgt::event(QEvent* arg__1)
586 {
592 {
587 if (_wrapper) {
593 if (_wrapper) {
588 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
594 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
589 PyErr_Clear();
595 PyErr_Clear();
590 if (obj && !PythonQtSlotFunction_Check(obj)) {
596 if (obj && !PythonQtSlotFunction_Check(obj)) {
591 static const char* argumentList[] ={"bool" , "QEvent*"};
597 static const char* argumentList[] ={"bool" , "QEvent*"};
592 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
598 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
593 bool returnValue;
599 bool returnValue;
594 void* args[2] = {NULL, (void*)&arg__1};
600 void* args[2] = {NULL, (void*)&arg__1};
595 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
601 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
596 if (result) {
602 if (result) {
597 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
603 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
598 if (args[0]!=&returnValue) {
604 if (args[0]!=&returnValue) {
599 if (args[0]==NULL) {
605 if (args[0]==NULL) {
600 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
606 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
601 } else {
607 } else {
602 returnValue = *((bool*)args[0]);
608 returnValue = *((bool*)args[0]);
603 }
609 }
604 }
610 }
605 }
611 }
606 if (result) { Py_DECREF(result); }
612 if (result) { Py_DECREF(result); }
607 Py_DECREF(obj);
613 Py_DECREF(obj);
608 return returnValue;
614 return returnValue;
609 }
615 }
610 }
616 }
611 return MemSizeWdgt::event(arg__1);
617 return MemSizeWdgt::event(arg__1);
612 }
618 }
613 bool PythonQtShell_MemSizeWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
619 bool PythonQtShell_MemSizeWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
614 {
620 {
615 if (_wrapper) {
621 if (_wrapper) {
616 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
622 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
617 PyErr_Clear();
623 PyErr_Clear();
618 if (obj && !PythonQtSlotFunction_Check(obj)) {
624 if (obj && !PythonQtSlotFunction_Check(obj)) {
619 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
625 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
620 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
626 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
621 bool returnValue;
627 bool returnValue;
622 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
628 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
623 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
629 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
624 if (result) {
630 if (result) {
625 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
631 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
626 if (args[0]!=&returnValue) {
632 if (args[0]!=&returnValue) {
627 if (args[0]==NULL) {
633 if (args[0]==NULL) {
628 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
634 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
629 } else {
635 } else {
630 returnValue = *((bool*)args[0]);
636 returnValue = *((bool*)args[0]);
631 }
637 }
632 }
638 }
633 }
639 }
634 if (result) { Py_DECREF(result); }
640 if (result) { Py_DECREF(result); }
635 Py_DECREF(obj);
641 Py_DECREF(obj);
636 return returnValue;
642 return returnValue;
637 }
643 }
638 }
644 }
639 return MemSizeWdgt::eventFilter(arg__1, arg__2);
645 return MemSizeWdgt::eventFilter(arg__1, arg__2);
640 }
646 }
641 void PythonQtShell_MemSizeWdgt::focusInEvent(QFocusEvent* arg__1)
647 void PythonQtShell_MemSizeWdgt::focusInEvent(QFocusEvent* arg__1)
642 {
648 {
643 if (_wrapper) {
649 if (_wrapper) {
644 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
650 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
645 PyErr_Clear();
651 PyErr_Clear();
646 if (obj && !PythonQtSlotFunction_Check(obj)) {
652 if (obj && !PythonQtSlotFunction_Check(obj)) {
647 static const char* argumentList[] ={"" , "QFocusEvent*"};
653 static const char* argumentList[] ={"" , "QFocusEvent*"};
648 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
654 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
649 void* args[2] = {NULL, (void*)&arg__1};
655 void* args[2] = {NULL, (void*)&arg__1};
650 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
656 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
651 if (result) { Py_DECREF(result); }
657 if (result) { Py_DECREF(result); }
652 Py_DECREF(obj);
658 Py_DECREF(obj);
653 return;
659 return;
654 }
660 }
655 }
661 }
656 MemSizeWdgt::focusInEvent(arg__1);
662 MemSizeWdgt::focusInEvent(arg__1);
657 }
663 }
658 bool PythonQtShell_MemSizeWdgt::focusNextPrevChild(bool next)
664 bool PythonQtShell_MemSizeWdgt::focusNextPrevChild(bool next)
659 {
665 {
660 if (_wrapper) {
666 if (_wrapper) {
661 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
667 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
662 PyErr_Clear();
668 PyErr_Clear();
663 if (obj && !PythonQtSlotFunction_Check(obj)) {
669 if (obj && !PythonQtSlotFunction_Check(obj)) {
664 static const char* argumentList[] ={"bool" , "bool"};
670 static const char* argumentList[] ={"bool" , "bool"};
665 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
671 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
666 bool returnValue;
672 bool returnValue;
667 void* args[2] = {NULL, (void*)&next};
673 void* args[2] = {NULL, (void*)&next};
668 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
674 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
669 if (result) {
675 if (result) {
670 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
676 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
671 if (args[0]!=&returnValue) {
677 if (args[0]!=&returnValue) {
672 if (args[0]==NULL) {
678 if (args[0]==NULL) {
673 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
679 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
674 } else {
680 } else {
675 returnValue = *((bool*)args[0]);
681 returnValue = *((bool*)args[0]);
676 }
682 }
677 }
683 }
678 }
684 }
679 if (result) { Py_DECREF(result); }
685 if (result) { Py_DECREF(result); }
680 Py_DECREF(obj);
686 Py_DECREF(obj);
681 return returnValue;
687 return returnValue;
682 }
688 }
683 }
689 }
684 return MemSizeWdgt::focusNextPrevChild(next);
690 return MemSizeWdgt::focusNextPrevChild(next);
685 }
691 }
686 void PythonQtShell_MemSizeWdgt::focusOutEvent(QFocusEvent* arg__1)
692 void PythonQtShell_MemSizeWdgt::focusOutEvent(QFocusEvent* arg__1)
687 {
693 {
688 if (_wrapper) {
694 if (_wrapper) {
689 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
695 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
690 PyErr_Clear();
696 PyErr_Clear();
691 if (obj && !PythonQtSlotFunction_Check(obj)) {
697 if (obj && !PythonQtSlotFunction_Check(obj)) {
692 static const char* argumentList[] ={"" , "QFocusEvent*"};
698 static const char* argumentList[] ={"" , "QFocusEvent*"};
693 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
699 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
694 void* args[2] = {NULL, (void*)&arg__1};
700 void* args[2] = {NULL, (void*)&arg__1};
695 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
701 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
696 if (result) { Py_DECREF(result); }
702 if (result) { Py_DECREF(result); }
697 Py_DECREF(obj);
703 Py_DECREF(obj);
698 return;
704 return;
699 }
705 }
700 }
706 }
701 MemSizeWdgt::focusOutEvent(arg__1);
707 MemSizeWdgt::focusOutEvent(arg__1);
702 }
708 }
703 bool PythonQtShell_MemSizeWdgt::hasHeightForWidth() const
709 bool PythonQtShell_MemSizeWdgt::hasHeightForWidth() const
704 {
710 {
705 if (_wrapper) {
711 if (_wrapper) {
706 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
712 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
707 PyErr_Clear();
713 PyErr_Clear();
708 if (obj && !PythonQtSlotFunction_Check(obj)) {
714 if (obj && !PythonQtSlotFunction_Check(obj)) {
709 static const char* argumentList[] ={"bool"};
715 static const char* argumentList[] ={"bool"};
710 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
716 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
711 bool returnValue;
717 bool returnValue;
712 void* args[1] = {NULL};
718 void* args[1] = {NULL};
713 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
719 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
714 if (result) {
720 if (result) {
715 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
721 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
716 if (args[0]!=&returnValue) {
722 if (args[0]!=&returnValue) {
717 if (args[0]==NULL) {
723 if (args[0]==NULL) {
718 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
724 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
719 } else {
725 } else {
720 returnValue = *((bool*)args[0]);
726 returnValue = *((bool*)args[0]);
721 }
727 }
722 }
728 }
723 }
729 }
724 if (result) { Py_DECREF(result); }
730 if (result) { Py_DECREF(result); }
725 Py_DECREF(obj);
731 Py_DECREF(obj);
726 return returnValue;
732 return returnValue;
727 }
733 }
728 }
734 }
729 return MemSizeWdgt::hasHeightForWidth();
735 return MemSizeWdgt::hasHeightForWidth();
730 }
736 }
731 int PythonQtShell_MemSizeWdgt::heightForWidth(int arg__1) const
737 int PythonQtShell_MemSizeWdgt::heightForWidth(int arg__1) const
732 {
738 {
733 if (_wrapper) {
739 if (_wrapper) {
734 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
740 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
735 PyErr_Clear();
741 PyErr_Clear();
736 if (obj && !PythonQtSlotFunction_Check(obj)) {
742 if (obj && !PythonQtSlotFunction_Check(obj)) {
737 static const char* argumentList[] ={"int" , "int"};
743 static const char* argumentList[] ={"int" , "int"};
738 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
744 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
739 int returnValue;
745 int returnValue;
740 void* args[2] = {NULL, (void*)&arg__1};
746 void* args[2] = {NULL, (void*)&arg__1};
741 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
747 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
742 if (result) {
748 if (result) {
743 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
749 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
744 if (args[0]!=&returnValue) {
750 if (args[0]!=&returnValue) {
745 if (args[0]==NULL) {
751 if (args[0]==NULL) {
746 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
752 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
747 } else {
753 } else {
748 returnValue = *((int*)args[0]);
754 returnValue = *((int*)args[0]);
749 }
755 }
750 }
756 }
751 }
757 }
752 if (result) { Py_DECREF(result); }
758 if (result) { Py_DECREF(result); }
753 Py_DECREF(obj);
759 Py_DECREF(obj);
754 return returnValue;
760 return returnValue;
755 }
761 }
756 }
762 }
757 return MemSizeWdgt::heightForWidth(arg__1);
763 return MemSizeWdgt::heightForWidth(arg__1);
758 }
764 }
759 void PythonQtShell_MemSizeWdgt::hideEvent(QHideEvent* arg__1)
765 void PythonQtShell_MemSizeWdgt::hideEvent(QHideEvent* arg__1)
760 {
766 {
761 if (_wrapper) {
767 if (_wrapper) {
762 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
768 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
763 PyErr_Clear();
769 PyErr_Clear();
764 if (obj && !PythonQtSlotFunction_Check(obj)) {
770 if (obj && !PythonQtSlotFunction_Check(obj)) {
765 static const char* argumentList[] ={"" , "QHideEvent*"};
771 static const char* argumentList[] ={"" , "QHideEvent*"};
766 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
772 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
767 void* args[2] = {NULL, (void*)&arg__1};
773 void* args[2] = {NULL, (void*)&arg__1};
768 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
774 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
769 if (result) { Py_DECREF(result); }
775 if (result) { Py_DECREF(result); }
770 Py_DECREF(obj);
776 Py_DECREF(obj);
771 return;
777 return;
772 }
778 }
773 }
779 }
774 MemSizeWdgt::hideEvent(arg__1);
780 MemSizeWdgt::hideEvent(arg__1);
775 }
781 }
776 void PythonQtShell_MemSizeWdgt::initPainter(QPainter* painter) const
782 void PythonQtShell_MemSizeWdgt::initPainter(QPainter* painter) const
777 {
783 {
778 if (_wrapper) {
784 if (_wrapper) {
779 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
785 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
780 PyErr_Clear();
786 PyErr_Clear();
781 if (obj && !PythonQtSlotFunction_Check(obj)) {
787 if (obj && !PythonQtSlotFunction_Check(obj)) {
782 static const char* argumentList[] ={"" , "QPainter*"};
788 static const char* argumentList[] ={"" , "QPainter*"};
783 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
789 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
784 void* args[2] = {NULL, (void*)&painter};
790 void* args[2] = {NULL, (void*)&painter};
785 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
791 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
786 if (result) { Py_DECREF(result); }
792 if (result) { Py_DECREF(result); }
787 Py_DECREF(obj);
793 Py_DECREF(obj);
788 return;
794 return;
789 }
795 }
790 }
796 }
791 MemSizeWdgt::initPainter(painter);
797 MemSizeWdgt::initPainter(painter);
792 }
798 }
793 void PythonQtShell_MemSizeWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
799 void PythonQtShell_MemSizeWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
794 {
800 {
795 if (_wrapper) {
801 if (_wrapper) {
796 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
802 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
797 PyErr_Clear();
803 PyErr_Clear();
798 if (obj && !PythonQtSlotFunction_Check(obj)) {
804 if (obj && !PythonQtSlotFunction_Check(obj)) {
799 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
805 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
800 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
806 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
801 void* args[2] = {NULL, (void*)&arg__1};
807 void* args[2] = {NULL, (void*)&arg__1};
802 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
808 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
803 if (result) { Py_DECREF(result); }
809 if (result) { Py_DECREF(result); }
804 Py_DECREF(obj);
810 Py_DECREF(obj);
805 return;
811 return;
806 }
812 }
807 }
813 }
808 MemSizeWdgt::inputMethodEvent(arg__1);
814 MemSizeWdgt::inputMethodEvent(arg__1);
809 }
815 }
810 QVariant PythonQtShell_MemSizeWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
816 QVariant PythonQtShell_MemSizeWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
811 {
817 {
812 if (_wrapper) {
818 if (_wrapper) {
813 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
819 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
814 PyErr_Clear();
820 PyErr_Clear();
815 if (obj && !PythonQtSlotFunction_Check(obj)) {
821 if (obj && !PythonQtSlotFunction_Check(obj)) {
816 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
822 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
817 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
823 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
818 QVariant returnValue;
824 QVariant returnValue;
819 void* args[2] = {NULL, (void*)&arg__1};
825 void* args[2] = {NULL, (void*)&arg__1};
820 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
826 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
821 if (result) {
827 if (result) {
822 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
828 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
823 if (args[0]!=&returnValue) {
829 if (args[0]!=&returnValue) {
824 if (args[0]==NULL) {
830 if (args[0]==NULL) {
825 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
831 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
826 } else {
832 } else {
827 returnValue = *((QVariant*)args[0]);
833 returnValue = *((QVariant*)args[0]);
828 }
834 }
829 }
835 }
830 }
836 }
831 if (result) { Py_DECREF(result); }
837 if (result) { Py_DECREF(result); }
832 Py_DECREF(obj);
838 Py_DECREF(obj);
833 return returnValue;
839 return returnValue;
834 }
840 }
835 }
841 }
836 return MemSizeWdgt::inputMethodQuery(arg__1);
842 return MemSizeWdgt::inputMethodQuery(arg__1);
837 }
843 }
838 void PythonQtShell_MemSizeWdgt::keyPressEvent(QKeyEvent* arg__1)
844 void PythonQtShell_MemSizeWdgt::keyPressEvent(QKeyEvent* arg__1)
839 {
845 {
840 if (_wrapper) {
846 if (_wrapper) {
841 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
847 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
842 PyErr_Clear();
848 PyErr_Clear();
843 if (obj && !PythonQtSlotFunction_Check(obj)) {
849 if (obj && !PythonQtSlotFunction_Check(obj)) {
844 static const char* argumentList[] ={"" , "QKeyEvent*"};
850 static const char* argumentList[] ={"" , "QKeyEvent*"};
845 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
851 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
846 void* args[2] = {NULL, (void*)&arg__1};
852 void* args[2] = {NULL, (void*)&arg__1};
847 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
853 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
848 if (result) { Py_DECREF(result); }
854 if (result) { Py_DECREF(result); }
849 Py_DECREF(obj);
855 Py_DECREF(obj);
850 return;
856 return;
851 }
857 }
852 }
858 }
853 MemSizeWdgt::keyPressEvent(arg__1);
859 MemSizeWdgt::keyPressEvent(arg__1);
854 }
860 }
855 void PythonQtShell_MemSizeWdgt::keyReleaseEvent(QKeyEvent* arg__1)
861 void PythonQtShell_MemSizeWdgt::keyReleaseEvent(QKeyEvent* arg__1)
856 {
862 {
857 if (_wrapper) {
863 if (_wrapper) {
858 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
864 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
859 PyErr_Clear();
865 PyErr_Clear();
860 if (obj && !PythonQtSlotFunction_Check(obj)) {
866 if (obj && !PythonQtSlotFunction_Check(obj)) {
861 static const char* argumentList[] ={"" , "QKeyEvent*"};
867 static const char* argumentList[] ={"" , "QKeyEvent*"};
862 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
868 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
863 void* args[2] = {NULL, (void*)&arg__1};
869 void* args[2] = {NULL, (void*)&arg__1};
864 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
870 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
865 if (result) { Py_DECREF(result); }
871 if (result) { Py_DECREF(result); }
866 Py_DECREF(obj);
872 Py_DECREF(obj);
867 return;
873 return;
868 }
874 }
869 }
875 }
870 MemSizeWdgt::keyReleaseEvent(arg__1);
876 MemSizeWdgt::keyReleaseEvent(arg__1);
871 }
877 }
872 void PythonQtShell_MemSizeWdgt::leaveEvent(QEvent* arg__1)
878 void PythonQtShell_MemSizeWdgt::leaveEvent(QEvent* arg__1)
873 {
879 {
874 if (_wrapper) {
880 if (_wrapper) {
875 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
881 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
876 PyErr_Clear();
882 PyErr_Clear();
877 if (obj && !PythonQtSlotFunction_Check(obj)) {
883 if (obj && !PythonQtSlotFunction_Check(obj)) {
878 static const char* argumentList[] ={"" , "QEvent*"};
884 static const char* argumentList[] ={"" , "QEvent*"};
879 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
885 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
880 void* args[2] = {NULL, (void*)&arg__1};
886 void* args[2] = {NULL, (void*)&arg__1};
881 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
887 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
882 if (result) { Py_DECREF(result); }
888 if (result) { Py_DECREF(result); }
883 Py_DECREF(obj);
889 Py_DECREF(obj);
884 return;
890 return;
885 }
891 }
886 }
892 }
887 MemSizeWdgt::leaveEvent(arg__1);
893 MemSizeWdgt::leaveEvent(arg__1);
888 }
894 }
889 int PythonQtShell_MemSizeWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
895 int PythonQtShell_MemSizeWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
890 {
896 {
891 if (_wrapper) {
897 if (_wrapper) {
892 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
898 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
893 PyErr_Clear();
899 PyErr_Clear();
894 if (obj && !PythonQtSlotFunction_Check(obj)) {
900 if (obj && !PythonQtSlotFunction_Check(obj)) {
895 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
901 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
896 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
902 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
897 int returnValue;
903 int returnValue;
898 void* args[2] = {NULL, (void*)&arg__1};
904 void* args[2] = {NULL, (void*)&arg__1};
899 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
905 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
900 if (result) {
906 if (result) {
901 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
907 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
902 if (args[0]!=&returnValue) {
908 if (args[0]!=&returnValue) {
903 if (args[0]==NULL) {
909 if (args[0]==NULL) {
904 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
910 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
905 } else {
911 } else {
906 returnValue = *((int*)args[0]);
912 returnValue = *((int*)args[0]);
907 }
913 }
908 }
914 }
909 }
915 }
910 if (result) { Py_DECREF(result); }
916 if (result) { Py_DECREF(result); }
911 Py_DECREF(obj);
917 Py_DECREF(obj);
912 return returnValue;
918 return returnValue;
913 }
919 }
914 }
920 }
915 return MemSizeWdgt::metric(arg__1);
921 return MemSizeWdgt::metric(arg__1);
916 }
922 }
917 QSize PythonQtShell_MemSizeWdgt::minimumSizeHint() const
923 QSize PythonQtShell_MemSizeWdgt::minimumSizeHint() const
918 {
924 {
919 if (_wrapper) {
925 if (_wrapper) {
920 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
926 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
921 PyErr_Clear();
927 PyErr_Clear();
922 if (obj && !PythonQtSlotFunction_Check(obj)) {
928 if (obj && !PythonQtSlotFunction_Check(obj)) {
923 static const char* argumentList[] ={"QSize"};
929 static const char* argumentList[] ={"QSize"};
924 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
930 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
925 QSize returnValue;
931 QSize returnValue;
926 void* args[1] = {NULL};
932 void* args[1] = {NULL};
927 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
933 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
928 if (result) {
934 if (result) {
929 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
935 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
930 if (args[0]!=&returnValue) {
936 if (args[0]!=&returnValue) {
931 if (args[0]==NULL) {
937 if (args[0]==NULL) {
932 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
938 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
933 } else {
939 } else {
934 returnValue = *((QSize*)args[0]);
940 returnValue = *((QSize*)args[0]);
935 }
941 }
936 }
942 }
937 }
943 }
938 if (result) { Py_DECREF(result); }
944 if (result) { Py_DECREF(result); }
939 Py_DECREF(obj);
945 Py_DECREF(obj);
940 return returnValue;
946 return returnValue;
941 }
947 }
942 }
948 }
943 return MemSizeWdgt::minimumSizeHint();
949 return MemSizeWdgt::minimumSizeHint();
944 }
950 }
945 void PythonQtShell_MemSizeWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
951 void PythonQtShell_MemSizeWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
946 {
952 {
947 if (_wrapper) {
953 if (_wrapper) {
948 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
954 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
949 PyErr_Clear();
955 PyErr_Clear();
950 if (obj && !PythonQtSlotFunction_Check(obj)) {
956 if (obj && !PythonQtSlotFunction_Check(obj)) {
951 static const char* argumentList[] ={"" , "QMouseEvent*"};
957 static const char* argumentList[] ={"" , "QMouseEvent*"};
952 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
958 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
953 void* args[2] = {NULL, (void*)&arg__1};
959 void* args[2] = {NULL, (void*)&arg__1};
954 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
960 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
955 if (result) { Py_DECREF(result); }
961 if (result) { Py_DECREF(result); }
956 Py_DECREF(obj);
962 Py_DECREF(obj);
957 return;
963 return;
958 }
964 }
959 }
965 }
960 MemSizeWdgt::mouseDoubleClickEvent(arg__1);
966 MemSizeWdgt::mouseDoubleClickEvent(arg__1);
961 }
967 }
962 void PythonQtShell_MemSizeWdgt::mouseMoveEvent(QMouseEvent* arg__1)
968 void PythonQtShell_MemSizeWdgt::mouseMoveEvent(QMouseEvent* arg__1)
963 {
969 {
964 if (_wrapper) {
970 if (_wrapper) {
965 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
971 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
966 PyErr_Clear();
972 PyErr_Clear();
967 if (obj && !PythonQtSlotFunction_Check(obj)) {
973 if (obj && !PythonQtSlotFunction_Check(obj)) {
968 static const char* argumentList[] ={"" , "QMouseEvent*"};
974 static const char* argumentList[] ={"" , "QMouseEvent*"};
969 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
975 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
970 void* args[2] = {NULL, (void*)&arg__1};
976 void* args[2] = {NULL, (void*)&arg__1};
971 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
977 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
972 if (result) { Py_DECREF(result); }
978 if (result) { Py_DECREF(result); }
973 Py_DECREF(obj);
979 Py_DECREF(obj);
974 return;
980 return;
975 }
981 }
976 }
982 }
977 MemSizeWdgt::mouseMoveEvent(arg__1);
983 MemSizeWdgt::mouseMoveEvent(arg__1);
978 }
984 }
979 void PythonQtShell_MemSizeWdgt::mousePressEvent(QMouseEvent* arg__1)
985 void PythonQtShell_MemSizeWdgt::mousePressEvent(QMouseEvent* arg__1)
980 {
986 {
981 if (_wrapper) {
987 if (_wrapper) {
982 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
988 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
983 PyErr_Clear();
989 PyErr_Clear();
984 if (obj && !PythonQtSlotFunction_Check(obj)) {
990 if (obj && !PythonQtSlotFunction_Check(obj)) {
985 static const char* argumentList[] ={"" , "QMouseEvent*"};
991 static const char* argumentList[] ={"" , "QMouseEvent*"};
986 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
992 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
987 void* args[2] = {NULL, (void*)&arg__1};
993 void* args[2] = {NULL, (void*)&arg__1};
988 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
994 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
989 if (result) { Py_DECREF(result); }
995 if (result) { Py_DECREF(result); }
990 Py_DECREF(obj);
996 Py_DECREF(obj);
991 return;
997 return;
992 }
998 }
993 }
999 }
994 MemSizeWdgt::mousePressEvent(arg__1);
1000 MemSizeWdgt::mousePressEvent(arg__1);
995 }
1001 }
996 void PythonQtShell_MemSizeWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
1002 void PythonQtShell_MemSizeWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
997 {
1003 {
998 if (_wrapper) {
1004 if (_wrapper) {
999 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
1005 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
1000 PyErr_Clear();
1006 PyErr_Clear();
1001 if (obj && !PythonQtSlotFunction_Check(obj)) {
1007 if (obj && !PythonQtSlotFunction_Check(obj)) {
1002 static const char* argumentList[] ={"" , "QMouseEvent*"};
1008 static const char* argumentList[] ={"" , "QMouseEvent*"};
1003 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1009 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1004 void* args[2] = {NULL, (void*)&arg__1};
1010 void* args[2] = {NULL, (void*)&arg__1};
1005 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1011 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1006 if (result) { Py_DECREF(result); }
1012 if (result) { Py_DECREF(result); }
1007 Py_DECREF(obj);
1013 Py_DECREF(obj);
1008 return;
1014 return;
1009 }
1015 }
1010 }
1016 }
1011 MemSizeWdgt::mouseReleaseEvent(arg__1);
1017 MemSizeWdgt::mouseReleaseEvent(arg__1);
1012 }
1018 }
1013 void PythonQtShell_MemSizeWdgt::moveEvent(QMoveEvent* arg__1)
1019 void PythonQtShell_MemSizeWdgt::moveEvent(QMoveEvent* arg__1)
1014 {
1020 {
1015 if (_wrapper) {
1021 if (_wrapper) {
1016 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
1022 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
1017 PyErr_Clear();
1023 PyErr_Clear();
1018 if (obj && !PythonQtSlotFunction_Check(obj)) {
1024 if (obj && !PythonQtSlotFunction_Check(obj)) {
1019 static const char* argumentList[] ={"" , "QMoveEvent*"};
1025 static const char* argumentList[] ={"" , "QMoveEvent*"};
1020 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1026 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1021 void* args[2] = {NULL, (void*)&arg__1};
1027 void* args[2] = {NULL, (void*)&arg__1};
1022 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1028 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1023 if (result) { Py_DECREF(result); }
1029 if (result) { Py_DECREF(result); }
1024 Py_DECREF(obj);
1030 Py_DECREF(obj);
1025 return;
1031 return;
1026 }
1032 }
1027 }
1033 }
1028 MemSizeWdgt::moveEvent(arg__1);
1034 MemSizeWdgt::moveEvent(arg__1);
1029 }
1035 }
1030 bool PythonQtShell_MemSizeWdgt::nativeEvent(const QByteArray& eventType, void* message, long* result)
1036 bool PythonQtShell_MemSizeWdgt::nativeEvent(const QByteArray& eventType, void* message, long* result)
1031 {
1037 {
1032 if (_wrapper) {
1038 if (_wrapper) {
1033 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
1039 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
1034 PyErr_Clear();
1040 PyErr_Clear();
1035 if (obj && !PythonQtSlotFunction_Check(obj)) {
1041 if (obj && !PythonQtSlotFunction_Check(obj)) {
1036 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
1042 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
1037 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
1043 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
1038 bool returnValue;
1044 bool returnValue;
1039 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
1045 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
1040 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1046 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1041 if (result) {
1047 if (result) {
1042 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1048 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1043 if (args[0]!=&returnValue) {
1049 if (args[0]!=&returnValue) {
1044 if (args[0]==NULL) {
1050 if (args[0]==NULL) {
1045 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
1051 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
1046 } else {
1052 } else {
1047 returnValue = *((bool*)args[0]);
1053 returnValue = *((bool*)args[0]);
1048 }
1054 }
1049 }
1055 }
1050 }
1056 }
1051 if (result) { Py_DECREF(result); }
1057 if (result) { Py_DECREF(result); }
1052 Py_DECREF(obj);
1058 Py_DECREF(obj);
1053 return returnValue;
1059 return returnValue;
1054 }
1060 }
1055 }
1061 }
1056 return MemSizeWdgt::nativeEvent(eventType, message, result);
1062 return MemSizeWdgt::nativeEvent(eventType, message, result);
1057 }
1063 }
1058 QPaintEngine* PythonQtShell_MemSizeWdgt::paintEngine() const
1064 QPaintEngine* PythonQtShell_MemSizeWdgt::paintEngine() const
1059 {
1065 {
1060 if (_wrapper) {
1066 if (_wrapper) {
1061 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
1067 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
1062 PyErr_Clear();
1068 PyErr_Clear();
1063 if (obj && !PythonQtSlotFunction_Check(obj)) {
1069 if (obj && !PythonQtSlotFunction_Check(obj)) {
1064 static const char* argumentList[] ={"QPaintEngine*"};
1070 static const char* argumentList[] ={"QPaintEngine*"};
1065 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1071 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1066 QPaintEngine* returnValue;
1072 QPaintEngine* returnValue;
1067 void* args[1] = {NULL};
1073 void* args[1] = {NULL};
1068 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1074 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1069 if (result) {
1075 if (result) {
1070 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1076 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1071 if (args[0]!=&returnValue) {
1077 if (args[0]!=&returnValue) {
1072 if (args[0]==NULL) {
1078 if (args[0]==NULL) {
1073 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
1079 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
1074 } else {
1080 } else {
1075 returnValue = *((QPaintEngine**)args[0]);
1081 returnValue = *((QPaintEngine**)args[0]);
1076 }
1082 }
1077 }
1083 }
1078 }
1084 }
1079 if (result) { Py_DECREF(result); }
1085 if (result) { Py_DECREF(result); }
1080 Py_DECREF(obj);
1086 Py_DECREF(obj);
1081 return returnValue;
1087 return returnValue;
1082 }
1088 }
1083 }
1089 }
1084 return MemSizeWdgt::paintEngine();
1090 return MemSizeWdgt::paintEngine();
1085 }
1091 }
1086 void PythonQtShell_MemSizeWdgt::paintEvent(QPaintEvent* arg__1)
1092 void PythonQtShell_MemSizeWdgt::paintEvent(QPaintEvent* arg__1)
1087 {
1093 {
1088 if (_wrapper) {
1094 if (_wrapper) {
1089 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
1095 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
1090 PyErr_Clear();
1096 PyErr_Clear();
1091 if (obj && !PythonQtSlotFunction_Check(obj)) {
1097 if (obj && !PythonQtSlotFunction_Check(obj)) {
1092 static const char* argumentList[] ={"" , "QPaintEvent*"};
1098 static const char* argumentList[] ={"" , "QPaintEvent*"};
1093 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1099 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1094 void* args[2] = {NULL, (void*)&arg__1};
1100 void* args[2] = {NULL, (void*)&arg__1};
1095 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1101 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1096 if (result) { Py_DECREF(result); }
1102 if (result) { Py_DECREF(result); }
1097 Py_DECREF(obj);
1103 Py_DECREF(obj);
1098 return;
1104 return;
1099 }
1105 }
1100 }
1106 }
1101 MemSizeWdgt::paintEvent(arg__1);
1107 MemSizeWdgt::paintEvent(arg__1);
1102 }
1108 }
1103 QPaintDevice* PythonQtShell_MemSizeWdgt::redirected(QPoint* offset) const
1109 QPaintDevice* PythonQtShell_MemSizeWdgt::redirected(QPoint* offset) const
1104 {
1110 {
1105 if (_wrapper) {
1111 if (_wrapper) {
1106 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
1112 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
1107 PyErr_Clear();
1113 PyErr_Clear();
1108 if (obj && !PythonQtSlotFunction_Check(obj)) {
1114 if (obj && !PythonQtSlotFunction_Check(obj)) {
1109 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
1115 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
1110 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1116 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1111 QPaintDevice* returnValue;
1117 QPaintDevice* returnValue;
1112 void* args[2] = {NULL, (void*)&offset};
1118 void* args[2] = {NULL, (void*)&offset};
1113 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1119 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1114 if (result) {
1120 if (result) {
1115 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1121 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1116 if (args[0]!=&returnValue) {
1122 if (args[0]!=&returnValue) {
1117 if (args[0]==NULL) {
1123 if (args[0]==NULL) {
1118 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
1124 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
1119 } else {
1125 } else {
1120 returnValue = *((QPaintDevice**)args[0]);
1126 returnValue = *((QPaintDevice**)args[0]);
1121 }
1127 }
1122 }
1128 }
1123 }
1129 }
1124 if (result) { Py_DECREF(result); }
1130 if (result) { Py_DECREF(result); }
1125 Py_DECREF(obj);
1131 Py_DECREF(obj);
1126 return returnValue;
1132 return returnValue;
1127 }
1133 }
1128 }
1134 }
1129 return MemSizeWdgt::redirected(offset);
1135 return MemSizeWdgt::redirected(offset);
1130 }
1136 }
1131 void PythonQtShell_MemSizeWdgt::resizeEvent(QResizeEvent* arg__1)
1137 void PythonQtShell_MemSizeWdgt::resizeEvent(QResizeEvent* arg__1)
1132 {
1138 {
1133 if (_wrapper) {
1139 if (_wrapper) {
1134 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
1140 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
1135 PyErr_Clear();
1141 PyErr_Clear();
1136 if (obj && !PythonQtSlotFunction_Check(obj)) {
1142 if (obj && !PythonQtSlotFunction_Check(obj)) {
1137 static const char* argumentList[] ={"" , "QResizeEvent*"};
1143 static const char* argumentList[] ={"" , "QResizeEvent*"};
1138 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1144 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1139 void* args[2] = {NULL, (void*)&arg__1};
1145 void* args[2] = {NULL, (void*)&arg__1};
1140 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1146 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1141 if (result) { Py_DECREF(result); }
1147 if (result) { Py_DECREF(result); }
1142 Py_DECREF(obj);
1148 Py_DECREF(obj);
1143 return;
1149 return;
1144 }
1150 }
1145 }
1151 }
1146 MemSizeWdgt::resizeEvent(arg__1);
1152 MemSizeWdgt::resizeEvent(arg__1);
1147 }
1153 }
1148 QPainter* PythonQtShell_MemSizeWdgt::sharedPainter() const
1154 QPainter* PythonQtShell_MemSizeWdgt::sharedPainter() const
1149 {
1155 {
1150 if (_wrapper) {
1156 if (_wrapper) {
1151 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
1157 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
1152 PyErr_Clear();
1158 PyErr_Clear();
1153 if (obj && !PythonQtSlotFunction_Check(obj)) {
1159 if (obj && !PythonQtSlotFunction_Check(obj)) {
1154 static const char* argumentList[] ={"QPainter*"};
1160 static const char* argumentList[] ={"QPainter*"};
1155 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1161 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1156 QPainter* returnValue;
1162 QPainter* returnValue;
1157 void* args[1] = {NULL};
1163 void* args[1] = {NULL};
1158 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1164 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1159 if (result) {
1165 if (result) {
1160 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1166 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1161 if (args[0]!=&returnValue) {
1167 if (args[0]!=&returnValue) {
1162 if (args[0]==NULL) {
1168 if (args[0]==NULL) {
1163 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
1169 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
1164 } else {
1170 } else {
1165 returnValue = *((QPainter**)args[0]);
1171 returnValue = *((QPainter**)args[0]);
1166 }
1172 }
1167 }
1173 }
1168 }
1174 }
1169 if (result) { Py_DECREF(result); }
1175 if (result) { Py_DECREF(result); }
1170 Py_DECREF(obj);
1176 Py_DECREF(obj);
1171 return returnValue;
1177 return returnValue;
1172 }
1178 }
1173 }
1179 }
1174 return MemSizeWdgt::sharedPainter();
1180 return MemSizeWdgt::sharedPainter();
1175 }
1181 }
1176 void PythonQtShell_MemSizeWdgt::showEvent(QShowEvent* arg__1)
1182 void PythonQtShell_MemSizeWdgt::showEvent(QShowEvent* arg__1)
1177 {
1183 {
1178 if (_wrapper) {
1184 if (_wrapper) {
1179 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
1185 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
1180 PyErr_Clear();
1186 PyErr_Clear();
1181 if (obj && !PythonQtSlotFunction_Check(obj)) {
1187 if (obj && !PythonQtSlotFunction_Check(obj)) {
1182 static const char* argumentList[] ={"" , "QShowEvent*"};
1188 static const char* argumentList[] ={"" , "QShowEvent*"};
1183 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1189 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1184 void* args[2] = {NULL, (void*)&arg__1};
1190 void* args[2] = {NULL, (void*)&arg__1};
1185 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1191 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1186 if (result) { Py_DECREF(result); }
1192 if (result) { Py_DECREF(result); }
1187 Py_DECREF(obj);
1193 Py_DECREF(obj);
1188 return;
1194 return;
1189 }
1195 }
1190 }
1196 }
1191 MemSizeWdgt::showEvent(arg__1);
1197 MemSizeWdgt::showEvent(arg__1);
1192 }
1198 }
1193 QSize PythonQtShell_MemSizeWdgt::sizeHint() const
1199 QSize PythonQtShell_MemSizeWdgt::sizeHint() const
1194 {
1200 {
1195 if (_wrapper) {
1201 if (_wrapper) {
1196 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
1202 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
1197 PyErr_Clear();
1203 PyErr_Clear();
1198 if (obj && !PythonQtSlotFunction_Check(obj)) {
1204 if (obj && !PythonQtSlotFunction_Check(obj)) {
1199 static const char* argumentList[] ={"QSize"};
1205 static const char* argumentList[] ={"QSize"};
1200 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1206 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1201 QSize returnValue;
1207 QSize returnValue;
1202 void* args[1] = {NULL};
1208 void* args[1] = {NULL};
1203 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1209 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1204 if (result) {
1210 if (result) {
1205 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1211 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1206 if (args[0]!=&returnValue) {
1212 if (args[0]!=&returnValue) {
1207 if (args[0]==NULL) {
1213 if (args[0]==NULL) {
1208 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
1214 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
1209 } else {
1215 } else {
1210 returnValue = *((QSize*)args[0]);
1216 returnValue = *((QSize*)args[0]);
1211 }
1217 }
1212 }
1218 }
1213 }
1219 }
1214 if (result) { Py_DECREF(result); }
1220 if (result) { Py_DECREF(result); }
1215 Py_DECREF(obj);
1221 Py_DECREF(obj);
1216 return returnValue;
1222 return returnValue;
1217 }
1223 }
1218 }
1224 }
1219 return MemSizeWdgt::sizeHint();
1225 return MemSizeWdgt::sizeHint();
1220 }
1226 }
1221 void PythonQtShell_MemSizeWdgt::tabletEvent(QTabletEvent* arg__1)
1227 void PythonQtShell_MemSizeWdgt::tabletEvent(QTabletEvent* arg__1)
1222 {
1228 {
1223 if (_wrapper) {
1229 if (_wrapper) {
1224 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
1230 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
1225 PyErr_Clear();
1231 PyErr_Clear();
1226 if (obj && !PythonQtSlotFunction_Check(obj)) {
1232 if (obj && !PythonQtSlotFunction_Check(obj)) {
1227 static const char* argumentList[] ={"" , "QTabletEvent*"};
1233 static const char* argumentList[] ={"" , "QTabletEvent*"};
1228 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1234 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1229 void* args[2] = {NULL, (void*)&arg__1};
1235 void* args[2] = {NULL, (void*)&arg__1};
1230 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1236 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1231 if (result) { Py_DECREF(result); }
1237 if (result) { Py_DECREF(result); }
1232 Py_DECREF(obj);
1238 Py_DECREF(obj);
1233 return;
1239 return;
1234 }
1240 }
1235 }
1241 }
1236 MemSizeWdgt::tabletEvent(arg__1);
1242 MemSizeWdgt::tabletEvent(arg__1);
1237 }
1243 }
1238 void PythonQtShell_MemSizeWdgt::timerEvent(QTimerEvent* arg__1)
1244 void PythonQtShell_MemSizeWdgt::timerEvent(QTimerEvent* arg__1)
1239 {
1245 {
1240 if (_wrapper) {
1246 if (_wrapper) {
1241 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
1247 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
1242 PyErr_Clear();
1248 PyErr_Clear();
1243 if (obj && !PythonQtSlotFunction_Check(obj)) {
1249 if (obj && !PythonQtSlotFunction_Check(obj)) {
1244 static const char* argumentList[] ={"" , "QTimerEvent*"};
1250 static const char* argumentList[] ={"" , "QTimerEvent*"};
1245 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1251 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1246 void* args[2] = {NULL, (void*)&arg__1};
1252 void* args[2] = {NULL, (void*)&arg__1};
1247 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1253 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1248 if (result) { Py_DECREF(result); }
1254 if (result) { Py_DECREF(result); }
1249 Py_DECREF(obj);
1255 Py_DECREF(obj);
1250 return;
1256 return;
1251 }
1257 }
1252 }
1258 }
1253 MemSizeWdgt::timerEvent(arg__1);
1259 MemSizeWdgt::timerEvent(arg__1);
1254 }
1260 }
1255 void PythonQtShell_MemSizeWdgt::wheelEvent(QWheelEvent* arg__1)
1261 void PythonQtShell_MemSizeWdgt::wheelEvent(QWheelEvent* arg__1)
1256 {
1262 {
1257 if (_wrapper) {
1263 if (_wrapper) {
1258 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
1264 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
1259 PyErr_Clear();
1265 PyErr_Clear();
1260 if (obj && !PythonQtSlotFunction_Check(obj)) {
1266 if (obj && !PythonQtSlotFunction_Check(obj)) {
1261 static const char* argumentList[] ={"" , "QWheelEvent*"};
1267 static const char* argumentList[] ={"" , "QWheelEvent*"};
1262 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1268 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1263 void* args[2] = {NULL, (void*)&arg__1};
1269 void* args[2] = {NULL, (void*)&arg__1};
1264 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1270 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1265 if (result) { Py_DECREF(result); }
1271 if (result) { Py_DECREF(result); }
1266 Py_DECREF(obj);
1272 Py_DECREF(obj);
1267 return;
1273 return;
1268 }
1274 }
1269 }
1275 }
1270 MemSizeWdgt::wheelEvent(arg__1);
1276 MemSizeWdgt::wheelEvent(arg__1);
1271 }
1277 }
1272 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(QWidget* parent)
1278 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(QWidget* parent)
1273 {
1279 {
1274 return new PythonQtShell_MemSizeWdgt(parent); }
1280 return new PythonQtShell_MemSizeWdgt(parent); }
1275
1281
1276 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(int defaultSize, QWidget* parent)
1282 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(int defaultSize, QWidget* parent)
1277 {
1283 {
1278 return new PythonQtShell_MemSizeWdgt(defaultSize, parent); }
1284 return new PythonQtShell_MemSizeWdgt(defaultSize, parent); }
1279
1285
1280 int PythonQtWrapper_MemSizeWdgt::getsize(MemSizeWdgt* theWrappedObject)
1286 int PythonQtWrapper_MemSizeWdgt::getsize(MemSizeWdgt* theWrappedObject)
1281 {
1287 {
1282 return ( theWrappedObject->getsize());
1288 return ( theWrappedObject->getsize());
1283 }
1289 }
1284
1290
1285 void PythonQtWrapper_MemSizeWdgt::setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max)
1291 void PythonQtWrapper_MemSizeWdgt::setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max)
1286 {
1292 {
1287 ( theWrappedObject->setMaximum(max));
1293 ( theWrappedObject->setMaximum(max));
1288 }
1294 }
1289
1295
1290 void PythonQtWrapper_MemSizeWdgt::show(MemSizeWdgt* theWrappedObject)
1296 void PythonQtWrapper_MemSizeWdgt::show(MemSizeWdgt* theWrappedObject)
1291 {
1297 {
1292 ( theWrappedObject->show());
1298 ( theWrappedObject->show());
1293 }
1299 }
1294
1300
1295 void PythonQtWrapper_MemSizeWdgt::updateSizeValue(MemSizeWdgt* theWrappedObject)
1301 void PythonQtWrapper_MemSizeWdgt::updateSizeValue(MemSizeWdgt* theWrappedObject)
1296 {
1302 {
1297 ( theWrappedObject->updateSizeValue());
1303 ( theWrappedObject->updateSizeValue());
1298 }
1304 }
1299
1305
1300
1306
1301
1307
1302 PythonQtShell_QHexEdit::~PythonQtShell_QHexEdit() {
1308 PythonQtShell_QHexEdit::~PythonQtShell_QHexEdit() {
1303 PythonQtPrivate* priv = PythonQt::priv();
1309 PythonQtPrivate* priv = PythonQt::priv();
1304 if (priv) { priv->shellClassDeleted(this); }
1310 if (priv) { priv->shellClassDeleted(this); }
1305 }
1311 }
1306 void PythonQtShell_QHexEdit::actionEvent(QActionEvent* arg__1)
1312 void PythonQtShell_QHexEdit::actionEvent(QActionEvent* arg__1)
1307 {
1313 {
1308 if (_wrapper) {
1314 if (_wrapper) {
1309 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
1315 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
1310 PyErr_Clear();
1316 PyErr_Clear();
1311 if (obj && !PythonQtSlotFunction_Check(obj)) {
1317 if (obj && !PythonQtSlotFunction_Check(obj)) {
1312 static const char* argumentList[] ={"" , "QActionEvent*"};
1318 static const char* argumentList[] ={"" , "QActionEvent*"};
1313 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1319 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1314 void* args[2] = {NULL, (void*)&arg__1};
1320 void* args[2] = {NULL, (void*)&arg__1};
1315 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1321 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1316 if (result) { Py_DECREF(result); }
1322 if (result) { Py_DECREF(result); }
1317 Py_DECREF(obj);
1323 Py_DECREF(obj);
1318 return;
1324 return;
1319 }
1325 }
1320 }
1326 }
1321 QHexEdit::actionEvent(arg__1);
1327 QHexEdit::actionEvent(arg__1);
1322 }
1328 }
1323 void PythonQtShell_QHexEdit::changeEvent(QEvent* arg__1)
1329 void PythonQtShell_QHexEdit::changeEvent(QEvent* arg__1)
1324 {
1330 {
1325 if (_wrapper) {
1331 if (_wrapper) {
1326 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
1332 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
1327 PyErr_Clear();
1333 PyErr_Clear();
1328 if (obj && !PythonQtSlotFunction_Check(obj)) {
1334 if (obj && !PythonQtSlotFunction_Check(obj)) {
1329 static const char* argumentList[] ={"" , "QEvent*"};
1335 static const char* argumentList[] ={"" , "QEvent*"};
1330 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1336 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1331 void* args[2] = {NULL, (void*)&arg__1};
1337 void* args[2] = {NULL, (void*)&arg__1};
1332 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1338 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1333 if (result) { Py_DECREF(result); }
1339 if (result) { Py_DECREF(result); }
1334 Py_DECREF(obj);
1340 Py_DECREF(obj);
1335 return;
1341 return;
1336 }
1342 }
1337 }
1343 }
1338 QHexEdit::changeEvent(arg__1);
1344 QHexEdit::changeEvent(arg__1);
1339 }
1345 }
1340 void PythonQtShell_QHexEdit::childEvent(QChildEvent* arg__1)
1346 void PythonQtShell_QHexEdit::childEvent(QChildEvent* arg__1)
1341 {
1347 {
1342 if (_wrapper) {
1348 if (_wrapper) {
1343 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
1349 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
1344 PyErr_Clear();
1350 PyErr_Clear();
1345 if (obj && !PythonQtSlotFunction_Check(obj)) {
1351 if (obj && !PythonQtSlotFunction_Check(obj)) {
1346 static const char* argumentList[] ={"" , "QChildEvent*"};
1352 static const char* argumentList[] ={"" , "QChildEvent*"};
1347 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1353 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1348 void* args[2] = {NULL, (void*)&arg__1};
1354 void* args[2] = {NULL, (void*)&arg__1};
1349 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1355 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1350 if (result) { Py_DECREF(result); }
1356 if (result) { Py_DECREF(result); }
1351 Py_DECREF(obj);
1357 Py_DECREF(obj);
1352 return;
1358 return;
1353 }
1359 }
1354 }
1360 }
1355 QHexEdit::childEvent(arg__1);
1361 QHexEdit::childEvent(arg__1);
1356 }
1362 }
1357 void PythonQtShell_QHexEdit::closeEvent(QCloseEvent* arg__1)
1363 void PythonQtShell_QHexEdit::closeEvent(QCloseEvent* arg__1)
1358 {
1364 {
1359 if (_wrapper) {
1365 if (_wrapper) {
1360 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
1366 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
1361 PyErr_Clear();
1367 PyErr_Clear();
1362 if (obj && !PythonQtSlotFunction_Check(obj)) {
1368 if (obj && !PythonQtSlotFunction_Check(obj)) {
1363 static const char* argumentList[] ={"" , "QCloseEvent*"};
1369 static const char* argumentList[] ={"" , "QCloseEvent*"};
1364 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1370 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1365 void* args[2] = {NULL, (void*)&arg__1};
1371 void* args[2] = {NULL, (void*)&arg__1};
1366 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1372 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1367 if (result) { Py_DECREF(result); }
1373 if (result) { Py_DECREF(result); }
1368 Py_DECREF(obj);
1374 Py_DECREF(obj);
1369 return;
1375 return;
1370 }
1376 }
1371 }
1377 }
1372 QHexEdit::closeEvent(arg__1);
1378 QHexEdit::closeEvent(arg__1);
1373 }
1379 }
1374 void PythonQtShell_QHexEdit::contextMenuEvent(QContextMenuEvent* arg__1)
1380 void PythonQtShell_QHexEdit::contextMenuEvent(QContextMenuEvent* arg__1)
1375 {
1381 {
1376 if (_wrapper) {
1382 if (_wrapper) {
1377 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
1383 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
1378 PyErr_Clear();
1384 PyErr_Clear();
1379 if (obj && !PythonQtSlotFunction_Check(obj)) {
1385 if (obj && !PythonQtSlotFunction_Check(obj)) {
1380 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
1386 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
1381 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1387 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1382 void* args[2] = {NULL, (void*)&arg__1};
1388 void* args[2] = {NULL, (void*)&arg__1};
1383 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1389 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1384 if (result) { Py_DECREF(result); }
1390 if (result) { Py_DECREF(result); }
1385 Py_DECREF(obj);
1391 Py_DECREF(obj);
1386 return;
1392 return;
1387 }
1393 }
1388 }
1394 }
1389 QHexEdit::contextMenuEvent(arg__1);
1395 QHexEdit::contextMenuEvent(arg__1);
1390 }
1396 }
1391 void PythonQtShell_QHexEdit::customEvent(QEvent* arg__1)
1397 void PythonQtShell_QHexEdit::customEvent(QEvent* arg__1)
1392 {
1398 {
1393 if (_wrapper) {
1399 if (_wrapper) {
1394 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
1400 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
1395 PyErr_Clear();
1401 PyErr_Clear();
1396 if (obj && !PythonQtSlotFunction_Check(obj)) {
1402 if (obj && !PythonQtSlotFunction_Check(obj)) {
1397 static const char* argumentList[] ={"" , "QEvent*"};
1403 static const char* argumentList[] ={"" , "QEvent*"};
1398 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1404 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1399 void* args[2] = {NULL, (void*)&arg__1};
1405 void* args[2] = {NULL, (void*)&arg__1};
1400 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1406 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1401 if (result) { Py_DECREF(result); }
1407 if (result) { Py_DECREF(result); }
1402 Py_DECREF(obj);
1408 Py_DECREF(obj);
1403 return;
1409 return;
1404 }
1410 }
1405 }
1411 }
1406 QHexEdit::customEvent(arg__1);
1412 QHexEdit::customEvent(arg__1);
1407 }
1413 }
1408 int PythonQtShell_QHexEdit::devType() const
1414 int PythonQtShell_QHexEdit::devType() const
1409 {
1415 {
1410 if (_wrapper) {
1416 if (_wrapper) {
1411 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
1417 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
1412 PyErr_Clear();
1418 PyErr_Clear();
1413 if (obj && !PythonQtSlotFunction_Check(obj)) {
1419 if (obj && !PythonQtSlotFunction_Check(obj)) {
1414 static const char* argumentList[] ={"int"};
1420 static const char* argumentList[] ={"int"};
1415 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1421 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1416 int returnValue;
1422 int returnValue;
1417 void* args[1] = {NULL};
1423 void* args[1] = {NULL};
1418 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1424 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1419 if (result) {
1425 if (result) {
1420 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1426 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1421 if (args[0]!=&returnValue) {
1427 if (args[0]!=&returnValue) {
1422 if (args[0]==NULL) {
1428 if (args[0]==NULL) {
1423 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
1429 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
1424 } else {
1430 } else {
1425 returnValue = *((int*)args[0]);
1431 returnValue = *((int*)args[0]);
1426 }
1432 }
1427 }
1433 }
1428 }
1434 }
1429 if (result) { Py_DECREF(result); }
1435 if (result) { Py_DECREF(result); }
1430 Py_DECREF(obj);
1436 Py_DECREF(obj);
1431 return returnValue;
1437 return returnValue;
1432 }
1438 }
1433 }
1439 }
1434 return QHexEdit::devType();
1440 return QHexEdit::devType();
1435 }
1441 }
1436 void PythonQtShell_QHexEdit::dragEnterEvent(QDragEnterEvent* arg__1)
1442 void PythonQtShell_QHexEdit::dragEnterEvent(QDragEnterEvent* arg__1)
1437 {
1443 {
1438 if (_wrapper) {
1444 if (_wrapper) {
1439 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
1445 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
1440 PyErr_Clear();
1446 PyErr_Clear();
1441 if (obj && !PythonQtSlotFunction_Check(obj)) {
1447 if (obj && !PythonQtSlotFunction_Check(obj)) {
1442 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
1448 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
1443 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1449 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1444 void* args[2] = {NULL, (void*)&arg__1};
1450 void* args[2] = {NULL, (void*)&arg__1};
1445 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1451 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1446 if (result) { Py_DECREF(result); }
1452 if (result) { Py_DECREF(result); }
1447 Py_DECREF(obj);
1453 Py_DECREF(obj);
1448 return;
1454 return;
1449 }
1455 }
1450 }
1456 }
1451 QHexEdit::dragEnterEvent(arg__1);
1457 QHexEdit::dragEnterEvent(arg__1);
1452 }
1458 }
1453 void PythonQtShell_QHexEdit::dragLeaveEvent(QDragLeaveEvent* arg__1)
1459 void PythonQtShell_QHexEdit::dragLeaveEvent(QDragLeaveEvent* arg__1)
1454 {
1460 {
1455 if (_wrapper) {
1461 if (_wrapper) {
1456 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
1462 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
1457 PyErr_Clear();
1463 PyErr_Clear();
1458 if (obj && !PythonQtSlotFunction_Check(obj)) {
1464 if (obj && !PythonQtSlotFunction_Check(obj)) {
1459 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
1465 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
1460 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1466 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1461 void* args[2] = {NULL, (void*)&arg__1};
1467 void* args[2] = {NULL, (void*)&arg__1};
1462 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1468 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1463 if (result) { Py_DECREF(result); }
1469 if (result) { Py_DECREF(result); }
1464 Py_DECREF(obj);
1470 Py_DECREF(obj);
1465 return;
1471 return;
1466 }
1472 }
1467 }
1473 }
1468 QHexEdit::dragLeaveEvent(arg__1);
1474 QHexEdit::dragLeaveEvent(arg__1);
1469 }
1475 }
1470 void PythonQtShell_QHexEdit::dragMoveEvent(QDragMoveEvent* arg__1)
1476 void PythonQtShell_QHexEdit::dragMoveEvent(QDragMoveEvent* arg__1)
1471 {
1477 {
1472 if (_wrapper) {
1478 if (_wrapper) {
1473 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
1479 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
1474 PyErr_Clear();
1480 PyErr_Clear();
1475 if (obj && !PythonQtSlotFunction_Check(obj)) {
1481 if (obj && !PythonQtSlotFunction_Check(obj)) {
1476 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
1482 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
1477 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1483 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1478 void* args[2] = {NULL, (void*)&arg__1};
1484 void* args[2] = {NULL, (void*)&arg__1};
1479 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1485 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1480 if (result) { Py_DECREF(result); }
1486 if (result) { Py_DECREF(result); }
1481 Py_DECREF(obj);
1487 Py_DECREF(obj);
1482 return;
1488 return;
1483 }
1489 }
1484 }
1490 }
1485 QHexEdit::dragMoveEvent(arg__1);
1491 QHexEdit::dragMoveEvent(arg__1);
1486 }
1492 }
1487 void PythonQtShell_QHexEdit::dropEvent(QDropEvent* arg__1)
1493 void PythonQtShell_QHexEdit::dropEvent(QDropEvent* arg__1)
1488 {
1494 {
1489 if (_wrapper) {
1495 if (_wrapper) {
1490 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
1496 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
1491 PyErr_Clear();
1497 PyErr_Clear();
1492 if (obj && !PythonQtSlotFunction_Check(obj)) {
1498 if (obj && !PythonQtSlotFunction_Check(obj)) {
1493 static const char* argumentList[] ={"" , "QDropEvent*"};
1499 static const char* argumentList[] ={"" , "QDropEvent*"};
1494 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1500 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1495 void* args[2] = {NULL, (void*)&arg__1};
1501 void* args[2] = {NULL, (void*)&arg__1};
1496 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1502 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1497 if (result) { Py_DECREF(result); }
1503 if (result) { Py_DECREF(result); }
1498 Py_DECREF(obj);
1504 Py_DECREF(obj);
1499 return;
1505 return;
1500 }
1506 }
1501 }
1507 }
1502 QHexEdit::dropEvent(arg__1);
1508 QHexEdit::dropEvent(arg__1);
1503 }
1509 }
1504 void PythonQtShell_QHexEdit::enterEvent(QEvent* arg__1)
1510 void PythonQtShell_QHexEdit::enterEvent(QEvent* arg__1)
1505 {
1511 {
1506 if (_wrapper) {
1512 if (_wrapper) {
1507 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
1513 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
1508 PyErr_Clear();
1514 PyErr_Clear();
1509 if (obj && !PythonQtSlotFunction_Check(obj)) {
1515 if (obj && !PythonQtSlotFunction_Check(obj)) {
1510 static const char* argumentList[] ={"" , "QEvent*"};
1516 static const char* argumentList[] ={"" , "QEvent*"};
1511 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1517 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1512 void* args[2] = {NULL, (void*)&arg__1};
1518 void* args[2] = {NULL, (void*)&arg__1};
1513 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1519 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1514 if (result) { Py_DECREF(result); }
1520 if (result) { Py_DECREF(result); }
1515 Py_DECREF(obj);
1521 Py_DECREF(obj);
1516 return;
1522 return;
1517 }
1523 }
1518 }
1524 }
1519 QHexEdit::enterEvent(arg__1);
1525 QHexEdit::enterEvent(arg__1);
1520 }
1526 }
1521 bool PythonQtShell_QHexEdit::event(QEvent* arg__1)
1527 bool PythonQtShell_QHexEdit::event(QEvent* arg__1)
1522 {
1528 {
1523 if (_wrapper) {
1529 if (_wrapper) {
1524 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
1530 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
1525 PyErr_Clear();
1531 PyErr_Clear();
1526 if (obj && !PythonQtSlotFunction_Check(obj)) {
1532 if (obj && !PythonQtSlotFunction_Check(obj)) {
1527 static const char* argumentList[] ={"bool" , "QEvent*"};
1533 static const char* argumentList[] ={"bool" , "QEvent*"};
1528 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1534 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1529 bool returnValue;
1535 bool returnValue;
1530 void* args[2] = {NULL, (void*)&arg__1};
1536 void* args[2] = {NULL, (void*)&arg__1};
1531 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1537 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1532 if (result) {
1538 if (result) {
1533 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1539 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1534 if (args[0]!=&returnValue) {
1540 if (args[0]!=&returnValue) {
1535 if (args[0]==NULL) {
1541 if (args[0]==NULL) {
1536 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
1542 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
1537 } else {
1543 } else {
1538 returnValue = *((bool*)args[0]);
1544 returnValue = *((bool*)args[0]);
1539 }
1545 }
1540 }
1546 }
1541 }
1547 }
1542 if (result) { Py_DECREF(result); }
1548 if (result) { Py_DECREF(result); }
1543 Py_DECREF(obj);
1549 Py_DECREF(obj);
1544 return returnValue;
1550 return returnValue;
1545 }
1551 }
1546 }
1552 }
1547 return QHexEdit::event(arg__1);
1553 return QHexEdit::event(arg__1);
1548 }
1554 }
1549 bool PythonQtShell_QHexEdit::eventFilter(QObject* arg__1, QEvent* arg__2)
1555 bool PythonQtShell_QHexEdit::eventFilter(QObject* arg__1, QEvent* arg__2)
1550 {
1556 {
1551 if (_wrapper) {
1557 if (_wrapper) {
1552 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
1558 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
1553 PyErr_Clear();
1559 PyErr_Clear();
1554 if (obj && !PythonQtSlotFunction_Check(obj)) {
1560 if (obj && !PythonQtSlotFunction_Check(obj)) {
1555 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
1561 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
1556 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
1562 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
1557 bool returnValue;
1563 bool returnValue;
1558 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
1564 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
1559 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1565 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1560 if (result) {
1566 if (result) {
1561 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1567 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1562 if (args[0]!=&returnValue) {
1568 if (args[0]!=&returnValue) {
1563 if (args[0]==NULL) {
1569 if (args[0]==NULL) {
1564 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
1570 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
1565 } else {
1571 } else {
1566 returnValue = *((bool*)args[0]);
1572 returnValue = *((bool*)args[0]);
1567 }
1573 }
1568 }
1574 }
1569 }
1575 }
1570 if (result) { Py_DECREF(result); }
1576 if (result) { Py_DECREF(result); }
1571 Py_DECREF(obj);
1577 Py_DECREF(obj);
1572 return returnValue;
1578 return returnValue;
1573 }
1579 }
1574 }
1580 }
1575 return QHexEdit::eventFilter(arg__1, arg__2);
1581 return QHexEdit::eventFilter(arg__1, arg__2);
1576 }
1582 }
1577 void PythonQtShell_QHexEdit::focusInEvent(QFocusEvent* arg__1)
1583 void PythonQtShell_QHexEdit::focusInEvent(QFocusEvent* arg__1)
1578 {
1584 {
1579 if (_wrapper) {
1585 if (_wrapper) {
1580 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
1586 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
1581 PyErr_Clear();
1587 PyErr_Clear();
1582 if (obj && !PythonQtSlotFunction_Check(obj)) {
1588 if (obj && !PythonQtSlotFunction_Check(obj)) {
1583 static const char* argumentList[] ={"" , "QFocusEvent*"};
1589 static const char* argumentList[] ={"" , "QFocusEvent*"};
1584 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1590 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1585 void* args[2] = {NULL, (void*)&arg__1};
1591 void* args[2] = {NULL, (void*)&arg__1};
1586 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1592 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1587 if (result) { Py_DECREF(result); }
1593 if (result) { Py_DECREF(result); }
1588 Py_DECREF(obj);
1594 Py_DECREF(obj);
1589 return;
1595 return;
1590 }
1596 }
1591 }
1597 }
1592 QHexEdit::focusInEvent(arg__1);
1598 QHexEdit::focusInEvent(arg__1);
1593 }
1599 }
1594 bool PythonQtShell_QHexEdit::focusNextPrevChild(bool next)
1600 bool PythonQtShell_QHexEdit::focusNextPrevChild(bool next)
1595 {
1601 {
1596 if (_wrapper) {
1602 if (_wrapper) {
1597 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
1603 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
1598 PyErr_Clear();
1604 PyErr_Clear();
1599 if (obj && !PythonQtSlotFunction_Check(obj)) {
1605 if (obj && !PythonQtSlotFunction_Check(obj)) {
1600 static const char* argumentList[] ={"bool" , "bool"};
1606 static const char* argumentList[] ={"bool" , "bool"};
1601 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1607 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1602 bool returnValue;
1608 bool returnValue;
1603 void* args[2] = {NULL, (void*)&next};
1609 void* args[2] = {NULL, (void*)&next};
1604 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1610 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1605 if (result) {
1611 if (result) {
1606 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1612 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1607 if (args[0]!=&returnValue) {
1613 if (args[0]!=&returnValue) {
1608 if (args[0]==NULL) {
1614 if (args[0]==NULL) {
1609 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
1615 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
1610 } else {
1616 } else {
1611 returnValue = *((bool*)args[0]);
1617 returnValue = *((bool*)args[0]);
1612 }
1618 }
1613 }
1619 }
1614 }
1620 }
1615 if (result) { Py_DECREF(result); }
1621 if (result) { Py_DECREF(result); }
1616 Py_DECREF(obj);
1622 Py_DECREF(obj);
1617 return returnValue;
1623 return returnValue;
1618 }
1624 }
1619 }
1625 }
1620 return QHexEdit::focusNextPrevChild(next);
1626 return QHexEdit::focusNextPrevChild(next);
1621 }
1627 }
1622 void PythonQtShell_QHexEdit::focusOutEvent(QFocusEvent* arg__1)
1628 void PythonQtShell_QHexEdit::focusOutEvent(QFocusEvent* arg__1)
1623 {
1629 {
1624 if (_wrapper) {
1630 if (_wrapper) {
1625 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
1631 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
1626 PyErr_Clear();
1632 PyErr_Clear();
1627 if (obj && !PythonQtSlotFunction_Check(obj)) {
1633 if (obj && !PythonQtSlotFunction_Check(obj)) {
1628 static const char* argumentList[] ={"" , "QFocusEvent*"};
1634 static const char* argumentList[] ={"" , "QFocusEvent*"};
1629 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1635 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1630 void* args[2] = {NULL, (void*)&arg__1};
1636 void* args[2] = {NULL, (void*)&arg__1};
1631 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1637 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1632 if (result) { Py_DECREF(result); }
1638 if (result) { Py_DECREF(result); }
1633 Py_DECREF(obj);
1639 Py_DECREF(obj);
1634 return;
1640 return;
1635 }
1641 }
1636 }
1642 }
1637 QHexEdit::focusOutEvent(arg__1);
1643 QHexEdit::focusOutEvent(arg__1);
1638 }
1644 }
1639 bool PythonQtShell_QHexEdit::hasHeightForWidth() const
1645 bool PythonQtShell_QHexEdit::hasHeightForWidth() const
1640 {
1646 {
1641 if (_wrapper) {
1647 if (_wrapper) {
1642 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
1648 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
1643 PyErr_Clear();
1649 PyErr_Clear();
1644 if (obj && !PythonQtSlotFunction_Check(obj)) {
1650 if (obj && !PythonQtSlotFunction_Check(obj)) {
1645 static const char* argumentList[] ={"bool"};
1651 static const char* argumentList[] ={"bool"};
1646 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1652 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1647 bool returnValue;
1653 bool returnValue;
1648 void* args[1] = {NULL};
1654 void* args[1] = {NULL};
1649 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1655 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1650 if (result) {
1656 if (result) {
1651 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1657 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1652 if (args[0]!=&returnValue) {
1658 if (args[0]!=&returnValue) {
1653 if (args[0]==NULL) {
1659 if (args[0]==NULL) {
1654 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
1660 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
1655 } else {
1661 } else {
1656 returnValue = *((bool*)args[0]);
1662 returnValue = *((bool*)args[0]);
1657 }
1663 }
1658 }
1664 }
1659 }
1665 }
1660 if (result) { Py_DECREF(result); }
1666 if (result) { Py_DECREF(result); }
1661 Py_DECREF(obj);
1667 Py_DECREF(obj);
1662 return returnValue;
1668 return returnValue;
1663 }
1669 }
1664 }
1670 }
1665 return QHexEdit::hasHeightForWidth();
1671 return QHexEdit::hasHeightForWidth();
1666 }
1672 }
1667 int PythonQtShell_QHexEdit::heightForWidth(int arg__1) const
1673 int PythonQtShell_QHexEdit::heightForWidth(int arg__1) const
1668 {
1674 {
1669 if (_wrapper) {
1675 if (_wrapper) {
1670 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
1676 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
1671 PyErr_Clear();
1677 PyErr_Clear();
1672 if (obj && !PythonQtSlotFunction_Check(obj)) {
1678 if (obj && !PythonQtSlotFunction_Check(obj)) {
1673 static const char* argumentList[] ={"int" , "int"};
1679 static const char* argumentList[] ={"int" , "int"};
1674 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1680 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1675 int returnValue;
1681 int returnValue;
1676 void* args[2] = {NULL, (void*)&arg__1};
1682 void* args[2] = {NULL, (void*)&arg__1};
1677 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1683 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1678 if (result) {
1684 if (result) {
1679 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1685 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1680 if (args[0]!=&returnValue) {
1686 if (args[0]!=&returnValue) {
1681 if (args[0]==NULL) {
1687 if (args[0]==NULL) {
1682 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
1688 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
1683 } else {
1689 } else {
1684 returnValue = *((int*)args[0]);
1690 returnValue = *((int*)args[0]);
1685 }
1691 }
1686 }
1692 }
1687 }
1693 }
1688 if (result) { Py_DECREF(result); }
1694 if (result) { Py_DECREF(result); }
1689 Py_DECREF(obj);
1695 Py_DECREF(obj);
1690 return returnValue;
1696 return returnValue;
1691 }
1697 }
1692 }
1698 }
1693 return QHexEdit::heightForWidth(arg__1);
1699 return QHexEdit::heightForWidth(arg__1);
1694 }
1700 }
1695 void PythonQtShell_QHexEdit::hideEvent(QHideEvent* arg__1)
1701 void PythonQtShell_QHexEdit::hideEvent(QHideEvent* arg__1)
1696 {
1702 {
1697 if (_wrapper) {
1703 if (_wrapper) {
1698 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
1704 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
1699 PyErr_Clear();
1705 PyErr_Clear();
1700 if (obj && !PythonQtSlotFunction_Check(obj)) {
1706 if (obj && !PythonQtSlotFunction_Check(obj)) {
1701 static const char* argumentList[] ={"" , "QHideEvent*"};
1707 static const char* argumentList[] ={"" , "QHideEvent*"};
1702 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1708 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1703 void* args[2] = {NULL, (void*)&arg__1};
1709 void* args[2] = {NULL, (void*)&arg__1};
1704 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1710 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1705 if (result) { Py_DECREF(result); }
1711 if (result) { Py_DECREF(result); }
1706 Py_DECREF(obj);
1712 Py_DECREF(obj);
1707 return;
1713 return;
1708 }
1714 }
1709 }
1715 }
1710 QHexEdit::hideEvent(arg__1);
1716 QHexEdit::hideEvent(arg__1);
1711 }
1717 }
1712 void PythonQtShell_QHexEdit::initPainter(QPainter* painter) const
1718 void PythonQtShell_QHexEdit::initPainter(QPainter* painter) const
1713 {
1719 {
1714 if (_wrapper) {
1720 if (_wrapper) {
1715 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
1721 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
1716 PyErr_Clear();
1722 PyErr_Clear();
1717 if (obj && !PythonQtSlotFunction_Check(obj)) {
1723 if (obj && !PythonQtSlotFunction_Check(obj)) {
1718 static const char* argumentList[] ={"" , "QPainter*"};
1724 static const char* argumentList[] ={"" , "QPainter*"};
1719 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1725 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1720 void* args[2] = {NULL, (void*)&painter};
1726 void* args[2] = {NULL, (void*)&painter};
1721 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1727 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1722 if (result) { Py_DECREF(result); }
1728 if (result) { Py_DECREF(result); }
1723 Py_DECREF(obj);
1729 Py_DECREF(obj);
1724 return;
1730 return;
1725 }
1731 }
1726 }
1732 }
1727 QHexEdit::initPainter(painter);
1733 QHexEdit::initPainter(painter);
1728 }
1734 }
1729 void PythonQtShell_QHexEdit::inputMethodEvent(QInputMethodEvent* arg__1)
1735 void PythonQtShell_QHexEdit::inputMethodEvent(QInputMethodEvent* arg__1)
1730 {
1736 {
1731 if (_wrapper) {
1737 if (_wrapper) {
1732 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
1738 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
1733 PyErr_Clear();
1739 PyErr_Clear();
1734 if (obj && !PythonQtSlotFunction_Check(obj)) {
1740 if (obj && !PythonQtSlotFunction_Check(obj)) {
1735 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
1741 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
1736 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1742 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1737 void* args[2] = {NULL, (void*)&arg__1};
1743 void* args[2] = {NULL, (void*)&arg__1};
1738 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1744 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1739 if (result) { Py_DECREF(result); }
1745 if (result) { Py_DECREF(result); }
1740 Py_DECREF(obj);
1746 Py_DECREF(obj);
1741 return;
1747 return;
1742 }
1748 }
1743 }
1749 }
1744 QHexEdit::inputMethodEvent(arg__1);
1750 QHexEdit::inputMethodEvent(arg__1);
1745 }
1751 }
1746 QVariant PythonQtShell_QHexEdit::inputMethodQuery(Qt::InputMethodQuery arg__1) const
1752 QVariant PythonQtShell_QHexEdit::inputMethodQuery(Qt::InputMethodQuery arg__1) const
1747 {
1753 {
1748 if (_wrapper) {
1754 if (_wrapper) {
1749 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
1755 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
1750 PyErr_Clear();
1756 PyErr_Clear();
1751 if (obj && !PythonQtSlotFunction_Check(obj)) {
1757 if (obj && !PythonQtSlotFunction_Check(obj)) {
1752 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
1758 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
1753 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1759 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1754 QVariant returnValue;
1760 QVariant returnValue;
1755 void* args[2] = {NULL, (void*)&arg__1};
1761 void* args[2] = {NULL, (void*)&arg__1};
1756 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1762 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1757 if (result) {
1763 if (result) {
1758 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1764 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1759 if (args[0]!=&returnValue) {
1765 if (args[0]!=&returnValue) {
1760 if (args[0]==NULL) {
1766 if (args[0]==NULL) {
1761 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
1767 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
1762 } else {
1768 } else {
1763 returnValue = *((QVariant*)args[0]);
1769 returnValue = *((QVariant*)args[0]);
1764 }
1770 }
1765 }
1771 }
1766 }
1772 }
1767 if (result) { Py_DECREF(result); }
1773 if (result) { Py_DECREF(result); }
1768 Py_DECREF(obj);
1774 Py_DECREF(obj);
1769 return returnValue;
1775 return returnValue;
1770 }
1776 }
1771 }
1777 }
1772 return QHexEdit::inputMethodQuery(arg__1);
1778 return QHexEdit::inputMethodQuery(arg__1);
1773 }
1779 }
1774 void PythonQtShell_QHexEdit::keyPressEvent(QKeyEvent* arg__1)
1780 void PythonQtShell_QHexEdit::keyPressEvent(QKeyEvent* arg__1)
1775 {
1781 {
1776 if (_wrapper) {
1782 if (_wrapper) {
1777 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
1783 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
1778 PyErr_Clear();
1784 PyErr_Clear();
1779 if (obj && !PythonQtSlotFunction_Check(obj)) {
1785 if (obj && !PythonQtSlotFunction_Check(obj)) {
1780 static const char* argumentList[] ={"" , "QKeyEvent*"};
1786 static const char* argumentList[] ={"" , "QKeyEvent*"};
1781 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1787 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1782 void* args[2] = {NULL, (void*)&arg__1};
1788 void* args[2] = {NULL, (void*)&arg__1};
1783 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1789 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1784 if (result) { Py_DECREF(result); }
1790 if (result) { Py_DECREF(result); }
1785 Py_DECREF(obj);
1791 Py_DECREF(obj);
1786 return;
1792 return;
1787 }
1793 }
1788 }
1794 }
1789 QHexEdit::keyPressEvent(arg__1);
1795 QHexEdit::keyPressEvent(arg__1);
1790 }
1796 }
1791 void PythonQtShell_QHexEdit::keyReleaseEvent(QKeyEvent* arg__1)
1797 void PythonQtShell_QHexEdit::keyReleaseEvent(QKeyEvent* arg__1)
1792 {
1798 {
1793 if (_wrapper) {
1799 if (_wrapper) {
1794 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
1800 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
1795 PyErr_Clear();
1801 PyErr_Clear();
1796 if (obj && !PythonQtSlotFunction_Check(obj)) {
1802 if (obj && !PythonQtSlotFunction_Check(obj)) {
1797 static const char* argumentList[] ={"" , "QKeyEvent*"};
1803 static const char* argumentList[] ={"" , "QKeyEvent*"};
1798 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1804 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1799 void* args[2] = {NULL, (void*)&arg__1};
1805 void* args[2] = {NULL, (void*)&arg__1};
1800 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1806 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1801 if (result) { Py_DECREF(result); }
1807 if (result) { Py_DECREF(result); }
1802 Py_DECREF(obj);
1808 Py_DECREF(obj);
1803 return;
1809 return;
1804 }
1810 }
1805 }
1811 }
1806 QHexEdit::keyReleaseEvent(arg__1);
1812 QHexEdit::keyReleaseEvent(arg__1);
1807 }
1813 }
1808 void PythonQtShell_QHexEdit::leaveEvent(QEvent* arg__1)
1814 void PythonQtShell_QHexEdit::leaveEvent(QEvent* arg__1)
1809 {
1815 {
1810 if (_wrapper) {
1816 if (_wrapper) {
1811 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
1817 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
1812 PyErr_Clear();
1818 PyErr_Clear();
1813 if (obj && !PythonQtSlotFunction_Check(obj)) {
1819 if (obj && !PythonQtSlotFunction_Check(obj)) {
1814 static const char* argumentList[] ={"" , "QEvent*"};
1820 static const char* argumentList[] ={"" , "QEvent*"};
1815 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1821 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1816 void* args[2] = {NULL, (void*)&arg__1};
1822 void* args[2] = {NULL, (void*)&arg__1};
1817 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1823 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1818 if (result) { Py_DECREF(result); }
1824 if (result) { Py_DECREF(result); }
1819 Py_DECREF(obj);
1825 Py_DECREF(obj);
1820 return;
1826 return;
1821 }
1827 }
1822 }
1828 }
1823 QHexEdit::leaveEvent(arg__1);
1829 QHexEdit::leaveEvent(arg__1);
1824 }
1830 }
1825 int PythonQtShell_QHexEdit::metric(QPaintDevice::PaintDeviceMetric arg__1) const
1831 int PythonQtShell_QHexEdit::metric(QPaintDevice::PaintDeviceMetric arg__1) const
1826 {
1832 {
1827 if (_wrapper) {
1833 if (_wrapper) {
1828 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
1834 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
1829 PyErr_Clear();
1835 PyErr_Clear();
1830 if (obj && !PythonQtSlotFunction_Check(obj)) {
1836 if (obj && !PythonQtSlotFunction_Check(obj)) {
1831 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
1837 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
1832 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1838 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1833 int returnValue;
1839 int returnValue;
1834 void* args[2] = {NULL, (void*)&arg__1};
1840 void* args[2] = {NULL, (void*)&arg__1};
1835 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1841 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1836 if (result) {
1842 if (result) {
1837 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1843 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1838 if (args[0]!=&returnValue) {
1844 if (args[0]!=&returnValue) {
1839 if (args[0]==NULL) {
1845 if (args[0]==NULL) {
1840 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
1846 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
1841 } else {
1847 } else {
1842 returnValue = *((int*)args[0]);
1848 returnValue = *((int*)args[0]);
1843 }
1849 }
1844 }
1850 }
1845 }
1851 }
1846 if (result) { Py_DECREF(result); }
1852 if (result) { Py_DECREF(result); }
1847 Py_DECREF(obj);
1853 Py_DECREF(obj);
1848 return returnValue;
1854 return returnValue;
1849 }
1855 }
1850 }
1856 }
1851 return QHexEdit::metric(arg__1);
1857 return QHexEdit::metric(arg__1);
1852 }
1858 }
1853 void PythonQtShell_QHexEdit::mouseDoubleClickEvent(QMouseEvent* arg__1)
1859 void PythonQtShell_QHexEdit::mouseDoubleClickEvent(QMouseEvent* arg__1)
1854 {
1860 {
1855 if (_wrapper) {
1861 if (_wrapper) {
1856 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
1862 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
1857 PyErr_Clear();
1863 PyErr_Clear();
1858 if (obj && !PythonQtSlotFunction_Check(obj)) {
1864 if (obj && !PythonQtSlotFunction_Check(obj)) {
1859 static const char* argumentList[] ={"" , "QMouseEvent*"};
1865 static const char* argumentList[] ={"" , "QMouseEvent*"};
1860 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1866 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1861 void* args[2] = {NULL, (void*)&arg__1};
1867 void* args[2] = {NULL, (void*)&arg__1};
1862 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1868 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1863 if (result) { Py_DECREF(result); }
1869 if (result) { Py_DECREF(result); }
1864 Py_DECREF(obj);
1870 Py_DECREF(obj);
1865 return;
1871 return;
1866 }
1872 }
1867 }
1873 }
1868 QHexEdit::mouseDoubleClickEvent(arg__1);
1874 QHexEdit::mouseDoubleClickEvent(arg__1);
1869 }
1875 }
1870 void PythonQtShell_QHexEdit::mouseMoveEvent(QMouseEvent* arg__1)
1876 void PythonQtShell_QHexEdit::mouseMoveEvent(QMouseEvent* arg__1)
1871 {
1877 {
1872 if (_wrapper) {
1878 if (_wrapper) {
1873 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
1879 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
1874 PyErr_Clear();
1880 PyErr_Clear();
1875 if (obj && !PythonQtSlotFunction_Check(obj)) {
1881 if (obj && !PythonQtSlotFunction_Check(obj)) {
1876 static const char* argumentList[] ={"" , "QMouseEvent*"};
1882 static const char* argumentList[] ={"" , "QMouseEvent*"};
1877 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1883 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1878 void* args[2] = {NULL, (void*)&arg__1};
1884 void* args[2] = {NULL, (void*)&arg__1};
1879 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1885 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1880 if (result) { Py_DECREF(result); }
1886 if (result) { Py_DECREF(result); }
1881 Py_DECREF(obj);
1887 Py_DECREF(obj);
1882 return;
1888 return;
1883 }
1889 }
1884 }
1890 }
1885 QHexEdit::mouseMoveEvent(arg__1);
1891 QHexEdit::mouseMoveEvent(arg__1);
1886 }
1892 }
1887 void PythonQtShell_QHexEdit::mousePressEvent(QMouseEvent* arg__1)
1893 void PythonQtShell_QHexEdit::mousePressEvent(QMouseEvent* arg__1)
1888 {
1894 {
1889 if (_wrapper) {
1895 if (_wrapper) {
1890 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
1896 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
1891 PyErr_Clear();
1897 PyErr_Clear();
1892 if (obj && !PythonQtSlotFunction_Check(obj)) {
1898 if (obj && !PythonQtSlotFunction_Check(obj)) {
1893 static const char* argumentList[] ={"" , "QMouseEvent*"};
1899 static const char* argumentList[] ={"" , "QMouseEvent*"};
1894 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1900 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1895 void* args[2] = {NULL, (void*)&arg__1};
1901 void* args[2] = {NULL, (void*)&arg__1};
1896 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1902 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1897 if (result) { Py_DECREF(result); }
1903 if (result) { Py_DECREF(result); }
1898 Py_DECREF(obj);
1904 Py_DECREF(obj);
1899 return;
1905 return;
1900 }
1906 }
1901 }
1907 }
1902 QHexEdit::mousePressEvent(arg__1);
1908 QHexEdit::mousePressEvent(arg__1);
1903 }
1909 }
1904 void PythonQtShell_QHexEdit::mouseReleaseEvent(QMouseEvent* arg__1)
1910 void PythonQtShell_QHexEdit::mouseReleaseEvent(QMouseEvent* arg__1)
1905 {
1911 {
1906 if (_wrapper) {
1912 if (_wrapper) {
1907 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
1913 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
1908 PyErr_Clear();
1914 PyErr_Clear();
1909 if (obj && !PythonQtSlotFunction_Check(obj)) {
1915 if (obj && !PythonQtSlotFunction_Check(obj)) {
1910 static const char* argumentList[] ={"" , "QMouseEvent*"};
1916 static const char* argumentList[] ={"" , "QMouseEvent*"};
1911 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1917 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1912 void* args[2] = {NULL, (void*)&arg__1};
1918 void* args[2] = {NULL, (void*)&arg__1};
1913 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1919 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1914 if (result) { Py_DECREF(result); }
1920 if (result) { Py_DECREF(result); }
1915 Py_DECREF(obj);
1921 Py_DECREF(obj);
1916 return;
1922 return;
1917 }
1923 }
1918 }
1924 }
1919 QHexEdit::mouseReleaseEvent(arg__1);
1925 QHexEdit::mouseReleaseEvent(arg__1);
1920 }
1926 }
1921 void PythonQtShell_QHexEdit::moveEvent(QMoveEvent* arg__1)
1927 void PythonQtShell_QHexEdit::moveEvent(QMoveEvent* arg__1)
1922 {
1928 {
1923 if (_wrapper) {
1929 if (_wrapper) {
1924 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
1930 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
1925 PyErr_Clear();
1931 PyErr_Clear();
1926 if (obj && !PythonQtSlotFunction_Check(obj)) {
1932 if (obj && !PythonQtSlotFunction_Check(obj)) {
1927 static const char* argumentList[] ={"" , "QMoveEvent*"};
1933 static const char* argumentList[] ={"" , "QMoveEvent*"};
1928 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1934 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1929 void* args[2] = {NULL, (void*)&arg__1};
1935 void* args[2] = {NULL, (void*)&arg__1};
1930 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1936 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1931 if (result) { Py_DECREF(result); }
1937 if (result) { Py_DECREF(result); }
1932 Py_DECREF(obj);
1938 Py_DECREF(obj);
1933 return;
1939 return;
1934 }
1940 }
1935 }
1941 }
1936 QHexEdit::moveEvent(arg__1);
1942 QHexEdit::moveEvent(arg__1);
1937 }
1943 }
1938 bool PythonQtShell_QHexEdit::nativeEvent(const QByteArray& eventType, void* message, long* result)
1944 bool PythonQtShell_QHexEdit::nativeEvent(const QByteArray& eventType, void* message, long* result)
1939 {
1945 {
1940 if (_wrapper) {
1946 if (_wrapper) {
1941 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
1947 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
1942 PyErr_Clear();
1948 PyErr_Clear();
1943 if (obj && !PythonQtSlotFunction_Check(obj)) {
1949 if (obj && !PythonQtSlotFunction_Check(obj)) {
1944 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
1950 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
1945 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
1951 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
1946 bool returnValue;
1952 bool returnValue;
1947 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
1953 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
1948 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1954 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1949 if (result) {
1955 if (result) {
1950 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1956 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1951 if (args[0]!=&returnValue) {
1957 if (args[0]!=&returnValue) {
1952 if (args[0]==NULL) {
1958 if (args[0]==NULL) {
1953 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
1959 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
1954 } else {
1960 } else {
1955 returnValue = *((bool*)args[0]);
1961 returnValue = *((bool*)args[0]);
1956 }
1962 }
1957 }
1963 }
1958 }
1964 }
1959 if (result) { Py_DECREF(result); }
1965 if (result) { Py_DECREF(result); }
1960 Py_DECREF(obj);
1966 Py_DECREF(obj);
1961 return returnValue;
1967 return returnValue;
1962 }
1968 }
1963 }
1969 }
1964 return QHexEdit::nativeEvent(eventType, message, result);
1970 return QHexEdit::nativeEvent(eventType, message, result);
1965 }
1971 }
1966 QPaintEngine* PythonQtShell_QHexEdit::paintEngine() const
1972 QPaintEngine* PythonQtShell_QHexEdit::paintEngine() const
1967 {
1973 {
1968 if (_wrapper) {
1974 if (_wrapper) {
1969 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
1975 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
1970 PyErr_Clear();
1976 PyErr_Clear();
1971 if (obj && !PythonQtSlotFunction_Check(obj)) {
1977 if (obj && !PythonQtSlotFunction_Check(obj)) {
1972 static const char* argumentList[] ={"QPaintEngine*"};
1978 static const char* argumentList[] ={"QPaintEngine*"};
1973 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1979 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1974 QPaintEngine* returnValue;
1980 QPaintEngine* returnValue;
1975 void* args[1] = {NULL};
1981 void* args[1] = {NULL};
1976 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1982 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1977 if (result) {
1983 if (result) {
1978 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1984 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1979 if (args[0]!=&returnValue) {
1985 if (args[0]!=&returnValue) {
1980 if (args[0]==NULL) {
1986 if (args[0]==NULL) {
1981 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
1987 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
1982 } else {
1988 } else {
1983 returnValue = *((QPaintEngine**)args[0]);
1989 returnValue = *((QPaintEngine**)args[0]);
1984 }
1990 }
1985 }
1991 }
1986 }
1992 }
1987 if (result) { Py_DECREF(result); }
1993 if (result) { Py_DECREF(result); }
1988 Py_DECREF(obj);
1994 Py_DECREF(obj);
1989 return returnValue;
1995 return returnValue;
1990 }
1996 }
1991 }
1997 }
1992 return QHexEdit::paintEngine();
1998 return QHexEdit::paintEngine();
1993 }
1999 }
1994 void PythonQtShell_QHexEdit::paintEvent(QPaintEvent* arg__1)
2000 void PythonQtShell_QHexEdit::paintEvent(QPaintEvent* arg__1)
1995 {
2001 {
1996 if (_wrapper) {
2002 if (_wrapper) {
1997 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
2003 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
1998 PyErr_Clear();
2004 PyErr_Clear();
1999 if (obj && !PythonQtSlotFunction_Check(obj)) {
2005 if (obj && !PythonQtSlotFunction_Check(obj)) {
2000 static const char* argumentList[] ={"" , "QPaintEvent*"};
2006 static const char* argumentList[] ={"" , "QPaintEvent*"};
2001 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2007 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2002 void* args[2] = {NULL, (void*)&arg__1};
2008 void* args[2] = {NULL, (void*)&arg__1};
2003 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2009 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2004 if (result) { Py_DECREF(result); }
2010 if (result) { Py_DECREF(result); }
2005 Py_DECREF(obj);
2011 Py_DECREF(obj);
2006 return;
2012 return;
2007 }
2013 }
2008 }
2014 }
2009 QHexEdit::paintEvent(arg__1);
2015 QHexEdit::paintEvent(arg__1);
2010 }
2016 }
2011 QPaintDevice* PythonQtShell_QHexEdit::redirected(QPoint* offset) const
2017 QPaintDevice* PythonQtShell_QHexEdit::redirected(QPoint* offset) const
2012 {
2018 {
2013 if (_wrapper) {
2019 if (_wrapper) {
2014 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
2020 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
2015 PyErr_Clear();
2021 PyErr_Clear();
2016 if (obj && !PythonQtSlotFunction_Check(obj)) {
2022 if (obj && !PythonQtSlotFunction_Check(obj)) {
2017 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
2023 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
2018 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2024 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2019 QPaintDevice* returnValue;
2025 QPaintDevice* returnValue;
2020 void* args[2] = {NULL, (void*)&offset};
2026 void* args[2] = {NULL, (void*)&offset};
2021 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2027 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2022 if (result) {
2028 if (result) {
2023 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2029 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2024 if (args[0]!=&returnValue) {
2030 if (args[0]!=&returnValue) {
2025 if (args[0]==NULL) {
2031 if (args[0]==NULL) {
2026 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
2032 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
2027 } else {
2033 } else {
2028 returnValue = *((QPaintDevice**)args[0]);
2034 returnValue = *((QPaintDevice**)args[0]);
2029 }
2035 }
2030 }
2036 }
2031 }
2037 }
2032 if (result) { Py_DECREF(result); }
2038 if (result) { Py_DECREF(result); }
2033 Py_DECREF(obj);
2039 Py_DECREF(obj);
2034 return returnValue;
2040 return returnValue;
2035 }
2041 }
2036 }
2042 }
2037 return QHexEdit::redirected(offset);
2043 return QHexEdit::redirected(offset);
2038 }
2044 }
2039 void PythonQtShell_QHexEdit::resizeEvent(QResizeEvent* arg__1)
2045 void PythonQtShell_QHexEdit::resizeEvent(QResizeEvent* arg__1)
2040 {
2046 {
2041 if (_wrapper) {
2047 if (_wrapper) {
2042 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
2048 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
2043 PyErr_Clear();
2049 PyErr_Clear();
2044 if (obj && !PythonQtSlotFunction_Check(obj)) {
2050 if (obj && !PythonQtSlotFunction_Check(obj)) {
2045 static const char* argumentList[] ={"" , "QResizeEvent*"};
2051 static const char* argumentList[] ={"" , "QResizeEvent*"};
2046 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2052 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2047 void* args[2] = {NULL, (void*)&arg__1};
2053 void* args[2] = {NULL, (void*)&arg__1};
2048 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2054 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2049 if (result) { Py_DECREF(result); }
2055 if (result) { Py_DECREF(result); }
2050 Py_DECREF(obj);
2056 Py_DECREF(obj);
2051 return;
2057 return;
2052 }
2058 }
2053 }
2059 }
2054 QHexEdit::resizeEvent(arg__1);
2060 QHexEdit::resizeEvent(arg__1);
2055 }
2061 }
2056 void PythonQtShell_QHexEdit::scrollContentsBy(int dx, int dy)
2062 void PythonQtShell_QHexEdit::scrollContentsBy(int dx, int dy)
2057 {
2063 {
2058 if (_wrapper) {
2064 if (_wrapper) {
2059 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "scrollContentsBy");
2065 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "scrollContentsBy");
2060 PyErr_Clear();
2066 PyErr_Clear();
2061 if (obj && !PythonQtSlotFunction_Check(obj)) {
2067 if (obj && !PythonQtSlotFunction_Check(obj)) {
2062 static const char* argumentList[] ={"" , "int" , "int"};
2068 static const char* argumentList[] ={"" , "int" , "int"};
2063 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2069 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2064 void* args[3] = {NULL, (void*)&dx, (void*)&dy};
2070 void* args[3] = {NULL, (void*)&dx, (void*)&dy};
2065 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2071 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2066 if (result) { Py_DECREF(result); }
2072 if (result) { Py_DECREF(result); }
2067 Py_DECREF(obj);
2073 Py_DECREF(obj);
2068 return;
2074 return;
2069 }
2075 }
2070 }
2076 }
2071 QHexEdit::scrollContentsBy(dx, dy);
2077 QHexEdit::scrollContentsBy(dx, dy);
2072 }
2078 }
2073 void PythonQtShell_QHexEdit::setupViewport(QWidget* viewport)
2079 void PythonQtShell_QHexEdit::setupViewport(QWidget* viewport)
2074 {
2080 {
2075 if (_wrapper) {
2081 if (_wrapper) {
2076 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setupViewport");
2082 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setupViewport");
2077 PyErr_Clear();
2083 PyErr_Clear();
2078 if (obj && !PythonQtSlotFunction_Check(obj)) {
2084 if (obj && !PythonQtSlotFunction_Check(obj)) {
2079 static const char* argumentList[] ={"" , "QWidget*"};
2085 static const char* argumentList[] ={"" , "QWidget*"};
2080 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2086 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2081 void* args[2] = {NULL, (void*)&viewport};
2087 void* args[2] = {NULL, (void*)&viewport};
2082 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2088 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2083 if (result) { Py_DECREF(result); }
2089 if (result) { Py_DECREF(result); }
2084 Py_DECREF(obj);
2090 Py_DECREF(obj);
2085 return;
2091 return;
2086 }
2092 }
2087 }
2093 }
2088 QHexEdit::setupViewport(viewport);
2094 QHexEdit::setupViewport(viewport);
2089 }
2095 }
2090 QPainter* PythonQtShell_QHexEdit::sharedPainter() const
2096 QPainter* PythonQtShell_QHexEdit::sharedPainter() const
2091 {
2097 {
2092 if (_wrapper) {
2098 if (_wrapper) {
2093 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
2099 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
2094 PyErr_Clear();
2100 PyErr_Clear();
2095 if (obj && !PythonQtSlotFunction_Check(obj)) {
2101 if (obj && !PythonQtSlotFunction_Check(obj)) {
2096 static const char* argumentList[] ={"QPainter*"};
2102 static const char* argumentList[] ={"QPainter*"};
2097 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2103 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2098 QPainter* returnValue;
2104 QPainter* returnValue;
2099 void* args[1] = {NULL};
2105 void* args[1] = {NULL};
2100 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2106 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2101 if (result) {
2107 if (result) {
2102 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2108 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2103 if (args[0]!=&returnValue) {
2109 if (args[0]!=&returnValue) {
2104 if (args[0]==NULL) {
2110 if (args[0]==NULL) {
2105 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
2111 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
2106 } else {
2112 } else {
2107 returnValue = *((QPainter**)args[0]);
2113 returnValue = *((QPainter**)args[0]);
2108 }
2114 }
2109 }
2115 }
2110 }
2116 }
2111 if (result) { Py_DECREF(result); }
2117 if (result) { Py_DECREF(result); }
2112 Py_DECREF(obj);
2118 Py_DECREF(obj);
2113 return returnValue;
2119 return returnValue;
2114 }
2120 }
2115 }
2121 }
2116 return QHexEdit::sharedPainter();
2122 return QHexEdit::sharedPainter();
2117 }
2123 }
2118 void PythonQtShell_QHexEdit::showEvent(QShowEvent* arg__1)
2124 void PythonQtShell_QHexEdit::showEvent(QShowEvent* arg__1)
2119 {
2125 {
2120 if (_wrapper) {
2126 if (_wrapper) {
2121 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
2127 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
2122 PyErr_Clear();
2128 PyErr_Clear();
2123 if (obj && !PythonQtSlotFunction_Check(obj)) {
2129 if (obj && !PythonQtSlotFunction_Check(obj)) {
2124 static const char* argumentList[] ={"" , "QShowEvent*"};
2130 static const char* argumentList[] ={"" , "QShowEvent*"};
2125 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2131 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2126 void* args[2] = {NULL, (void*)&arg__1};
2132 void* args[2] = {NULL, (void*)&arg__1};
2127 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2133 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2128 if (result) { Py_DECREF(result); }
2134 if (result) { Py_DECREF(result); }
2129 Py_DECREF(obj);
2135 Py_DECREF(obj);
2130 return;
2136 return;
2131 }
2137 }
2132 }
2138 }
2133 QHexEdit::showEvent(arg__1);
2139 QHexEdit::showEvent(arg__1);
2134 }
2140 }
2135 void PythonQtShell_QHexEdit::tabletEvent(QTabletEvent* arg__1)
2141 void PythonQtShell_QHexEdit::tabletEvent(QTabletEvent* arg__1)
2136 {
2142 {
2137 if (_wrapper) {
2143 if (_wrapper) {
2138 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
2144 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
2139 PyErr_Clear();
2145 PyErr_Clear();
2140 if (obj && !PythonQtSlotFunction_Check(obj)) {
2146 if (obj && !PythonQtSlotFunction_Check(obj)) {
2141 static const char* argumentList[] ={"" , "QTabletEvent*"};
2147 static const char* argumentList[] ={"" , "QTabletEvent*"};
2142 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2148 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2143 void* args[2] = {NULL, (void*)&arg__1};
2149 void* args[2] = {NULL, (void*)&arg__1};
2144 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2150 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2145 if (result) { Py_DECREF(result); }
2151 if (result) { Py_DECREF(result); }
2146 Py_DECREF(obj);
2152 Py_DECREF(obj);
2147 return;
2153 return;
2148 }
2154 }
2149 }
2155 }
2150 QHexEdit::tabletEvent(arg__1);
2156 QHexEdit::tabletEvent(arg__1);
2151 }
2157 }
2152 void PythonQtShell_QHexEdit::timerEvent(QTimerEvent* arg__1)
2158 void PythonQtShell_QHexEdit::timerEvent(QTimerEvent* arg__1)
2153 {
2159 {
2154 if (_wrapper) {
2160 if (_wrapper) {
2155 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
2161 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
2156 PyErr_Clear();
2162 PyErr_Clear();
2157 if (obj && !PythonQtSlotFunction_Check(obj)) {
2163 if (obj && !PythonQtSlotFunction_Check(obj)) {
2158 static const char* argumentList[] ={"" , "QTimerEvent*"};
2164 static const char* argumentList[] ={"" , "QTimerEvent*"};
2159 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2165 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2160 void* args[2] = {NULL, (void*)&arg__1};
2166 void* args[2] = {NULL, (void*)&arg__1};
2161 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2167 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2162 if (result) { Py_DECREF(result); }
2168 if (result) { Py_DECREF(result); }
2163 Py_DECREF(obj);
2169 Py_DECREF(obj);
2164 return;
2170 return;
2165 }
2171 }
2166 }
2172 }
2167 QHexEdit::timerEvent(arg__1);
2173 QHexEdit::timerEvent(arg__1);
2168 }
2174 }
2169 bool PythonQtShell_QHexEdit::viewportEvent(QEvent* arg__1)
2175 bool PythonQtShell_QHexEdit::viewportEvent(QEvent* arg__1)
2170 {
2176 {
2171 if (_wrapper) {
2177 if (_wrapper) {
2172 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportEvent");
2178 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportEvent");
2173 PyErr_Clear();
2179 PyErr_Clear();
2174 if (obj && !PythonQtSlotFunction_Check(obj)) {
2180 if (obj && !PythonQtSlotFunction_Check(obj)) {
2175 static const char* argumentList[] ={"bool" , "QEvent*"};
2181 static const char* argumentList[] ={"bool" , "QEvent*"};
2176 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2182 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2177 bool returnValue;
2183 bool returnValue;
2178 void* args[2] = {NULL, (void*)&arg__1};
2184 void* args[2] = {NULL, (void*)&arg__1};
2179 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2185 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2180 if (result) {
2186 if (result) {
2181 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2187 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2182 if (args[0]!=&returnValue) {
2188 if (args[0]!=&returnValue) {
2183 if (args[0]==NULL) {
2189 if (args[0]==NULL) {
2184 PythonQt::priv()->handleVirtualOverloadReturnError("viewportEvent", methodInfo, result);
2190 PythonQt::priv()->handleVirtualOverloadReturnError("viewportEvent", methodInfo, result);
2185 } else {
2191 } else {
2186 returnValue = *((bool*)args[0]);
2192 returnValue = *((bool*)args[0]);
2187 }
2193 }
2188 }
2194 }
2189 }
2195 }
2190 if (result) { Py_DECREF(result); }
2196 if (result) { Py_DECREF(result); }
2191 Py_DECREF(obj);
2197 Py_DECREF(obj);
2192 return returnValue;
2198 return returnValue;
2193 }
2199 }
2194 }
2200 }
2195 return QHexEdit::viewportEvent(arg__1);
2201 return QHexEdit::viewportEvent(arg__1);
2196 }
2202 }
2197 QSize PythonQtShell_QHexEdit::viewportSizeHint() const
2203 QSize PythonQtShell_QHexEdit::viewportSizeHint() const
2198 {
2204 {
2199 if (_wrapper) {
2205 if (_wrapper) {
2200 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportSizeHint");
2206 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportSizeHint");
2201 PyErr_Clear();
2207 PyErr_Clear();
2202 if (obj && !PythonQtSlotFunction_Check(obj)) {
2208 if (obj && !PythonQtSlotFunction_Check(obj)) {
2203 static const char* argumentList[] ={"QSize"};
2209 static const char* argumentList[] ={"QSize"};
2204 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2210 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2205 QSize returnValue;
2211 QSize returnValue;
2206 void* args[1] = {NULL};
2212 void* args[1] = {NULL};
2207 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2213 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2208 if (result) {
2214 if (result) {
2209 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2215 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2210 if (args[0]!=&returnValue) {
2216 if (args[0]!=&returnValue) {
2211 if (args[0]==NULL) {
2217 if (args[0]==NULL) {
2212 PythonQt::priv()->handleVirtualOverloadReturnError("viewportSizeHint", methodInfo, result);
2218 PythonQt::priv()->handleVirtualOverloadReturnError("viewportSizeHint", methodInfo, result);
2213 } else {
2219 } else {
2214 returnValue = *((QSize*)args[0]);
2220 returnValue = *((QSize*)args[0]);
2215 }
2221 }
2216 }
2222 }
2217 }
2223 }
2218 if (result) { Py_DECREF(result); }
2224 if (result) { Py_DECREF(result); }
2219 Py_DECREF(obj);
2225 Py_DECREF(obj);
2220 return returnValue;
2226 return returnValue;
2221 }
2227 }
2222 }
2228 }
2223 return QHexEdit::viewportSizeHint();
2229 return QHexEdit::viewportSizeHint();
2224 }
2230 }
2225 void PythonQtShell_QHexEdit::wheelEvent(QWheelEvent* arg__1)
2231 void PythonQtShell_QHexEdit::wheelEvent(QWheelEvent* arg__1)
2226 {
2232 {
2227 if (_wrapper) {
2233 if (_wrapper) {
2228 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
2234 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
2229 PyErr_Clear();
2235 PyErr_Clear();
2230 if (obj && !PythonQtSlotFunction_Check(obj)) {
2236 if (obj && !PythonQtSlotFunction_Check(obj)) {
2231 static const char* argumentList[] ={"" , "QWheelEvent*"};
2237 static const char* argumentList[] ={"" , "QWheelEvent*"};
2232 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2238 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2233 void* args[2] = {NULL, (void*)&arg__1};
2239 void* args[2] = {NULL, (void*)&arg__1};
2234 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2240 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2235 if (result) { Py_DECREF(result); }
2241 if (result) { Py_DECREF(result); }
2236 Py_DECREF(obj);
2242 Py_DECREF(obj);
2237 return;
2243 return;
2238 }
2244 }
2239 }
2245 }
2240 QHexEdit::wheelEvent(arg__1);
2246 QHexEdit::wheelEvent(arg__1);
2241 }
2247 }
2242 QHexEdit* PythonQtWrapper_QHexEdit::new_QHexEdit(QWidget* parent)
2248 QHexEdit* PythonQtWrapper_QHexEdit::new_QHexEdit(QWidget* parent)
2243 {
2249 {
2244 return new PythonQtShell_QHexEdit(parent); }
2250 return new PythonQtShell_QHexEdit(parent); }
2245
2251
2246 QColor PythonQtWrapper_QHexEdit::addressAreaColor(QHexEdit* theWrappedObject)
2252 QColor PythonQtWrapper_QHexEdit::addressAreaColor(QHexEdit* theWrappedObject)
2247 {
2253 {
2248 return ( theWrappedObject->addressAreaColor());
2254 return ( theWrappedObject->addressAreaColor());
2249 }
2255 }
2250
2256
2251 int PythonQtWrapper_QHexEdit::addressOffset(QHexEdit* theWrappedObject)
2257 int PythonQtWrapper_QHexEdit::addressOffset(QHexEdit* theWrappedObject)
2252 {
2258 {
2253 return ( theWrappedObject->addressOffset());
2259 return ( theWrappedObject->addressOffset());
2254 }
2260 }
2255
2261
2256 int PythonQtWrapper_QHexEdit::cursorPosition(QHexEdit* theWrappedObject)
2262 int PythonQtWrapper_QHexEdit::cursorPosition(QHexEdit* theWrappedObject)
2257 {
2263 {
2258 return ( theWrappedObject->cursorPosition());
2264 return ( theWrappedObject->cursorPosition());
2259 }
2265 }
2260
2266
2261 QByteArray PythonQtWrapper_QHexEdit::data(QHexEdit* theWrappedObject)
2267 QByteArray PythonQtWrapper_QHexEdit::data(QHexEdit* theWrappedObject)
2262 {
2268 {
2263 return ( theWrappedObject->data());
2269 return ( theWrappedObject->data());
2264 }
2270 }
2265
2271
2266 const QFont* PythonQtWrapper_QHexEdit::font(QHexEdit* theWrappedObject) const
2272 const QFont* PythonQtWrapper_QHexEdit::font(QHexEdit* theWrappedObject) const
2267 {
2273 {
2268 return &( theWrappedObject->font());
2274 return &( theWrappedObject->font());
2269 }
2275 }
2270
2276
2271 QColor PythonQtWrapper_QHexEdit::highlightingColor(QHexEdit* theWrappedObject)
2277 QColor PythonQtWrapper_QHexEdit::highlightingColor(QHexEdit* theWrappedObject)
2272 {
2278 {
2273 return ( theWrappedObject->highlightingColor());
2279 return ( theWrappedObject->highlightingColor());
2274 }
2280 }
2275
2281
2276 int PythonQtWrapper_QHexEdit::indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2282 int PythonQtWrapper_QHexEdit::indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2277 {
2283 {
2278 return ( theWrappedObject->indexOf(ba, from));
2284 return ( theWrappedObject->indexOf(ba, from));
2279 }
2285 }
2280
2286
2281 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, char ch)
2287 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, char ch)
2282 {
2288 {
2283 ( theWrappedObject->insert(i, ch));
2289 ( theWrappedObject->insert(i, ch));
2284 }
2290 }
2285
2291
2286 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba)
2292 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba)
2287 {
2293 {
2288 ( theWrappedObject->insert(i, ba));
2294 ( theWrappedObject->insert(i, ba));
2289 }
2295 }
2290
2296
2291 bool PythonQtWrapper_QHexEdit::isReadOnly(QHexEdit* theWrappedObject)
2297 bool PythonQtWrapper_QHexEdit::isReadOnly(QHexEdit* theWrappedObject)
2292 {
2298 {
2293 return ( theWrappedObject->isReadOnly());
2299 return ( theWrappedObject->isReadOnly());
2294 }
2300 }
2295
2301
2296 int PythonQtWrapper_QHexEdit::lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2302 int PythonQtWrapper_QHexEdit::lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2297 {
2303 {
2298 return ( theWrappedObject->lastIndexOf(ba, from));
2304 return ( theWrappedObject->lastIndexOf(ba, from));
2299 }
2305 }
2300
2306
2301 bool PythonQtWrapper_QHexEdit::overwriteMode(QHexEdit* theWrappedObject)
2307 bool PythonQtWrapper_QHexEdit::overwriteMode(QHexEdit* theWrappedObject)
2302 {
2308 {
2303 return ( theWrappedObject->overwriteMode());
2309 return ( theWrappedObject->overwriteMode());
2304 }
2310 }
2305
2311
2306 void PythonQtWrapper_QHexEdit::remove(QHexEdit* theWrappedObject, int pos, int len)
2312 void PythonQtWrapper_QHexEdit::remove(QHexEdit* theWrappedObject, int pos, int len)
2307 {
2313 {
2308 ( theWrappedObject->remove(pos, len));
2314 ( theWrappedObject->remove(pos, len));
2309 }
2315 }
2310
2316
2311 void PythonQtWrapper_QHexEdit::replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after)
2317 void PythonQtWrapper_QHexEdit::replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after)
2312 {
2318 {
2313 ( theWrappedObject->replace(pos, len, after));
2319 ( theWrappedObject->replace(pos, len, after));
2314 }
2320 }
2315
2321
2316 QColor PythonQtWrapper_QHexEdit::selectionColor(QHexEdit* theWrappedObject)
2322 QColor PythonQtWrapper_QHexEdit::selectionColor(QHexEdit* theWrappedObject)
2317 {
2323 {
2318 return ( theWrappedObject->selectionColor());
2324 return ( theWrappedObject->selectionColor());
2319 }
2325 }
2320
2326
2321 QString PythonQtWrapper_QHexEdit::selectionToReadableString(QHexEdit* theWrappedObject)
2327 QString PythonQtWrapper_QHexEdit::selectionToReadableString(QHexEdit* theWrappedObject)
2322 {
2328 {
2323 return ( theWrappedObject->selectionToReadableString());
2329 return ( theWrappedObject->selectionToReadableString());
2324 }
2330 }
2325
2331
2326 void PythonQtWrapper_QHexEdit::setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color)
2332 void PythonQtWrapper_QHexEdit::setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color)
2327 {
2333 {
2328 ( theWrappedObject->setAddressAreaColor(color));
2334 ( theWrappedObject->setAddressAreaColor(color));
2329 }
2335 }
2330
2336
2331 void PythonQtWrapper_QHexEdit::setAddressOffset(QHexEdit* theWrappedObject, int offset)
2337 void PythonQtWrapper_QHexEdit::setAddressOffset(QHexEdit* theWrappedObject, int offset)
2332 {
2338 {
2333 ( theWrappedObject->setAddressOffset(offset));
2339 ( theWrappedObject->setAddressOffset(offset));
2334 }
2340 }
2335
2341
2336 void PythonQtWrapper_QHexEdit::setCursorPosition(QHexEdit* theWrappedObject, int cusorPos)
2342 void PythonQtWrapper_QHexEdit::setCursorPosition(QHexEdit* theWrappedObject, int cusorPos)
2337 {
2343 {
2338 ( theWrappedObject->setCursorPosition(cusorPos));
2344 ( theWrappedObject->setCursorPosition(cusorPos));
2339 }
2345 }
2340
2346
2341 void PythonQtWrapper_QHexEdit::setData(QHexEdit* theWrappedObject, const QByteArray& data)
2347 void PythonQtWrapper_QHexEdit::setData(QHexEdit* theWrappedObject, const QByteArray& data)
2342 {
2348 {
2343 ( theWrappedObject->setData(data));
2349 ( theWrappedObject->setData(data));
2344 }
2350 }
2345
2351
2346 void PythonQtWrapper_QHexEdit::setFont(QHexEdit* theWrappedObject, const QFont& arg__1)
2352 void PythonQtWrapper_QHexEdit::setFont(QHexEdit* theWrappedObject, const QFont& arg__1)
2347 {
2353 {
2348 ( theWrappedObject->setFont(arg__1));
2354 ( theWrappedObject->setFont(arg__1));
2349 }
2355 }
2350
2356
2351 void PythonQtWrapper_QHexEdit::setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color)
2357 void PythonQtWrapper_QHexEdit::setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color)
2352 {
2358 {
2353 ( theWrappedObject->setHighlightingColor(color));
2359 ( theWrappedObject->setHighlightingColor(color));
2354 }
2360 }
2355
2361
2356 void PythonQtWrapper_QHexEdit::setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1)
2362 void PythonQtWrapper_QHexEdit::setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1)
2357 {
2363 {
2358 ( theWrappedObject->setOverwriteMode(arg__1));
2364 ( theWrappedObject->setOverwriteMode(arg__1));
2359 }
2365 }
2360
2366
2361 void PythonQtWrapper_QHexEdit::setReadOnly(QHexEdit* theWrappedObject, bool arg__1)
2367 void PythonQtWrapper_QHexEdit::setReadOnly(QHexEdit* theWrappedObject, bool arg__1)
2362 {
2368 {
2363 ( theWrappedObject->setReadOnly(arg__1));
2369 ( theWrappedObject->setReadOnly(arg__1));
2364 }
2370 }
2365
2371
2366 void PythonQtWrapper_QHexEdit::setSelectionColor(QHexEdit* theWrappedObject, const QColor& color)
2372 void PythonQtWrapper_QHexEdit::setSelectionColor(QHexEdit* theWrappedObject, const QColor& color)
2367 {
2373 {
2368 ( theWrappedObject->setSelectionColor(color));
2374 ( theWrappedObject->setSelectionColor(color));
2369 }
2375 }
2370
2376
2371 QString PythonQtWrapper_QHexEdit::toReadableString(QHexEdit* theWrappedObject)
2377 QString PythonQtWrapper_QHexEdit::toReadableString(QHexEdit* theWrappedObject)
2372 {
2378 {
2373 return ( theWrappedObject->toReadableString());
2379 return ( theWrappedObject->toReadableString());
2374 }
2380 }
2375
2381
2376
2382
2377
2383
2378 PythonQtShell_QHexSpinBox::~PythonQtShell_QHexSpinBox() {
2384 PythonQtShell_QHexSpinBox::~PythonQtShell_QHexSpinBox() {
2379 PythonQtPrivate* priv = PythonQt::priv();
2385 PythonQtPrivate* priv = PythonQt::priv();
2380 if (priv) { priv->shellClassDeleted(this); }
2386 if (priv) { priv->shellClassDeleted(this); }
2381 }
2387 }
2382 void PythonQtShell_QHexSpinBox::actionEvent(QActionEvent* arg__1)
2388 void PythonQtShell_QHexSpinBox::actionEvent(QActionEvent* arg__1)
2383 {
2389 {
2384 if (_wrapper) {
2390 if (_wrapper) {
2385 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
2391 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
2386 PyErr_Clear();
2392 PyErr_Clear();
2387 if (obj && !PythonQtSlotFunction_Check(obj)) {
2393 if (obj && !PythonQtSlotFunction_Check(obj)) {
2388 static const char* argumentList[] ={"" , "QActionEvent*"};
2394 static const char* argumentList[] ={"" , "QActionEvent*"};
2389 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2395 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2390 void* args[2] = {NULL, (void*)&arg__1};
2396 void* args[2] = {NULL, (void*)&arg__1};
2391 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2397 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2392 if (result) { Py_DECREF(result); }
2398 if (result) { Py_DECREF(result); }
2393 Py_DECREF(obj);
2399 Py_DECREF(obj);
2394 return;
2400 return;
2395 }
2401 }
2396 }
2402 }
2397 QHexSpinBox::actionEvent(arg__1);
2403 QHexSpinBox::actionEvent(arg__1);
2398 }
2404 }
2399 void PythonQtShell_QHexSpinBox::changeEvent(QEvent* event)
2405 void PythonQtShell_QHexSpinBox::changeEvent(QEvent* event)
2400 {
2406 {
2401 if (_wrapper) {
2407 if (_wrapper) {
2402 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
2408 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
2403 PyErr_Clear();
2409 PyErr_Clear();
2404 if (obj && !PythonQtSlotFunction_Check(obj)) {
2410 if (obj && !PythonQtSlotFunction_Check(obj)) {
2405 static const char* argumentList[] ={"" , "QEvent*"};
2411 static const char* argumentList[] ={"" , "QEvent*"};
2406 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2412 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2407 void* args[2] = {NULL, (void*)&event};
2413 void* args[2] = {NULL, (void*)&event};
2408 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2414 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2409 if (result) { Py_DECREF(result); }
2415 if (result) { Py_DECREF(result); }
2410 Py_DECREF(obj);
2416 Py_DECREF(obj);
2411 return;
2417 return;
2412 }
2418 }
2413 }
2419 }
2414 QHexSpinBox::changeEvent(event);
2420 QHexSpinBox::changeEvent(event);
2415 }
2421 }
2416 void PythonQtShell_QHexSpinBox::childEvent(QChildEvent* arg__1)
2422 void PythonQtShell_QHexSpinBox::childEvent(QChildEvent* arg__1)
2417 {
2423 {
2418 if (_wrapper) {
2424 if (_wrapper) {
2419 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
2425 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
2420 PyErr_Clear();
2426 PyErr_Clear();
2421 if (obj && !PythonQtSlotFunction_Check(obj)) {
2427 if (obj && !PythonQtSlotFunction_Check(obj)) {
2422 static const char* argumentList[] ={"" , "QChildEvent*"};
2428 static const char* argumentList[] ={"" , "QChildEvent*"};
2423 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2429 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2424 void* args[2] = {NULL, (void*)&arg__1};
2430 void* args[2] = {NULL, (void*)&arg__1};
2425 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2431 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2426 if (result) { Py_DECREF(result); }
2432 if (result) { Py_DECREF(result); }
2427 Py_DECREF(obj);
2433 Py_DECREF(obj);
2428 return;
2434 return;
2429 }
2435 }
2430 }
2436 }
2431 QHexSpinBox::childEvent(arg__1);
2437 QHexSpinBox::childEvent(arg__1);
2432 }
2438 }
2433 void PythonQtShell_QHexSpinBox::clear()
2439 void PythonQtShell_QHexSpinBox::clear()
2434 {
2440 {
2435 if (_wrapper) {
2441 if (_wrapper) {
2436 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "clear");
2442 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "clear");
2437 PyErr_Clear();
2443 PyErr_Clear();
2438 if (obj && !PythonQtSlotFunction_Check(obj)) {
2444 if (obj && !PythonQtSlotFunction_Check(obj)) {
2439 static const char* argumentList[] ={""};
2445 static const char* argumentList[] ={""};
2440 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2446 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2441 void* args[1] = {NULL};
2447 void* args[1] = {NULL};
2442 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2448 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2443 if (result) { Py_DECREF(result); }
2449 if (result) { Py_DECREF(result); }
2444 Py_DECREF(obj);
2450 Py_DECREF(obj);
2445 return;
2451 return;
2446 }
2452 }
2447 }
2453 }
2448 QHexSpinBox::clear();
2454 QHexSpinBox::clear();
2449 }
2455 }
2450 void PythonQtShell_QHexSpinBox::closeEvent(QCloseEvent* event)
2456 void PythonQtShell_QHexSpinBox::closeEvent(QCloseEvent* event)
2451 {
2457 {
2452 if (_wrapper) {
2458 if (_wrapper) {
2453 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
2459 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
2454 PyErr_Clear();
2460 PyErr_Clear();
2455 if (obj && !PythonQtSlotFunction_Check(obj)) {
2461 if (obj && !PythonQtSlotFunction_Check(obj)) {
2456 static const char* argumentList[] ={"" , "QCloseEvent*"};
2462 static const char* argumentList[] ={"" , "QCloseEvent*"};
2457 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2463 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2458 void* args[2] = {NULL, (void*)&event};
2464 void* args[2] = {NULL, (void*)&event};
2459 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2465 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2460 if (result) { Py_DECREF(result); }
2466 if (result) { Py_DECREF(result); }
2461 Py_DECREF(obj);
2467 Py_DECREF(obj);
2462 return;
2468 return;
2463 }
2469 }
2464 }
2470 }
2465 QHexSpinBox::closeEvent(event);
2471 QHexSpinBox::closeEvent(event);
2466 }
2472 }
2467 void PythonQtShell_QHexSpinBox::contextMenuEvent(QContextMenuEvent* event)
2473 void PythonQtShell_QHexSpinBox::contextMenuEvent(QContextMenuEvent* event)
2468 {
2474 {
2469 if (_wrapper) {
2475 if (_wrapper) {
2470 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
2476 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
2471 PyErr_Clear();
2477 PyErr_Clear();
2472 if (obj && !PythonQtSlotFunction_Check(obj)) {
2478 if (obj && !PythonQtSlotFunction_Check(obj)) {
2473 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
2479 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
2474 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2480 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2475 void* args[2] = {NULL, (void*)&event};
2481 void* args[2] = {NULL, (void*)&event};
2476 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2482 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2477 if (result) { Py_DECREF(result); }
2483 if (result) { Py_DECREF(result); }
2478 Py_DECREF(obj);
2484 Py_DECREF(obj);
2479 return;
2485 return;
2480 }
2486 }
2481 }
2487 }
2482 QHexSpinBox::contextMenuEvent(event);
2488 QHexSpinBox::contextMenuEvent(event);
2483 }
2489 }
2484 void PythonQtShell_QHexSpinBox::customEvent(QEvent* arg__1)
2490 void PythonQtShell_QHexSpinBox::customEvent(QEvent* arg__1)
2485 {
2491 {
2486 if (_wrapper) {
2492 if (_wrapper) {
2487 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
2493 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
2488 PyErr_Clear();
2494 PyErr_Clear();
2489 if (obj && !PythonQtSlotFunction_Check(obj)) {
2495 if (obj && !PythonQtSlotFunction_Check(obj)) {
2490 static const char* argumentList[] ={"" , "QEvent*"};
2496 static const char* argumentList[] ={"" , "QEvent*"};
2491 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2497 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2492 void* args[2] = {NULL, (void*)&arg__1};
2498 void* args[2] = {NULL, (void*)&arg__1};
2493 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2499 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2494 if (result) { Py_DECREF(result); }
2500 if (result) { Py_DECREF(result); }
2495 Py_DECREF(obj);
2501 Py_DECREF(obj);
2496 return;
2502 return;
2497 }
2503 }
2498 }
2504 }
2499 QHexSpinBox::customEvent(arg__1);
2505 QHexSpinBox::customEvent(arg__1);
2500 }
2506 }
2501 int PythonQtShell_QHexSpinBox::devType() const
2507 int PythonQtShell_QHexSpinBox::devType() const
2502 {
2508 {
2503 if (_wrapper) {
2509 if (_wrapper) {
2504 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
2510 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
2505 PyErr_Clear();
2511 PyErr_Clear();
2506 if (obj && !PythonQtSlotFunction_Check(obj)) {
2512 if (obj && !PythonQtSlotFunction_Check(obj)) {
2507 static const char* argumentList[] ={"int"};
2513 static const char* argumentList[] ={"int"};
2508 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2514 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2509 int returnValue;
2515 int returnValue;
2510 void* args[1] = {NULL};
2516 void* args[1] = {NULL};
2511 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2517 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2512 if (result) {
2518 if (result) {
2513 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2519 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2514 if (args[0]!=&returnValue) {
2520 if (args[0]!=&returnValue) {
2515 if (args[0]==NULL) {
2521 if (args[0]==NULL) {
2516 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
2522 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
2517 } else {
2523 } else {
2518 returnValue = *((int*)args[0]);
2524 returnValue = *((int*)args[0]);
2519 }
2525 }
2520 }
2526 }
2521 }
2527 }
2522 if (result) { Py_DECREF(result); }
2528 if (result) { Py_DECREF(result); }
2523 Py_DECREF(obj);
2529 Py_DECREF(obj);
2524 return returnValue;
2530 return returnValue;
2525 }
2531 }
2526 }
2532 }
2527 return QHexSpinBox::devType();
2533 return QHexSpinBox::devType();
2528 }
2534 }
2529 void PythonQtShell_QHexSpinBox::dragEnterEvent(QDragEnterEvent* arg__1)
2535 void PythonQtShell_QHexSpinBox::dragEnterEvent(QDragEnterEvent* arg__1)
2530 {
2536 {
2531 if (_wrapper) {
2537 if (_wrapper) {
2532 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
2538 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
2533 PyErr_Clear();
2539 PyErr_Clear();
2534 if (obj && !PythonQtSlotFunction_Check(obj)) {
2540 if (obj && !PythonQtSlotFunction_Check(obj)) {
2535 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
2541 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
2536 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2542 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2537 void* args[2] = {NULL, (void*)&arg__1};
2543 void* args[2] = {NULL, (void*)&arg__1};
2538 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2544 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2539 if (result) { Py_DECREF(result); }
2545 if (result) { Py_DECREF(result); }
2540 Py_DECREF(obj);
2546 Py_DECREF(obj);
2541 return;
2547 return;
2542 }
2548 }
2543 }
2549 }
2544 QHexSpinBox::dragEnterEvent(arg__1);
2550 QHexSpinBox::dragEnterEvent(arg__1);
2545 }
2551 }
2546 void PythonQtShell_QHexSpinBox::dragLeaveEvent(QDragLeaveEvent* arg__1)
2552 void PythonQtShell_QHexSpinBox::dragLeaveEvent(QDragLeaveEvent* arg__1)
2547 {
2553 {
2548 if (_wrapper) {
2554 if (_wrapper) {
2549 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
2555 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
2550 PyErr_Clear();
2556 PyErr_Clear();
2551 if (obj && !PythonQtSlotFunction_Check(obj)) {
2557 if (obj && !PythonQtSlotFunction_Check(obj)) {
2552 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
2558 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
2553 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2559 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2554 void* args[2] = {NULL, (void*)&arg__1};
2560 void* args[2] = {NULL, (void*)&arg__1};
2555 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2561 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2556 if (result) { Py_DECREF(result); }
2562 if (result) { Py_DECREF(result); }
2557 Py_DECREF(obj);
2563 Py_DECREF(obj);
2558 return;
2564 return;
2559 }
2565 }
2560 }
2566 }
2561 QHexSpinBox::dragLeaveEvent(arg__1);
2567 QHexSpinBox::dragLeaveEvent(arg__1);
2562 }
2568 }
2563 void PythonQtShell_QHexSpinBox::dragMoveEvent(QDragMoveEvent* arg__1)
2569 void PythonQtShell_QHexSpinBox::dragMoveEvent(QDragMoveEvent* arg__1)
2564 {
2570 {
2565 if (_wrapper) {
2571 if (_wrapper) {
2566 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
2572 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
2567 PyErr_Clear();
2573 PyErr_Clear();
2568 if (obj && !PythonQtSlotFunction_Check(obj)) {
2574 if (obj && !PythonQtSlotFunction_Check(obj)) {
2569 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
2575 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
2570 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2576 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2571 void* args[2] = {NULL, (void*)&arg__1};
2577 void* args[2] = {NULL, (void*)&arg__1};
2572 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2578 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2573 if (result) { Py_DECREF(result); }
2579 if (result) { Py_DECREF(result); }
2574 Py_DECREF(obj);
2580 Py_DECREF(obj);
2575 return;
2581 return;
2576 }
2582 }
2577 }
2583 }
2578 QHexSpinBox::dragMoveEvent(arg__1);
2584 QHexSpinBox::dragMoveEvent(arg__1);
2579 }
2585 }
2580 void PythonQtShell_QHexSpinBox::dropEvent(QDropEvent* arg__1)
2586 void PythonQtShell_QHexSpinBox::dropEvent(QDropEvent* arg__1)
2581 {
2587 {
2582 if (_wrapper) {
2588 if (_wrapper) {
2583 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
2589 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
2584 PyErr_Clear();
2590 PyErr_Clear();
2585 if (obj && !PythonQtSlotFunction_Check(obj)) {
2591 if (obj && !PythonQtSlotFunction_Check(obj)) {
2586 static const char* argumentList[] ={"" , "QDropEvent*"};
2592 static const char* argumentList[] ={"" , "QDropEvent*"};
2587 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2593 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2588 void* args[2] = {NULL, (void*)&arg__1};
2594 void* args[2] = {NULL, (void*)&arg__1};
2589 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2595 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2590 if (result) { Py_DECREF(result); }
2596 if (result) { Py_DECREF(result); }
2591 Py_DECREF(obj);
2597 Py_DECREF(obj);
2592 return;
2598 return;
2593 }
2599 }
2594 }
2600 }
2595 QHexSpinBox::dropEvent(arg__1);
2601 QHexSpinBox::dropEvent(arg__1);
2596 }
2602 }
2597 void PythonQtShell_QHexSpinBox::enterEvent(QEvent* arg__1)
2603 void PythonQtShell_QHexSpinBox::enterEvent(QEvent* arg__1)
2598 {
2604 {
2599 if (_wrapper) {
2605 if (_wrapper) {
2600 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
2606 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
2601 PyErr_Clear();
2607 PyErr_Clear();
2602 if (obj && !PythonQtSlotFunction_Check(obj)) {
2608 if (obj && !PythonQtSlotFunction_Check(obj)) {
2603 static const char* argumentList[] ={"" , "QEvent*"};
2609 static const char* argumentList[] ={"" , "QEvent*"};
2604 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2610 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2605 void* args[2] = {NULL, (void*)&arg__1};
2611 void* args[2] = {NULL, (void*)&arg__1};
2606 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2612 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2607 if (result) { Py_DECREF(result); }
2613 if (result) { Py_DECREF(result); }
2608 Py_DECREF(obj);
2614 Py_DECREF(obj);
2609 return;
2615 return;
2610 }
2616 }
2611 }
2617 }
2612 QHexSpinBox::enterEvent(arg__1);
2618 QHexSpinBox::enterEvent(arg__1);
2613 }
2619 }
2614 bool PythonQtShell_QHexSpinBox::event(QEvent* event)
2620 bool PythonQtShell_QHexSpinBox::event(QEvent* event)
2615 {
2621 {
2616 if (_wrapper) {
2622 if (_wrapper) {
2617 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
2623 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
2618 PyErr_Clear();
2624 PyErr_Clear();
2619 if (obj && !PythonQtSlotFunction_Check(obj)) {
2625 if (obj && !PythonQtSlotFunction_Check(obj)) {
2620 static const char* argumentList[] ={"bool" , "QEvent*"};
2626 static const char* argumentList[] ={"bool" , "QEvent*"};
2621 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2627 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2622 bool returnValue;
2628 bool returnValue;
2623 void* args[2] = {NULL, (void*)&event};
2629 void* args[2] = {NULL, (void*)&event};
2624 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2630 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2625 if (result) {
2631 if (result) {
2626 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2632 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2627 if (args[0]!=&returnValue) {
2633 if (args[0]!=&returnValue) {
2628 if (args[0]==NULL) {
2634 if (args[0]==NULL) {
2629 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
2635 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
2630 } else {
2636 } else {
2631 returnValue = *((bool*)args[0]);
2637 returnValue = *((bool*)args[0]);
2632 }
2638 }
2633 }
2639 }
2634 }
2640 }
2635 if (result) { Py_DECREF(result); }
2641 if (result) { Py_DECREF(result); }
2636 Py_DECREF(obj);
2642 Py_DECREF(obj);
2637 return returnValue;
2643 return returnValue;
2638 }
2644 }
2639 }
2645 }
2640 return QHexSpinBox::event(event);
2646 return QHexSpinBox::event(event);
2641 }
2647 }
2642 bool PythonQtShell_QHexSpinBox::eventFilter(QObject* arg__1, QEvent* arg__2)
2648 bool PythonQtShell_QHexSpinBox::eventFilter(QObject* arg__1, QEvent* arg__2)
2643 {
2649 {
2644 if (_wrapper) {
2650 if (_wrapper) {
2645 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
2651 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
2646 PyErr_Clear();
2652 PyErr_Clear();
2647 if (obj && !PythonQtSlotFunction_Check(obj)) {
2653 if (obj && !PythonQtSlotFunction_Check(obj)) {
2648 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
2654 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
2649 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2655 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2650 bool returnValue;
2656 bool returnValue;
2651 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
2657 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
2652 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2658 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2653 if (result) {
2659 if (result) {
2654 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2660 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2655 if (args[0]!=&returnValue) {
2661 if (args[0]!=&returnValue) {
2656 if (args[0]==NULL) {
2662 if (args[0]==NULL) {
2657 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
2663 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
2658 } else {
2664 } else {
2659 returnValue = *((bool*)args[0]);
2665 returnValue = *((bool*)args[0]);
2660 }
2666 }
2661 }
2667 }
2662 }
2668 }
2663 if (result) { Py_DECREF(result); }
2669 if (result) { Py_DECREF(result); }
2664 Py_DECREF(obj);
2670 Py_DECREF(obj);
2665 return returnValue;
2671 return returnValue;
2666 }
2672 }
2667 }
2673 }
2668 return QHexSpinBox::eventFilter(arg__1, arg__2);
2674 return QHexSpinBox::eventFilter(arg__1, arg__2);
2669 }
2675 }
2670 void PythonQtShell_QHexSpinBox::fixup(QString& str) const
2676 void PythonQtShell_QHexSpinBox::fixup(QString& str) const
2671 {
2677 {
2672 if (_wrapper) {
2678 if (_wrapper) {
2673 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "fixup");
2679 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "fixup");
2674 PyErr_Clear();
2680 PyErr_Clear();
2675 if (obj && !PythonQtSlotFunction_Check(obj)) {
2681 if (obj && !PythonQtSlotFunction_Check(obj)) {
2676 static const char* argumentList[] ={"" , "QString&"};
2682 static const char* argumentList[] ={"" , "QString&"};
2677 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2683 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2678 void* args[2] = {NULL, (void*)&str};
2684 void* args[2] = {NULL, (void*)&str};
2679 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2685 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2680 if (result) { Py_DECREF(result); }
2686 if (result) { Py_DECREF(result); }
2681 Py_DECREF(obj);
2687 Py_DECREF(obj);
2682 return;
2688 return;
2683 }
2689 }
2684 }
2690 }
2685 QHexSpinBox::fixup(str);
2691 QHexSpinBox::fixup(str);
2686 }
2692 }
2687 void PythonQtShell_QHexSpinBox::focusInEvent(QFocusEvent* event)
2693 void PythonQtShell_QHexSpinBox::focusInEvent(QFocusEvent* event)
2688 {
2694 {
2689 if (_wrapper) {
2695 if (_wrapper) {
2690 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
2696 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
2691 PyErr_Clear();
2697 PyErr_Clear();
2692 if (obj && !PythonQtSlotFunction_Check(obj)) {
2698 if (obj && !PythonQtSlotFunction_Check(obj)) {
2693 static const char* argumentList[] ={"" , "QFocusEvent*"};
2699 static const char* argumentList[] ={"" , "QFocusEvent*"};
2694 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2700 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2695 void* args[2] = {NULL, (void*)&event};
2701 void* args[2] = {NULL, (void*)&event};
2696 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2702 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2697 if (result) { Py_DECREF(result); }
2703 if (result) { Py_DECREF(result); }
2698 Py_DECREF(obj);
2704 Py_DECREF(obj);
2699 return;
2705 return;
2700 }
2706 }
2701 }
2707 }
2702 QHexSpinBox::focusInEvent(event);
2708 QHexSpinBox::focusInEvent(event);
2703 }
2709 }
2704 bool PythonQtShell_QHexSpinBox::focusNextPrevChild(bool next)
2710 bool PythonQtShell_QHexSpinBox::focusNextPrevChild(bool next)
2705 {
2711 {
2706 if (_wrapper) {
2712 if (_wrapper) {
2707 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
2713 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
2708 PyErr_Clear();
2714 PyErr_Clear();
2709 if (obj && !PythonQtSlotFunction_Check(obj)) {
2715 if (obj && !PythonQtSlotFunction_Check(obj)) {
2710 static const char* argumentList[] ={"bool" , "bool"};
2716 static const char* argumentList[] ={"bool" , "bool"};
2711 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2717 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2712 bool returnValue;
2718 bool returnValue;
2713 void* args[2] = {NULL, (void*)&next};
2719 void* args[2] = {NULL, (void*)&next};
2714 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2720 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2715 if (result) {
2721 if (result) {
2716 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2722 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2717 if (args[0]!=&returnValue) {
2723 if (args[0]!=&returnValue) {
2718 if (args[0]==NULL) {
2724 if (args[0]==NULL) {
2719 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
2725 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
2720 } else {
2726 } else {
2721 returnValue = *((bool*)args[0]);
2727 returnValue = *((bool*)args[0]);
2722 }
2728 }
2723 }
2729 }
2724 }
2730 }
2725 if (result) { Py_DECREF(result); }
2731 if (result) { Py_DECREF(result); }
2726 Py_DECREF(obj);
2732 Py_DECREF(obj);
2727 return returnValue;
2733 return returnValue;
2728 }
2734 }
2729 }
2735 }
2730 return QHexSpinBox::focusNextPrevChild(next);
2736 return QHexSpinBox::focusNextPrevChild(next);
2731 }
2737 }
2732 void PythonQtShell_QHexSpinBox::focusOutEvent(QFocusEvent* event)
2738 void PythonQtShell_QHexSpinBox::focusOutEvent(QFocusEvent* event)
2733 {
2739 {
2734 if (_wrapper) {
2740 if (_wrapper) {
2735 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
2741 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
2736 PyErr_Clear();
2742 PyErr_Clear();
2737 if (obj && !PythonQtSlotFunction_Check(obj)) {
2743 if (obj && !PythonQtSlotFunction_Check(obj)) {
2738 static const char* argumentList[] ={"" , "QFocusEvent*"};
2744 static const char* argumentList[] ={"" , "QFocusEvent*"};
2739 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2745 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2740 void* args[2] = {NULL, (void*)&event};
2746 void* args[2] = {NULL, (void*)&event};
2741 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2747 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2742 if (result) { Py_DECREF(result); }
2748 if (result) { Py_DECREF(result); }
2743 Py_DECREF(obj);
2749 Py_DECREF(obj);
2744 return;
2750 return;
2745 }
2751 }
2746 }
2752 }
2747 QHexSpinBox::focusOutEvent(event);
2753 QHexSpinBox::focusOutEvent(event);
2748 }
2754 }
2749 bool PythonQtShell_QHexSpinBox::hasHeightForWidth() const
2755 bool PythonQtShell_QHexSpinBox::hasHeightForWidth() const
2750 {
2756 {
2751 if (_wrapper) {
2757 if (_wrapper) {
2752 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
2758 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
2753 PyErr_Clear();
2759 PyErr_Clear();
2754 if (obj && !PythonQtSlotFunction_Check(obj)) {
2760 if (obj && !PythonQtSlotFunction_Check(obj)) {
2755 static const char* argumentList[] ={"bool"};
2761 static const char* argumentList[] ={"bool"};
2756 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2762 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2757 bool returnValue;
2763 bool returnValue;
2758 void* args[1] = {NULL};
2764 void* args[1] = {NULL};
2759 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2765 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2760 if (result) {
2766 if (result) {
2761 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2767 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2762 if (args[0]!=&returnValue) {
2768 if (args[0]!=&returnValue) {
2763 if (args[0]==NULL) {
2769 if (args[0]==NULL) {
2764 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
2770 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
2765 } else {
2771 } else {
2766 returnValue = *((bool*)args[0]);
2772 returnValue = *((bool*)args[0]);
2767 }
2773 }
2768 }
2774 }
2769 }
2775 }
2770 if (result) { Py_DECREF(result); }
2776 if (result) { Py_DECREF(result); }
2771 Py_DECREF(obj);
2777 Py_DECREF(obj);
2772 return returnValue;
2778 return returnValue;
2773 }
2779 }
2774 }
2780 }
2775 return QHexSpinBox::hasHeightForWidth();
2781 return QHexSpinBox::hasHeightForWidth();
2776 }
2782 }
2777 int PythonQtShell_QHexSpinBox::heightForWidth(int arg__1) const
2783 int PythonQtShell_QHexSpinBox::heightForWidth(int arg__1) const
2778 {
2784 {
2779 if (_wrapper) {
2785 if (_wrapper) {
2780 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
2786 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
2781 PyErr_Clear();
2787 PyErr_Clear();
2782 if (obj && !PythonQtSlotFunction_Check(obj)) {
2788 if (obj && !PythonQtSlotFunction_Check(obj)) {
2783 static const char* argumentList[] ={"int" , "int"};
2789 static const char* argumentList[] ={"int" , "int"};
2784 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2790 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2785 int returnValue;
2791 int returnValue;
2786 void* args[2] = {NULL, (void*)&arg__1};
2792 void* args[2] = {NULL, (void*)&arg__1};
2787 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2793 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2788 if (result) {
2794 if (result) {
2789 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2795 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2790 if (args[0]!=&returnValue) {
2796 if (args[0]!=&returnValue) {
2791 if (args[0]==NULL) {
2797 if (args[0]==NULL) {
2792 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
2798 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
2793 } else {
2799 } else {
2794 returnValue = *((int*)args[0]);
2800 returnValue = *((int*)args[0]);
2795 }
2801 }
2796 }
2802 }
2797 }
2803 }
2798 if (result) { Py_DECREF(result); }
2804 if (result) { Py_DECREF(result); }
2799 Py_DECREF(obj);
2805 Py_DECREF(obj);
2800 return returnValue;
2806 return returnValue;
2801 }
2807 }
2802 }
2808 }
2803 return QHexSpinBox::heightForWidth(arg__1);
2809 return QHexSpinBox::heightForWidth(arg__1);
2804 }
2810 }
2805 void PythonQtShell_QHexSpinBox::hideEvent(QHideEvent* event)
2811 void PythonQtShell_QHexSpinBox::hideEvent(QHideEvent* event)
2806 {
2812 {
2807 if (_wrapper) {
2813 if (_wrapper) {
2808 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
2814 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
2809 PyErr_Clear();
2815 PyErr_Clear();
2810 if (obj && !PythonQtSlotFunction_Check(obj)) {
2816 if (obj && !PythonQtSlotFunction_Check(obj)) {
2811 static const char* argumentList[] ={"" , "QHideEvent*"};
2817 static const char* argumentList[] ={"" , "QHideEvent*"};
2812 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2818 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2813 void* args[2] = {NULL, (void*)&event};
2819 void* args[2] = {NULL, (void*)&event};
2814 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2820 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2815 if (result) { Py_DECREF(result); }
2821 if (result) { Py_DECREF(result); }
2816 Py_DECREF(obj);
2822 Py_DECREF(obj);
2817 return;
2823 return;
2818 }
2824 }
2819 }
2825 }
2820 QHexSpinBox::hideEvent(event);
2826 QHexSpinBox::hideEvent(event);
2821 }
2827 }
2822 void PythonQtShell_QHexSpinBox::initPainter(QPainter* painter) const
2828 void PythonQtShell_QHexSpinBox::initPainter(QPainter* painter) const
2823 {
2829 {
2824 if (_wrapper) {
2830 if (_wrapper) {
2825 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
2831 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
2826 PyErr_Clear();
2832 PyErr_Clear();
2827 if (obj && !PythonQtSlotFunction_Check(obj)) {
2833 if (obj && !PythonQtSlotFunction_Check(obj)) {
2828 static const char* argumentList[] ={"" , "QPainter*"};
2834 static const char* argumentList[] ={"" , "QPainter*"};
2829 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2835 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2830 void* args[2] = {NULL, (void*)&painter};
2836 void* args[2] = {NULL, (void*)&painter};
2831 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2837 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2832 if (result) { Py_DECREF(result); }
2838 if (result) { Py_DECREF(result); }
2833 Py_DECREF(obj);
2839 Py_DECREF(obj);
2834 return;
2840 return;
2835 }
2841 }
2836 }
2842 }
2837 QHexSpinBox::initPainter(painter);
2843 QHexSpinBox::initPainter(painter);
2838 }
2844 }
2839 void PythonQtShell_QHexSpinBox::inputMethodEvent(QInputMethodEvent* arg__1)
2845 void PythonQtShell_QHexSpinBox::inputMethodEvent(QInputMethodEvent* arg__1)
2840 {
2846 {
2841 if (_wrapper) {
2847 if (_wrapper) {
2842 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
2848 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
2843 PyErr_Clear();
2849 PyErr_Clear();
2844 if (obj && !PythonQtSlotFunction_Check(obj)) {
2850 if (obj && !PythonQtSlotFunction_Check(obj)) {
2845 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
2851 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
2846 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2852 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2847 void* args[2] = {NULL, (void*)&arg__1};
2853 void* args[2] = {NULL, (void*)&arg__1};
2848 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2854 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2849 if (result) { Py_DECREF(result); }
2855 if (result) { Py_DECREF(result); }
2850 Py_DECREF(obj);
2856 Py_DECREF(obj);
2851 return;
2857 return;
2852 }
2858 }
2853 }
2859 }
2854 QHexSpinBox::inputMethodEvent(arg__1);
2860 QHexSpinBox::inputMethodEvent(arg__1);
2855 }
2861 }
2856 QVariant PythonQtShell_QHexSpinBox::inputMethodQuery(Qt::InputMethodQuery arg__1) const
2862 QVariant PythonQtShell_QHexSpinBox::inputMethodQuery(Qt::InputMethodQuery arg__1) const
2857 {
2863 {
2858 if (_wrapper) {
2864 if (_wrapper) {
2859 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
2865 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
2860 PyErr_Clear();
2866 PyErr_Clear();
2861 if (obj && !PythonQtSlotFunction_Check(obj)) {
2867 if (obj && !PythonQtSlotFunction_Check(obj)) {
2862 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
2868 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
2863 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2869 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2864 QVariant returnValue;
2870 QVariant returnValue;
2865 void* args[2] = {NULL, (void*)&arg__1};
2871 void* args[2] = {NULL, (void*)&arg__1};
2866 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2872 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2867 if (result) {
2873 if (result) {
2868 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2874 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2869 if (args[0]!=&returnValue) {
2875 if (args[0]!=&returnValue) {
2870 if (args[0]==NULL) {
2876 if (args[0]==NULL) {
2871 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
2877 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
2872 } else {
2878 } else {
2873 returnValue = *((QVariant*)args[0]);
2879 returnValue = *((QVariant*)args[0]);
2874 }
2880 }
2875 }
2881 }
2876 }
2882 }
2877 if (result) { Py_DECREF(result); }
2883 if (result) { Py_DECREF(result); }
2878 Py_DECREF(obj);
2884 Py_DECREF(obj);
2879 return returnValue;
2885 return returnValue;
2880 }
2886 }
2881 }
2887 }
2882 return QHexSpinBox::inputMethodQuery(arg__1);
2888 return QHexSpinBox::inputMethodQuery(arg__1);
2883 }
2889 }
2884 void PythonQtShell_QHexSpinBox::keyPressEvent(QKeyEvent* event)
2890 void PythonQtShell_QHexSpinBox::keyPressEvent(QKeyEvent* event)
2885 {
2891 {
2886 if (_wrapper) {
2892 if (_wrapper) {
2887 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
2893 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
2888 PyErr_Clear();
2894 PyErr_Clear();
2889 if (obj && !PythonQtSlotFunction_Check(obj)) {
2895 if (obj && !PythonQtSlotFunction_Check(obj)) {
2890 static const char* argumentList[] ={"" , "QKeyEvent*"};
2896 static const char* argumentList[] ={"" , "QKeyEvent*"};
2891 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2897 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2892 void* args[2] = {NULL, (void*)&event};
2898 void* args[2] = {NULL, (void*)&event};
2893 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2899 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2894 if (result) { Py_DECREF(result); }
2900 if (result) { Py_DECREF(result); }
2895 Py_DECREF(obj);
2901 Py_DECREF(obj);
2896 return;
2902 return;
2897 }
2903 }
2898 }
2904 }
2899 QHexSpinBox::keyPressEvent(event);
2905 QHexSpinBox::keyPressEvent(event);
2900 }
2906 }
2901 void PythonQtShell_QHexSpinBox::keyReleaseEvent(QKeyEvent* event)
2907 void PythonQtShell_QHexSpinBox::keyReleaseEvent(QKeyEvent* event)
2902 {
2908 {
2903 if (_wrapper) {
2909 if (_wrapper) {
2904 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
2910 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
2905 PyErr_Clear();
2911 PyErr_Clear();
2906 if (obj && !PythonQtSlotFunction_Check(obj)) {
2912 if (obj && !PythonQtSlotFunction_Check(obj)) {
2907 static const char* argumentList[] ={"" , "QKeyEvent*"};
2913 static const char* argumentList[] ={"" , "QKeyEvent*"};
2908 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2914 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2909 void* args[2] = {NULL, (void*)&event};
2915 void* args[2] = {NULL, (void*)&event};
2910 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2916 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2911 if (result) { Py_DECREF(result); }
2917 if (result) { Py_DECREF(result); }
2912 Py_DECREF(obj);
2918 Py_DECREF(obj);
2913 return;
2919 return;
2914 }
2920 }
2915 }
2921 }
2916 QHexSpinBox::keyReleaseEvent(event);
2922 QHexSpinBox::keyReleaseEvent(event);
2917 }
2923 }
2918 void PythonQtShell_QHexSpinBox::leaveEvent(QEvent* arg__1)
2924 void PythonQtShell_QHexSpinBox::leaveEvent(QEvent* arg__1)
2919 {
2925 {
2920 if (_wrapper) {
2926 if (_wrapper) {
2921 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
2927 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
2922 PyErr_Clear();
2928 PyErr_Clear();
2923 if (obj && !PythonQtSlotFunction_Check(obj)) {
2929 if (obj && !PythonQtSlotFunction_Check(obj)) {
2924 static const char* argumentList[] ={"" , "QEvent*"};
2930 static const char* argumentList[] ={"" , "QEvent*"};
2925 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2931 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2926 void* args[2] = {NULL, (void*)&arg__1};
2932 void* args[2] = {NULL, (void*)&arg__1};
2927 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2933 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2928 if (result) { Py_DECREF(result); }
2934 if (result) { Py_DECREF(result); }
2929 Py_DECREF(obj);
2935 Py_DECREF(obj);
2930 return;
2936 return;
2931 }
2937 }
2932 }
2938 }
2933 QHexSpinBox::leaveEvent(arg__1);
2939 QHexSpinBox::leaveEvent(arg__1);
2934 }
2940 }
2935 int PythonQtShell_QHexSpinBox::metric(QPaintDevice::PaintDeviceMetric arg__1) const
2941 int PythonQtShell_QHexSpinBox::metric(QPaintDevice::PaintDeviceMetric arg__1) const
2936 {
2942 {
2937 if (_wrapper) {
2943 if (_wrapper) {
2938 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
2944 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
2939 PyErr_Clear();
2945 PyErr_Clear();
2940 if (obj && !PythonQtSlotFunction_Check(obj)) {
2946 if (obj && !PythonQtSlotFunction_Check(obj)) {
2941 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
2947 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
2942 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2948 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2943 int returnValue;
2949 int returnValue;
2944 void* args[2] = {NULL, (void*)&arg__1};
2950 void* args[2] = {NULL, (void*)&arg__1};
2945 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2951 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2946 if (result) {
2952 if (result) {
2947 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2953 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2948 if (args[0]!=&returnValue) {
2954 if (args[0]!=&returnValue) {
2949 if (args[0]==NULL) {
2955 if (args[0]==NULL) {
2950 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
2956 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
2951 } else {
2957 } else {
2952 returnValue = *((int*)args[0]);
2958 returnValue = *((int*)args[0]);
2953 }
2959 }
2954 }
2960 }
2955 }
2961 }
2956 if (result) { Py_DECREF(result); }
2962 if (result) { Py_DECREF(result); }
2957 Py_DECREF(obj);
2963 Py_DECREF(obj);
2958 return returnValue;
2964 return returnValue;
2959 }
2965 }
2960 }
2966 }
2961 return QHexSpinBox::metric(arg__1);
2967 return QHexSpinBox::metric(arg__1);
2962 }
2968 }
2963 void PythonQtShell_QHexSpinBox::mouseDoubleClickEvent(QMouseEvent* arg__1)
2969 void PythonQtShell_QHexSpinBox::mouseDoubleClickEvent(QMouseEvent* arg__1)
2964 {
2970 {
2965 if (_wrapper) {
2971 if (_wrapper) {
2966 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
2972 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
2967 PyErr_Clear();
2973 PyErr_Clear();
2968 if (obj && !PythonQtSlotFunction_Check(obj)) {
2974 if (obj && !PythonQtSlotFunction_Check(obj)) {
2969 static const char* argumentList[] ={"" , "QMouseEvent*"};
2975 static const char* argumentList[] ={"" , "QMouseEvent*"};
2970 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2976 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2971 void* args[2] = {NULL, (void*)&arg__1};
2977 void* args[2] = {NULL, (void*)&arg__1};
2972 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2978 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2973 if (result) { Py_DECREF(result); }
2979 if (result) { Py_DECREF(result); }
2974 Py_DECREF(obj);
2980 Py_DECREF(obj);
2975 return;
2981 return;
2976 }
2982 }
2977 }
2983 }
2978 QHexSpinBox::mouseDoubleClickEvent(arg__1);
2984 QHexSpinBox::mouseDoubleClickEvent(arg__1);
2979 }
2985 }
2980 void PythonQtShell_QHexSpinBox::mouseMoveEvent(QMouseEvent* event)
2986 void PythonQtShell_QHexSpinBox::mouseMoveEvent(QMouseEvent* event)
2981 {
2987 {
2982 if (_wrapper) {
2988 if (_wrapper) {
2983 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
2989 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
2984 PyErr_Clear();
2990 PyErr_Clear();
2985 if (obj && !PythonQtSlotFunction_Check(obj)) {
2991 if (obj && !PythonQtSlotFunction_Check(obj)) {
2986 static const char* argumentList[] ={"" , "QMouseEvent*"};
2992 static const char* argumentList[] ={"" , "QMouseEvent*"};
2987 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2993 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2988 void* args[2] = {NULL, (void*)&event};
2994 void* args[2] = {NULL, (void*)&event};
2989 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2995 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2990 if (result) { Py_DECREF(result); }
2996 if (result) { Py_DECREF(result); }
2991 Py_DECREF(obj);
2997 Py_DECREF(obj);
2992 return;
2998 return;
2993 }
2999 }
2994 }
3000 }
2995 QHexSpinBox::mouseMoveEvent(event);
3001 QHexSpinBox::mouseMoveEvent(event);
2996 }
3002 }
2997 void PythonQtShell_QHexSpinBox::mousePressEvent(QMouseEvent* event)
3003 void PythonQtShell_QHexSpinBox::mousePressEvent(QMouseEvent* event)
2998 {
3004 {
2999 if (_wrapper) {
3005 if (_wrapper) {
3000 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
3006 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
3001 PyErr_Clear();
3007 PyErr_Clear();
3002 if (obj && !PythonQtSlotFunction_Check(obj)) {
3008 if (obj && !PythonQtSlotFunction_Check(obj)) {
3003 static const char* argumentList[] ={"" , "QMouseEvent*"};
3009 static const char* argumentList[] ={"" , "QMouseEvent*"};
3004 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3010 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3005 void* args[2] = {NULL, (void*)&event};
3011 void* args[2] = {NULL, (void*)&event};
3006 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3012 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3007 if (result) { Py_DECREF(result); }
3013 if (result) { Py_DECREF(result); }
3008 Py_DECREF(obj);
3014 Py_DECREF(obj);
3009 return;
3015 return;
3010 }
3016 }
3011 }
3017 }
3012 QHexSpinBox::mousePressEvent(event);
3018 QHexSpinBox::mousePressEvent(event);
3013 }
3019 }
3014 void PythonQtShell_QHexSpinBox::mouseReleaseEvent(QMouseEvent* event)
3020 void PythonQtShell_QHexSpinBox::mouseReleaseEvent(QMouseEvent* event)
3015 {
3021 {
3016 if (_wrapper) {
3022 if (_wrapper) {
3017 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
3023 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
3018 PyErr_Clear();
3024 PyErr_Clear();
3019 if (obj && !PythonQtSlotFunction_Check(obj)) {
3025 if (obj && !PythonQtSlotFunction_Check(obj)) {
3020 static const char* argumentList[] ={"" , "QMouseEvent*"};
3026 static const char* argumentList[] ={"" , "QMouseEvent*"};
3021 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3027 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3022 void* args[2] = {NULL, (void*)&event};
3028 void* args[2] = {NULL, (void*)&event};
3023 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3029 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3024 if (result) { Py_DECREF(result); }
3030 if (result) { Py_DECREF(result); }
3025 Py_DECREF(obj);
3031 Py_DECREF(obj);
3026 return;
3032 return;
3027 }
3033 }
3028 }
3034 }
3029 QHexSpinBox::mouseReleaseEvent(event);
3035 QHexSpinBox::mouseReleaseEvent(event);
3030 }
3036 }
3031 void PythonQtShell_QHexSpinBox::moveEvent(QMoveEvent* arg__1)
3037 void PythonQtShell_QHexSpinBox::moveEvent(QMoveEvent* arg__1)
3032 {
3038 {
3033 if (_wrapper) {
3039 if (_wrapper) {
3034 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
3040 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
3035 PyErr_Clear();
3041 PyErr_Clear();
3036 if (obj && !PythonQtSlotFunction_Check(obj)) {
3042 if (obj && !PythonQtSlotFunction_Check(obj)) {
3037 static const char* argumentList[] ={"" , "QMoveEvent*"};
3043 static const char* argumentList[] ={"" , "QMoveEvent*"};
3038 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3044 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3039 void* args[2] = {NULL, (void*)&arg__1};
3045 void* args[2] = {NULL, (void*)&arg__1};
3040 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3046 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3041 if (result) { Py_DECREF(result); }
3047 if (result) { Py_DECREF(result); }
3042 Py_DECREF(obj);
3048 Py_DECREF(obj);
3043 return;
3049 return;
3044 }
3050 }
3045 }
3051 }
3046 QHexSpinBox::moveEvent(arg__1);
3052 QHexSpinBox::moveEvent(arg__1);
3047 }
3053 }
3048 bool PythonQtShell_QHexSpinBox::nativeEvent(const QByteArray& eventType, void* message, long* result)
3054 bool PythonQtShell_QHexSpinBox::nativeEvent(const QByteArray& eventType, void* message, long* result)
3049 {
3055 {
3050 if (_wrapper) {
3056 if (_wrapper) {
3051 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
3057 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
3052 PyErr_Clear();
3058 PyErr_Clear();
3053 if (obj && !PythonQtSlotFunction_Check(obj)) {
3059 if (obj && !PythonQtSlotFunction_Check(obj)) {
3054 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
3060 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
3055 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
3061 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
3056 bool returnValue;
3062 bool returnValue;
3057 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
3063 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
3058 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3064 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3059 if (result) {
3065 if (result) {
3060 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3066 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3061 if (args[0]!=&returnValue) {
3067 if (args[0]!=&returnValue) {
3062 if (args[0]==NULL) {
3068 if (args[0]==NULL) {
3063 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
3069 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
3064 } else {
3070 } else {
3065 returnValue = *((bool*)args[0]);
3071 returnValue = *((bool*)args[0]);
3066 }
3072 }
3067 }
3073 }
3068 }
3074 }
3069 if (result) { Py_DECREF(result); }
3075 if (result) { Py_DECREF(result); }
3070 Py_DECREF(obj);
3076 Py_DECREF(obj);
3071 return returnValue;
3077 return returnValue;
3072 }
3078 }
3073 }
3079 }
3074 return QHexSpinBox::nativeEvent(eventType, message, result);
3080 return QHexSpinBox::nativeEvent(eventType, message, result);
3075 }
3081 }
3076 QPaintEngine* PythonQtShell_QHexSpinBox::paintEngine() const
3082 QPaintEngine* PythonQtShell_QHexSpinBox::paintEngine() const
3077 {
3083 {
3078 if (_wrapper) {
3084 if (_wrapper) {
3079 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
3085 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
3080 PyErr_Clear();
3086 PyErr_Clear();
3081 if (obj && !PythonQtSlotFunction_Check(obj)) {
3087 if (obj && !PythonQtSlotFunction_Check(obj)) {
3082 static const char* argumentList[] ={"QPaintEngine*"};
3088 static const char* argumentList[] ={"QPaintEngine*"};
3083 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3089 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3084 QPaintEngine* returnValue;
3090 QPaintEngine* returnValue;
3085 void* args[1] = {NULL};
3091 void* args[1] = {NULL};
3086 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3092 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3087 if (result) {
3093 if (result) {
3088 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3094 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3089 if (args[0]!=&returnValue) {
3095 if (args[0]!=&returnValue) {
3090 if (args[0]==NULL) {
3096 if (args[0]==NULL) {
3091 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
3097 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
3092 } else {
3098 } else {
3093 returnValue = *((QPaintEngine**)args[0]);
3099 returnValue = *((QPaintEngine**)args[0]);
3094 }
3100 }
3095 }
3101 }
3096 }
3102 }
3097 if (result) { Py_DECREF(result); }
3103 if (result) { Py_DECREF(result); }
3098 Py_DECREF(obj);
3104 Py_DECREF(obj);
3099 return returnValue;
3105 return returnValue;
3100 }
3106 }
3101 }
3107 }
3102 return QHexSpinBox::paintEngine();
3108 return QHexSpinBox::paintEngine();
3103 }
3109 }
3104 void PythonQtShell_QHexSpinBox::paintEvent(QPaintEvent* event)
3110 void PythonQtShell_QHexSpinBox::paintEvent(QPaintEvent* event)
3105 {
3111 {
3106 if (_wrapper) {
3112 if (_wrapper) {
3107 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
3113 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
3108 PyErr_Clear();
3114 PyErr_Clear();
3109 if (obj && !PythonQtSlotFunction_Check(obj)) {
3115 if (obj && !PythonQtSlotFunction_Check(obj)) {
3110 static const char* argumentList[] ={"" , "QPaintEvent*"};
3116 static const char* argumentList[] ={"" , "QPaintEvent*"};
3111 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3117 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3112 void* args[2] = {NULL, (void*)&event};
3118 void* args[2] = {NULL, (void*)&event};
3113 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3119 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3114 if (result) { Py_DECREF(result); }
3120 if (result) { Py_DECREF(result); }
3115 Py_DECREF(obj);
3121 Py_DECREF(obj);
3116 return;
3122 return;
3117 }
3123 }
3118 }
3124 }
3119 QHexSpinBox::paintEvent(event);
3125 QHexSpinBox::paintEvent(event);
3120 }
3126 }
3121 QPaintDevice* PythonQtShell_QHexSpinBox::redirected(QPoint* offset) const
3127 QPaintDevice* PythonQtShell_QHexSpinBox::redirected(QPoint* offset) const
3122 {
3128 {
3123 if (_wrapper) {
3129 if (_wrapper) {
3124 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
3130 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
3125 PyErr_Clear();
3131 PyErr_Clear();
3126 if (obj && !PythonQtSlotFunction_Check(obj)) {
3132 if (obj && !PythonQtSlotFunction_Check(obj)) {
3127 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
3133 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
3128 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3134 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3129 QPaintDevice* returnValue;
3135 QPaintDevice* returnValue;
3130 void* args[2] = {NULL, (void*)&offset};
3136 void* args[2] = {NULL, (void*)&offset};
3131 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3137 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3132 if (result) {
3138 if (result) {
3133 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3139 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3134 if (args[0]!=&returnValue) {
3140 if (args[0]!=&returnValue) {
3135 if (args[0]==NULL) {
3141 if (args[0]==NULL) {
3136 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
3142 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
3137 } else {
3143 } else {
3138 returnValue = *((QPaintDevice**)args[0]);
3144 returnValue = *((QPaintDevice**)args[0]);
3139 }
3145 }
3140 }
3146 }
3141 }
3147 }
3142 if (result) { Py_DECREF(result); }
3148 if (result) { Py_DECREF(result); }
3143 Py_DECREF(obj);
3149 Py_DECREF(obj);
3144 return returnValue;
3150 return returnValue;
3145 }
3151 }
3146 }
3152 }
3147 return QHexSpinBox::redirected(offset);
3153 return QHexSpinBox::redirected(offset);
3148 }
3154 }
3149 void PythonQtShell_QHexSpinBox::resizeEvent(QResizeEvent* event)
3155 void PythonQtShell_QHexSpinBox::resizeEvent(QResizeEvent* event)
3150 {
3156 {
3151 if (_wrapper) {
3157 if (_wrapper) {
3152 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
3158 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
3153 PyErr_Clear();
3159 PyErr_Clear();
3154 if (obj && !PythonQtSlotFunction_Check(obj)) {
3160 if (obj && !PythonQtSlotFunction_Check(obj)) {
3155 static const char* argumentList[] ={"" , "QResizeEvent*"};
3161 static const char* argumentList[] ={"" , "QResizeEvent*"};
3156 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3162 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3157 void* args[2] = {NULL, (void*)&event};
3163 void* args[2] = {NULL, (void*)&event};
3158 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3164 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3159 if (result) { Py_DECREF(result); }
3165 if (result) { Py_DECREF(result); }
3160 Py_DECREF(obj);
3166 Py_DECREF(obj);
3161 return;
3167 return;
3162 }
3168 }
3163 }
3169 }
3164 QHexSpinBox::resizeEvent(event);
3170 QHexSpinBox::resizeEvent(event);
3165 }
3171 }
3166 QPainter* PythonQtShell_QHexSpinBox::sharedPainter() const
3172 QPainter* PythonQtShell_QHexSpinBox::sharedPainter() const
3167 {
3173 {
3168 if (_wrapper) {
3174 if (_wrapper) {
3169 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
3175 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
3170 PyErr_Clear();
3176 PyErr_Clear();
3171 if (obj && !PythonQtSlotFunction_Check(obj)) {
3177 if (obj && !PythonQtSlotFunction_Check(obj)) {
3172 static const char* argumentList[] ={"QPainter*"};
3178 static const char* argumentList[] ={"QPainter*"};
3173 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3179 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3174 QPainter* returnValue;
3180 QPainter* returnValue;
3175 void* args[1] = {NULL};
3181 void* args[1] = {NULL};
3176 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3182 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3177 if (result) {
3183 if (result) {
3178 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3184 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3179 if (args[0]!=&returnValue) {
3185 if (args[0]!=&returnValue) {
3180 if (args[0]==NULL) {
3186 if (args[0]==NULL) {
3181 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
3187 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
3182 } else {
3188 } else {
3183 returnValue = *((QPainter**)args[0]);
3189 returnValue = *((QPainter**)args[0]);
3184 }
3190 }
3185 }
3191 }
3186 }
3192 }
3187 if (result) { Py_DECREF(result); }
3193 if (result) { Py_DECREF(result); }
3188 Py_DECREF(obj);
3194 Py_DECREF(obj);
3189 return returnValue;
3195 return returnValue;
3190 }
3196 }
3191 }
3197 }
3192 return QHexSpinBox::sharedPainter();
3198 return QHexSpinBox::sharedPainter();
3193 }
3199 }
3194 void PythonQtShell_QHexSpinBox::showEvent(QShowEvent* event)
3200 void PythonQtShell_QHexSpinBox::showEvent(QShowEvent* event)
3195 {
3201 {
3196 if (_wrapper) {
3202 if (_wrapper) {
3197 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
3203 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
3198 PyErr_Clear();
3204 PyErr_Clear();
3199 if (obj && !PythonQtSlotFunction_Check(obj)) {
3205 if (obj && !PythonQtSlotFunction_Check(obj)) {
3200 static const char* argumentList[] ={"" , "QShowEvent*"};
3206 static const char* argumentList[] ={"" , "QShowEvent*"};
3201 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3207 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3202 void* args[2] = {NULL, (void*)&event};
3208 void* args[2] = {NULL, (void*)&event};
3203 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3209 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3204 if (result) { Py_DECREF(result); }
3210 if (result) { Py_DECREF(result); }
3205 Py_DECREF(obj);
3211 Py_DECREF(obj);
3206 return;
3212 return;
3207 }
3213 }
3208 }
3214 }
3209 QHexSpinBox::showEvent(event);
3215 QHexSpinBox::showEvent(event);
3210 }
3216 }
3211 void PythonQtShell_QHexSpinBox::stepBy(int steps)
3217 void PythonQtShell_QHexSpinBox::stepBy(int steps)
3212 {
3218 {
3213 if (_wrapper) {
3219 if (_wrapper) {
3214 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepBy");
3220 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepBy");
3215 PyErr_Clear();
3221 PyErr_Clear();
3216 if (obj && !PythonQtSlotFunction_Check(obj)) {
3222 if (obj && !PythonQtSlotFunction_Check(obj)) {
3217 static const char* argumentList[] ={"" , "int"};
3223 static const char* argumentList[] ={"" , "int"};
3218 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3224 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3219 void* args[2] = {NULL, (void*)&steps};
3225 void* args[2] = {NULL, (void*)&steps};
3220 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3226 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3221 if (result) { Py_DECREF(result); }
3227 if (result) { Py_DECREF(result); }
3222 Py_DECREF(obj);
3228 Py_DECREF(obj);
3223 return;
3229 return;
3224 }
3230 }
3225 }
3231 }
3226 QHexSpinBox::stepBy(steps);
3232 QHexSpinBox::stepBy(steps);
3227 }
3233 }
3228 QAbstractSpinBox::StepEnabled PythonQtShell_QHexSpinBox::stepEnabled() const
3234 QAbstractSpinBox::StepEnabled PythonQtShell_QHexSpinBox::stepEnabled() const
3229 {
3235 {
3230 if (_wrapper) {
3236 if (_wrapper) {
3231 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepEnabled");
3237 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepEnabled");
3232 PyErr_Clear();
3238 PyErr_Clear();
3233 if (obj && !PythonQtSlotFunction_Check(obj)) {
3239 if (obj && !PythonQtSlotFunction_Check(obj)) {
3234 static const char* argumentList[] ={"QAbstractSpinBox::StepEnabled"};
3240 static const char* argumentList[] ={"QAbstractSpinBox::StepEnabled"};
3235 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3241 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3236 QAbstractSpinBox::StepEnabled returnValue;
3242 QAbstractSpinBox::StepEnabled returnValue;
3237 void* args[1] = {NULL};
3243 void* args[1] = {NULL};
3238 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3244 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3239 if (result) {
3245 if (result) {
3240 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3246 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3241 if (args[0]!=&returnValue) {
3247 if (args[0]!=&returnValue) {
3242 if (args[0]==NULL) {
3248 if (args[0]==NULL) {
3243 PythonQt::priv()->handleVirtualOverloadReturnError("stepEnabled", methodInfo, result);
3249 PythonQt::priv()->handleVirtualOverloadReturnError("stepEnabled", methodInfo, result);
3244 } else {
3250 } else {
3245 returnValue = *((QAbstractSpinBox::StepEnabled*)args[0]);
3251 returnValue = *((QAbstractSpinBox::StepEnabled*)args[0]);
3246 }
3252 }
3247 }
3253 }
3248 }
3254 }
3249 if (result) { Py_DECREF(result); }
3255 if (result) { Py_DECREF(result); }
3250 Py_DECREF(obj);
3256 Py_DECREF(obj);
3251 return returnValue;
3257 return returnValue;
3252 }
3258 }
3253 }
3259 }
3254 return QHexSpinBox::stepEnabled();
3260 return QHexSpinBox::stepEnabled();
3255 }
3261 }
3256 void PythonQtShell_QHexSpinBox::tabletEvent(QTabletEvent* arg__1)
3262 void PythonQtShell_QHexSpinBox::tabletEvent(QTabletEvent* arg__1)
3257 {
3263 {
3258 if (_wrapper) {
3264 if (_wrapper) {
3259 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
3265 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
3260 PyErr_Clear();
3266 PyErr_Clear();
3261 if (obj && !PythonQtSlotFunction_Check(obj)) {
3267 if (obj && !PythonQtSlotFunction_Check(obj)) {
3262 static const char* argumentList[] ={"" , "QTabletEvent*"};
3268 static const char* argumentList[] ={"" , "QTabletEvent*"};
3263 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3269 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3264 void* args[2] = {NULL, (void*)&arg__1};
3270 void* args[2] = {NULL, (void*)&arg__1};
3265 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3271 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3266 if (result) { Py_DECREF(result); }
3272 if (result) { Py_DECREF(result); }
3267 Py_DECREF(obj);
3273 Py_DECREF(obj);
3268 return;
3274 return;
3269 }
3275 }
3270 }
3276 }
3271 QHexSpinBox::tabletEvent(arg__1);
3277 QHexSpinBox::tabletEvent(arg__1);
3272 }
3278 }
3273 QString PythonQtShell_QHexSpinBox::textFromValue(int value) const
3279 QString PythonQtShell_QHexSpinBox::textFromValue(int value) const
3274 {
3280 {
3275 if (_wrapper) {
3281 if (_wrapper) {
3276 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "textFromValue");
3282 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "textFromValue");
3277 PyErr_Clear();
3283 PyErr_Clear();
3278 if (obj && !PythonQtSlotFunction_Check(obj)) {
3284 if (obj && !PythonQtSlotFunction_Check(obj)) {
3279 static const char* argumentList[] ={"QString" , "int"};
3285 static const char* argumentList[] ={"QString" , "int"};
3280 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3286 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3281 QString returnValue;
3287 QString returnValue;
3282 void* args[2] = {NULL, (void*)&value};
3288 void* args[2] = {NULL, (void*)&value};
3283 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3289 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3284 if (result) {
3290 if (result) {
3285 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3291 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3286 if (args[0]!=&returnValue) {
3292 if (args[0]!=&returnValue) {
3287 if (args[0]==NULL) {
3293 if (args[0]==NULL) {
3288 PythonQt::priv()->handleVirtualOverloadReturnError("textFromValue", methodInfo, result);
3294 PythonQt::priv()->handleVirtualOverloadReturnError("textFromValue", methodInfo, result);
3289 } else {
3295 } else {
3290 returnValue = *((QString*)args[0]);
3296 returnValue = *((QString*)args[0]);
3291 }
3297 }
3292 }
3298 }
3293 }
3299 }
3294 if (result) { Py_DECREF(result); }
3300 if (result) { Py_DECREF(result); }
3295 Py_DECREF(obj);
3301 Py_DECREF(obj);
3296 return returnValue;
3302 return returnValue;
3297 }
3303 }
3298 }
3304 }
3299 return QHexSpinBox::textFromValue(value);
3305 return QHexSpinBox::textFromValue(value);
3300 }
3306 }
3301 void PythonQtShell_QHexSpinBox::timerEvent(QTimerEvent* event)
3307 void PythonQtShell_QHexSpinBox::timerEvent(QTimerEvent* event)
3302 {
3308 {
3303 if (_wrapper) {
3309 if (_wrapper) {
3304 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
3310 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
3305 PyErr_Clear();
3311 PyErr_Clear();
3306 if (obj && !PythonQtSlotFunction_Check(obj)) {
3312 if (obj && !PythonQtSlotFunction_Check(obj)) {
3307 static const char* argumentList[] ={"" , "QTimerEvent*"};
3313 static const char* argumentList[] ={"" , "QTimerEvent*"};
3308 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3314 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3309 void* args[2] = {NULL, (void*)&event};
3315 void* args[2] = {NULL, (void*)&event};
3310 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3316 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3311 if (result) { Py_DECREF(result); }
3317 if (result) { Py_DECREF(result); }
3312 Py_DECREF(obj);
3318 Py_DECREF(obj);
3313 return;
3319 return;
3314 }
3320 }
3315 }
3321 }
3316 QHexSpinBox::timerEvent(event);
3322 QHexSpinBox::timerEvent(event);
3317 }
3323 }
3318 QValidator::State PythonQtShell_QHexSpinBox::validate(QString& input, int& pos) const
3324 QValidator::State PythonQtShell_QHexSpinBox::validate(QString& input, int& pos) const
3319 {
3325 {
3320 if (_wrapper) {
3326 if (_wrapper) {
3321 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "validate");
3327 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "validate");
3322 PyErr_Clear();
3328 PyErr_Clear();
3323 if (obj && !PythonQtSlotFunction_Check(obj)) {
3329 if (obj && !PythonQtSlotFunction_Check(obj)) {
3324 static const char* argumentList[] ={"QValidator::State" , "QString&" , "int&"};
3330 static const char* argumentList[] ={"QValidator::State" , "QString&" , "int&"};
3325 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3331 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3326 QValidator::State returnValue;
3332 QValidator::State returnValue;
3327 void* args[3] = {NULL, (void*)&input, (void*)&pos};
3333 void* args[3] = {NULL, (void*)&input, (void*)&pos};
3328 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3334 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3329 if (result) {
3335 if (result) {
3330 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3336 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3331 if (args[0]!=&returnValue) {
3337 if (args[0]!=&returnValue) {
3332 if (args[0]==NULL) {
3338 if (args[0]==NULL) {
3333 PythonQt::priv()->handleVirtualOverloadReturnError("validate", methodInfo, result);
3339 PythonQt::priv()->handleVirtualOverloadReturnError("validate", methodInfo, result);
3334 } else {
3340 } else {
3335 returnValue = *((QValidator::State*)args[0]);
3341 returnValue = *((QValidator::State*)args[0]);
3336 }
3342 }
3337 }
3343 }
3338 }
3344 }
3339 if (result) { Py_DECREF(result); }
3345 if (result) { Py_DECREF(result); }
3340 Py_DECREF(obj);
3346 Py_DECREF(obj);
3341 return returnValue;
3347 return returnValue;
3342 }
3348 }
3343 }
3349 }
3344 return QHexSpinBox::validate(input, pos);
3350 return QHexSpinBox::validate(input, pos);
3345 }
3351 }
3346 int PythonQtShell_QHexSpinBox::valueFromText(const QString& text) const
3352 int PythonQtShell_QHexSpinBox::valueFromText(const QString& text) const
3347 {
3353 {
3348 if (_wrapper) {
3354 if (_wrapper) {
3349 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "valueFromText");
3355 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "valueFromText");
3350 PyErr_Clear();
3356 PyErr_Clear();
3351 if (obj && !PythonQtSlotFunction_Check(obj)) {
3357 if (obj && !PythonQtSlotFunction_Check(obj)) {
3352 static const char* argumentList[] ={"int" , "const QString&"};
3358 static const char* argumentList[] ={"int" , "const QString&"};
3353 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3359 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3354 int returnValue;
3360 int returnValue;
3355 void* args[2] = {NULL, (void*)&text};
3361 void* args[2] = {NULL, (void*)&text};
3356 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3362 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3357 if (result) {
3363 if (result) {
3358 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3364 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3359 if (args[0]!=&returnValue) {
3365 if (args[0]!=&returnValue) {
3360 if (args[0]==NULL) {
3366 if (args[0]==NULL) {
3361 PythonQt::priv()->handleVirtualOverloadReturnError("valueFromText", methodInfo, result);
3367 PythonQt::priv()->handleVirtualOverloadReturnError("valueFromText", methodInfo, result);
3362 } else {
3368 } else {
3363 returnValue = *((int*)args[0]);
3369 returnValue = *((int*)args[0]);
3364 }
3370 }
3365 }
3371 }
3366 }
3372 }
3367 if (result) { Py_DECREF(result); }
3373 if (result) { Py_DECREF(result); }
3368 Py_DECREF(obj);
3374 Py_DECREF(obj);
3369 return returnValue;
3375 return returnValue;
3370 }
3376 }
3371 }
3377 }
3372 return QHexSpinBox::valueFromText(text);
3378 return QHexSpinBox::valueFromText(text);
3373 }
3379 }
3374 void PythonQtShell_QHexSpinBox::wheelEvent(QWheelEvent* event)
3380 void PythonQtShell_QHexSpinBox::wheelEvent(QWheelEvent* event)
3375 {
3381 {
3376 if (_wrapper) {
3382 if (_wrapper) {
3377 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
3383 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
3378 PyErr_Clear();
3384 PyErr_Clear();
3379 if (obj && !PythonQtSlotFunction_Check(obj)) {
3385 if (obj && !PythonQtSlotFunction_Check(obj)) {
3380 static const char* argumentList[] ={"" , "QWheelEvent*"};
3386 static const char* argumentList[] ={"" , "QWheelEvent*"};
3381 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3387 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3382 void* args[2] = {NULL, (void*)&event};
3388 void* args[2] = {NULL, (void*)&event};
3383 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3389 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3384 if (result) { Py_DECREF(result); }
3390 if (result) { Py_DECREF(result); }
3385 Py_DECREF(obj);
3391 Py_DECREF(obj);
3386 return;
3392 return;
3387 }
3393 }
3388 }
3394 }
3389 QHexSpinBox::wheelEvent(event);
3395 QHexSpinBox::wheelEvent(event);
3390 }
3396 }
3391 QHexSpinBox* PythonQtWrapper_QHexSpinBox::new_QHexSpinBox(QWidget* parent)
3397 QHexSpinBox* PythonQtWrapper_QHexSpinBox::new_QHexSpinBox(QWidget* parent)
3392 {
3398 {
3393 return new PythonQtShell_QHexSpinBox(parent); }
3399 return new PythonQtShell_QHexSpinBox(parent); }
3394
3400
3395 void PythonQtWrapper_QHexSpinBox::show(QHexSpinBox* theWrappedObject)
3401 void PythonQtWrapper_QHexSpinBox::show(QHexSpinBox* theWrappedObject)
3396 {
3402 {
3397 ( theWrappedObject->show());
3403 ( theWrappedObject->show());
3398 }
3404 }
3399
3405
3400 QString PythonQtWrapper_QHexSpinBox::textFromValue(QHexSpinBox* theWrappedObject, int value) const
3406 QString PythonQtWrapper_QHexSpinBox::textFromValue(QHexSpinBox* theWrappedObject, int value) const
3401 {
3407 {
3402 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_textFromValue(value));
3408 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_textFromValue(value));
3403 }
3409 }
3404
3410
3405 QValidator::State PythonQtWrapper_QHexSpinBox::validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const
3411 QValidator::State PythonQtWrapper_QHexSpinBox::validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const
3406 {
3412 {
3407 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_validate(input, pos));
3413 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_validate(input, pos));
3408 }
3414 }
3409
3415
3410 int PythonQtWrapper_QHexSpinBox::valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const
3416 int PythonQtWrapper_QHexSpinBox::valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const
3411 {
3417 {
3412 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_valueFromText(text));
3418 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_valueFromText(text));
3413 }
3419 }
3414
3420
3415
3421
3416
3422
3417 PythonQtShell_SocExplorerPlot::~PythonQtShell_SocExplorerPlot() {
3423 PythonQtShell_SocExplorerPlot::~PythonQtShell_SocExplorerPlot() {
3418 PythonQtPrivate* priv = PythonQt::priv();
3424 PythonQtPrivate* priv = PythonQt::priv();
3419 if (priv) { priv->shellClassDeleted(this); }
3425 if (priv) { priv->shellClassDeleted(this); }
3420 }
3426 }
3421 void PythonQtShell_SocExplorerPlot::actionEvent(QActionEvent* arg__1)
3427 void PythonQtShell_SocExplorerPlot::actionEvent(QActionEvent* arg__1)
3422 {
3428 {
3423 if (_wrapper) {
3429 if (_wrapper) {
3424 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
3430 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
3425 PyErr_Clear();
3431 PyErr_Clear();
3426 if (obj && !PythonQtSlotFunction_Check(obj)) {
3432 if (obj && !PythonQtSlotFunction_Check(obj)) {
3427 static const char* argumentList[] ={"" , "QActionEvent*"};
3433 static const char* argumentList[] ={"" , "QActionEvent*"};
3428 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3434 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3429 void* args[2] = {NULL, (void*)&arg__1};
3435 void* args[2] = {NULL, (void*)&arg__1};
3430 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3436 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3431 if (result) { Py_DECREF(result); }
3437 if (result) { Py_DECREF(result); }
3432 Py_DECREF(obj);
3438 Py_DECREF(obj);
3433 return;
3439 return;
3434 }
3440 }
3435 }
3441 }
3436 SocExplorerPlot::actionEvent(arg__1);
3442 SocExplorerPlot::actionEvent(arg__1);
3437 }
3443 }
3438 void PythonQtShell_SocExplorerPlot::changeEvent(QEvent* arg__1)
3444 void PythonQtShell_SocExplorerPlot::changeEvent(QEvent* arg__1)
3439 {
3445 {
3440 if (_wrapper) {
3446 if (_wrapper) {
3441 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
3447 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
3442 PyErr_Clear();
3448 PyErr_Clear();
3443 if (obj && !PythonQtSlotFunction_Check(obj)) {
3449 if (obj && !PythonQtSlotFunction_Check(obj)) {
3444 static const char* argumentList[] ={"" , "QEvent*"};
3450 static const char* argumentList[] ={"" , "QEvent*"};
3445 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3451 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3446 void* args[2] = {NULL, (void*)&arg__1};
3452 void* args[2] = {NULL, (void*)&arg__1};
3447 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3453 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3448 if (result) { Py_DECREF(result); }
3454 if (result) { Py_DECREF(result); }
3449 Py_DECREF(obj);
3455 Py_DECREF(obj);
3450 return;
3456 return;
3451 }
3457 }
3452 }
3458 }
3453 SocExplorerPlot::changeEvent(arg__1);
3459 SocExplorerPlot::changeEvent(arg__1);
3454 }
3460 }
3455 void PythonQtShell_SocExplorerPlot::childEvent(QChildEvent* arg__1)
3461 void PythonQtShell_SocExplorerPlot::childEvent(QChildEvent* arg__1)
3456 {
3462 {
3457 if (_wrapper) {
3463 if (_wrapper) {
3458 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
3464 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
3459 PyErr_Clear();
3465 PyErr_Clear();
3460 if (obj && !PythonQtSlotFunction_Check(obj)) {
3466 if (obj && !PythonQtSlotFunction_Check(obj)) {
3461 static const char* argumentList[] ={"" , "QChildEvent*"};
3467 static const char* argumentList[] ={"" , "QChildEvent*"};
3462 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3468 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3463 void* args[2] = {NULL, (void*)&arg__1};
3469 void* args[2] = {NULL, (void*)&arg__1};
3464 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3470 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3465 if (result) { Py_DECREF(result); }
3471 if (result) { Py_DECREF(result); }
3466 Py_DECREF(obj);
3472 Py_DECREF(obj);
3467 return;
3473 return;
3468 }
3474 }
3469 }
3475 }
3470 SocExplorerPlot::childEvent(arg__1);
3476 SocExplorerPlot::childEvent(arg__1);
3471 }
3477 }
3472 void PythonQtShell_SocExplorerPlot::closeEvent(QCloseEvent* arg__1)
3478 void PythonQtShell_SocExplorerPlot::closeEvent(QCloseEvent* arg__1)
3473 {
3479 {
3474 if (_wrapper) {
3480 if (_wrapper) {
3475 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
3481 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
3476 PyErr_Clear();
3482 PyErr_Clear();
3477 if (obj && !PythonQtSlotFunction_Check(obj)) {
3483 if (obj && !PythonQtSlotFunction_Check(obj)) {
3478 static const char* argumentList[] ={"" , "QCloseEvent*"};
3484 static const char* argumentList[] ={"" , "QCloseEvent*"};
3479 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3485 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3480 void* args[2] = {NULL, (void*)&arg__1};
3486 void* args[2] = {NULL, (void*)&arg__1};
3481 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3487 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3482 if (result) { Py_DECREF(result); }
3488 if (result) { Py_DECREF(result); }
3483 Py_DECREF(obj);
3489 Py_DECREF(obj);
3484 return;
3490 return;
3485 }
3491 }
3486 }
3492 }
3487 SocExplorerPlot::closeEvent(arg__1);
3493 SocExplorerPlot::closeEvent(arg__1);
3488 }
3494 }
3489 void PythonQtShell_SocExplorerPlot::contextMenuEvent(QContextMenuEvent* arg__1)
3495 void PythonQtShell_SocExplorerPlot::contextMenuEvent(QContextMenuEvent* arg__1)
3490 {
3496 {
3491 if (_wrapper) {
3497 if (_wrapper) {
3492 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
3498 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
3493 PyErr_Clear();
3499 PyErr_Clear();
3494 if (obj && !PythonQtSlotFunction_Check(obj)) {
3500 if (obj && !PythonQtSlotFunction_Check(obj)) {
3495 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
3501 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
3496 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3502 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3497 void* args[2] = {NULL, (void*)&arg__1};
3503 void* args[2] = {NULL, (void*)&arg__1};
3498 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3504 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3499 if (result) { Py_DECREF(result); }
3505 if (result) { Py_DECREF(result); }
3500 Py_DECREF(obj);
3506 Py_DECREF(obj);
3501 return;
3507 return;
3502 }
3508 }
3503 }
3509 }
3504 SocExplorerPlot::contextMenuEvent(arg__1);
3510 SocExplorerPlot::contextMenuEvent(arg__1);
3505 }
3511 }
3506 void PythonQtShell_SocExplorerPlot::customEvent(QEvent* arg__1)
3512 void PythonQtShell_SocExplorerPlot::customEvent(QEvent* arg__1)
3507 {
3513 {
3508 if (_wrapper) {
3514 if (_wrapper) {
3509 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
3515 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
3510 PyErr_Clear();
3516 PyErr_Clear();
3511 if (obj && !PythonQtSlotFunction_Check(obj)) {
3517 if (obj && !PythonQtSlotFunction_Check(obj)) {
3512 static const char* argumentList[] ={"" , "QEvent*"};
3518 static const char* argumentList[] ={"" , "QEvent*"};
3513 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3519 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3514 void* args[2] = {NULL, (void*)&arg__1};
3520 void* args[2] = {NULL, (void*)&arg__1};
3515 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3521 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3516 if (result) { Py_DECREF(result); }
3522 if (result) { Py_DECREF(result); }
3517 Py_DECREF(obj);
3523 Py_DECREF(obj);
3518 return;
3524 return;
3519 }
3525 }
3520 }
3526 }
3521 SocExplorerPlot::customEvent(arg__1);
3527 SocExplorerPlot::customEvent(arg__1);
3522 }
3528 }
3523 int PythonQtShell_SocExplorerPlot::devType() const
3529 int PythonQtShell_SocExplorerPlot::devType() const
3524 {
3530 {
3525 if (_wrapper) {
3531 if (_wrapper) {
3526 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
3532 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
3527 PyErr_Clear();
3533 PyErr_Clear();
3528 if (obj && !PythonQtSlotFunction_Check(obj)) {
3534 if (obj && !PythonQtSlotFunction_Check(obj)) {
3529 static const char* argumentList[] ={"int"};
3535 static const char* argumentList[] ={"int"};
3530 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3536 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3531 int returnValue;
3537 int returnValue;
3532 void* args[1] = {NULL};
3538 void* args[1] = {NULL};
3533 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3539 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3534 if (result) {
3540 if (result) {
3535 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3541 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3536 if (args[0]!=&returnValue) {
3542 if (args[0]!=&returnValue) {
3537 if (args[0]==NULL) {
3543 if (args[0]==NULL) {
3538 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
3544 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
3539 } else {
3545 } else {
3540 returnValue = *((int*)args[0]);
3546 returnValue = *((int*)args[0]);
3541 }
3547 }
3542 }
3548 }
3543 }
3549 }
3544 if (result) { Py_DECREF(result); }
3550 if (result) { Py_DECREF(result); }
3545 Py_DECREF(obj);
3551 Py_DECREF(obj);
3546 return returnValue;
3552 return returnValue;
3547 }
3553 }
3548 }
3554 }
3549 return SocExplorerPlot::devType();
3555 return SocExplorerPlot::devType();
3550 }
3556 }
3551 void PythonQtShell_SocExplorerPlot::dragEnterEvent(QDragEnterEvent* arg__1)
3557 void PythonQtShell_SocExplorerPlot::dragEnterEvent(QDragEnterEvent* arg__1)
3552 {
3558 {
3553 if (_wrapper) {
3559 if (_wrapper) {
3554 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
3560 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
3555 PyErr_Clear();
3561 PyErr_Clear();
3556 if (obj && !PythonQtSlotFunction_Check(obj)) {
3562 if (obj && !PythonQtSlotFunction_Check(obj)) {
3557 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
3563 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
3558 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3564 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3559 void* args[2] = {NULL, (void*)&arg__1};
3565 void* args[2] = {NULL, (void*)&arg__1};
3560 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3566 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3561 if (result) { Py_DECREF(result); }
3567 if (result) { Py_DECREF(result); }
3562 Py_DECREF(obj);
3568 Py_DECREF(obj);
3563 return;
3569 return;
3564 }
3570 }
3565 }
3571 }
3566 SocExplorerPlot::dragEnterEvent(arg__1);
3572 SocExplorerPlot::dragEnterEvent(arg__1);
3567 }
3573 }
3568 void PythonQtShell_SocExplorerPlot::dragLeaveEvent(QDragLeaveEvent* arg__1)
3574 void PythonQtShell_SocExplorerPlot::dragLeaveEvent(QDragLeaveEvent* arg__1)
3569 {
3575 {
3570 if (_wrapper) {
3576 if (_wrapper) {
3571 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
3577 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
3572 PyErr_Clear();
3578 PyErr_Clear();
3573 if (obj && !PythonQtSlotFunction_Check(obj)) {
3579 if (obj && !PythonQtSlotFunction_Check(obj)) {
3574 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
3580 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
3575 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3581 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3576 void* args[2] = {NULL, (void*)&arg__1};
3582 void* args[2] = {NULL, (void*)&arg__1};
3577 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3583 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3578 if (result) { Py_DECREF(result); }
3584 if (result) { Py_DECREF(result); }
3579 Py_DECREF(obj);
3585 Py_DECREF(obj);
3580 return;
3586 return;
3581 }
3587 }
3582 }
3588 }
3583 SocExplorerPlot::dragLeaveEvent(arg__1);
3589 SocExplorerPlot::dragLeaveEvent(arg__1);
3584 }
3590 }
3585 void PythonQtShell_SocExplorerPlot::dragMoveEvent(QDragMoveEvent* arg__1)
3591 void PythonQtShell_SocExplorerPlot::dragMoveEvent(QDragMoveEvent* arg__1)
3586 {
3592 {
3587 if (_wrapper) {
3593 if (_wrapper) {
3588 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
3594 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
3589 PyErr_Clear();
3595 PyErr_Clear();
3590 if (obj && !PythonQtSlotFunction_Check(obj)) {
3596 if (obj && !PythonQtSlotFunction_Check(obj)) {
3591 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
3597 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
3592 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3598 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3593 void* args[2] = {NULL, (void*)&arg__1};
3599 void* args[2] = {NULL, (void*)&arg__1};
3594 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3600 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3595 if (result) { Py_DECREF(result); }
3601 if (result) { Py_DECREF(result); }
3596 Py_DECREF(obj);
3602 Py_DECREF(obj);
3597 return;
3603 return;
3598 }
3604 }
3599 }
3605 }
3600 SocExplorerPlot::dragMoveEvent(arg__1);
3606 SocExplorerPlot::dragMoveEvent(arg__1);
3601 }
3607 }
3602 void PythonQtShell_SocExplorerPlot::dropEvent(QDropEvent* arg__1)
3608 void PythonQtShell_SocExplorerPlot::dropEvent(QDropEvent* arg__1)
3603 {
3609 {
3604 if (_wrapper) {
3610 if (_wrapper) {
3605 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
3611 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
3606 PyErr_Clear();
3612 PyErr_Clear();
3607 if (obj && !PythonQtSlotFunction_Check(obj)) {
3613 if (obj && !PythonQtSlotFunction_Check(obj)) {
3608 static const char* argumentList[] ={"" , "QDropEvent*"};
3614 static const char* argumentList[] ={"" , "QDropEvent*"};
3609 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3615 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3610 void* args[2] = {NULL, (void*)&arg__1};
3616 void* args[2] = {NULL, (void*)&arg__1};
3611 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3617 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3612 if (result) { Py_DECREF(result); }
3618 if (result) { Py_DECREF(result); }
3613 Py_DECREF(obj);
3619 Py_DECREF(obj);
3614 return;
3620 return;
3615 }
3621 }
3616 }
3622 }
3617 SocExplorerPlot::dropEvent(arg__1);
3623 SocExplorerPlot::dropEvent(arg__1);
3618 }
3624 }
3619 void PythonQtShell_SocExplorerPlot::enterEvent(QEvent* arg__1)
3625 void PythonQtShell_SocExplorerPlot::enterEvent(QEvent* arg__1)
3620 {
3626 {
3621 if (_wrapper) {
3627 if (_wrapper) {
3622 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
3628 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
3623 PyErr_Clear();
3629 PyErr_Clear();
3624 if (obj && !PythonQtSlotFunction_Check(obj)) {
3630 if (obj && !PythonQtSlotFunction_Check(obj)) {
3625 static const char* argumentList[] ={"" , "QEvent*"};
3631 static const char* argumentList[] ={"" , "QEvent*"};
3626 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3632 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3627 void* args[2] = {NULL, (void*)&arg__1};
3633 void* args[2] = {NULL, (void*)&arg__1};
3628 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3634 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3629 if (result) { Py_DECREF(result); }
3635 if (result) { Py_DECREF(result); }
3630 Py_DECREF(obj);
3636 Py_DECREF(obj);
3631 return;
3637 return;
3632 }
3638 }
3633 }
3639 }
3634 SocExplorerPlot::enterEvent(arg__1);
3640 SocExplorerPlot::enterEvent(arg__1);
3635 }
3641 }
3636 bool PythonQtShell_SocExplorerPlot::event(QEvent* arg__1)
3642 bool PythonQtShell_SocExplorerPlot::event(QEvent* arg__1)
3637 {
3643 {
3638 if (_wrapper) {
3644 if (_wrapper) {
3639 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
3645 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
3640 PyErr_Clear();
3646 PyErr_Clear();
3641 if (obj && !PythonQtSlotFunction_Check(obj)) {
3647 if (obj && !PythonQtSlotFunction_Check(obj)) {
3642 static const char* argumentList[] ={"bool" , "QEvent*"};
3648 static const char* argumentList[] ={"bool" , "QEvent*"};
3643 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3649 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3644 bool returnValue;
3650 bool returnValue;
3645 void* args[2] = {NULL, (void*)&arg__1};
3651 void* args[2] = {NULL, (void*)&arg__1};
3646 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3652 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3647 if (result) {
3653 if (result) {
3648 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3654 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3649 if (args[0]!=&returnValue) {
3655 if (args[0]!=&returnValue) {
3650 if (args[0]==NULL) {
3656 if (args[0]==NULL) {
3651 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
3657 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
3652 } else {
3658 } else {
3653 returnValue = *((bool*)args[0]);
3659 returnValue = *((bool*)args[0]);
3654 }
3660 }
3655 }
3661 }
3656 }
3662 }
3657 if (result) { Py_DECREF(result); }
3663 if (result) { Py_DECREF(result); }
3658 Py_DECREF(obj);
3664 Py_DECREF(obj);
3659 return returnValue;
3665 return returnValue;
3660 }
3666 }
3661 }
3667 }
3662 return SocExplorerPlot::event(arg__1);
3668 return SocExplorerPlot::event(arg__1);
3663 }
3669 }
3664 bool PythonQtShell_SocExplorerPlot::eventFilter(QObject* arg__1, QEvent* arg__2)
3670 bool PythonQtShell_SocExplorerPlot::eventFilter(QObject* arg__1, QEvent* arg__2)
3665 {
3671 {
3666 if (_wrapper) {
3672 if (_wrapper) {
3667 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
3673 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
3668 PyErr_Clear();
3674 PyErr_Clear();
3669 if (obj && !PythonQtSlotFunction_Check(obj)) {
3675 if (obj && !PythonQtSlotFunction_Check(obj)) {
3670 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
3676 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
3671 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3677 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3672 bool returnValue;
3678 bool returnValue;
3673 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
3679 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
3674 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3680 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3675 if (result) {
3681 if (result) {
3676 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3682 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3677 if (args[0]!=&returnValue) {
3683 if (args[0]!=&returnValue) {
3678 if (args[0]==NULL) {
3684 if (args[0]==NULL) {
3679 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
3685 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
3680 } else {
3686 } else {
3681 returnValue = *((bool*)args[0]);
3687 returnValue = *((bool*)args[0]);
3682 }
3688 }
3683 }
3689 }
3684 }
3690 }
3685 if (result) { Py_DECREF(result); }
3691 if (result) { Py_DECREF(result); }
3686 Py_DECREF(obj);
3692 Py_DECREF(obj);
3687 return returnValue;
3693 return returnValue;
3688 }
3694 }
3689 }
3695 }
3690 return SocExplorerPlot::eventFilter(arg__1, arg__2);
3696 return SocExplorerPlot::eventFilter(arg__1, arg__2);
3691 }
3697 }
3692 void PythonQtShell_SocExplorerPlot::focusInEvent(QFocusEvent* arg__1)
3698 void PythonQtShell_SocExplorerPlot::focusInEvent(QFocusEvent* arg__1)
3693 {
3699 {
3694 if (_wrapper) {
3700 if (_wrapper) {
3695 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
3701 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
3696 PyErr_Clear();
3702 PyErr_Clear();
3697 if (obj && !PythonQtSlotFunction_Check(obj)) {
3703 if (obj && !PythonQtSlotFunction_Check(obj)) {
3698 static const char* argumentList[] ={"" , "QFocusEvent*"};
3704 static const char* argumentList[] ={"" , "QFocusEvent*"};
3699 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3705 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3700 void* args[2] = {NULL, (void*)&arg__1};
3706 void* args[2] = {NULL, (void*)&arg__1};
3701 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3707 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3702 if (result) { Py_DECREF(result); }
3708 if (result) { Py_DECREF(result); }
3703 Py_DECREF(obj);
3709 Py_DECREF(obj);
3704 return;
3710 return;
3705 }
3711 }
3706 }
3712 }
3707 SocExplorerPlot::focusInEvent(arg__1);
3713 SocExplorerPlot::focusInEvent(arg__1);
3708 }
3714 }
3709 bool PythonQtShell_SocExplorerPlot::focusNextPrevChild(bool next)
3715 bool PythonQtShell_SocExplorerPlot::focusNextPrevChild(bool next)
3710 {
3716 {
3711 if (_wrapper) {
3717 if (_wrapper) {
3712 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
3718 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
3713 PyErr_Clear();
3719 PyErr_Clear();
3714 if (obj && !PythonQtSlotFunction_Check(obj)) {
3720 if (obj && !PythonQtSlotFunction_Check(obj)) {
3715 static const char* argumentList[] ={"bool" , "bool"};
3721 static const char* argumentList[] ={"bool" , "bool"};
3716 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3722 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3717 bool returnValue;
3723 bool returnValue;
3718 void* args[2] = {NULL, (void*)&next};
3724 void* args[2] = {NULL, (void*)&next};
3719 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3725 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3720 if (result) {
3726 if (result) {
3721 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3727 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3722 if (args[0]!=&returnValue) {
3728 if (args[0]!=&returnValue) {
3723 if (args[0]==NULL) {
3729 if (args[0]==NULL) {
3724 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
3730 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
3725 } else {
3731 } else {
3726 returnValue = *((bool*)args[0]);
3732 returnValue = *((bool*)args[0]);
3727 }
3733 }
3728 }
3734 }
3729 }
3735 }
3730 if (result) { Py_DECREF(result); }
3736 if (result) { Py_DECREF(result); }
3731 Py_DECREF(obj);
3737 Py_DECREF(obj);
3732 return returnValue;
3738 return returnValue;
3733 }
3739 }
3734 }
3740 }
3735 return SocExplorerPlot::focusNextPrevChild(next);
3741 return SocExplorerPlot::focusNextPrevChild(next);
3736 }
3742 }
3737 void PythonQtShell_SocExplorerPlot::focusOutEvent(QFocusEvent* arg__1)
3743 void PythonQtShell_SocExplorerPlot::focusOutEvent(QFocusEvent* arg__1)
3738 {
3744 {
3739 if (_wrapper) {
3745 if (_wrapper) {
3740 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
3746 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
3741 PyErr_Clear();
3747 PyErr_Clear();
3742 if (obj && !PythonQtSlotFunction_Check(obj)) {
3748 if (obj && !PythonQtSlotFunction_Check(obj)) {
3743 static const char* argumentList[] ={"" , "QFocusEvent*"};
3749 static const char* argumentList[] ={"" , "QFocusEvent*"};
3744 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3750 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3745 void* args[2] = {NULL, (void*)&arg__1};
3751 void* args[2] = {NULL, (void*)&arg__1};
3746 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3752 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3747 if (result) { Py_DECREF(result); }
3753 if (result) { Py_DECREF(result); }
3748 Py_DECREF(obj);
3754 Py_DECREF(obj);
3749 return;
3755 return;
3750 }
3756 }
3751 }
3757 }
3752 SocExplorerPlot::focusOutEvent(arg__1);
3758 SocExplorerPlot::focusOutEvent(arg__1);
3753 }
3759 }
3754 bool PythonQtShell_SocExplorerPlot::hasHeightForWidth() const
3760 bool PythonQtShell_SocExplorerPlot::hasHeightForWidth() const
3755 {
3761 {
3756 if (_wrapper) {
3762 if (_wrapper) {
3757 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
3763 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
3758 PyErr_Clear();
3764 PyErr_Clear();
3759 if (obj && !PythonQtSlotFunction_Check(obj)) {
3765 if (obj && !PythonQtSlotFunction_Check(obj)) {
3760 static const char* argumentList[] ={"bool"};
3766 static const char* argumentList[] ={"bool"};
3761 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3767 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3762 bool returnValue;
3768 bool returnValue;
3763 void* args[1] = {NULL};
3769 void* args[1] = {NULL};
3764 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3770 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3765 if (result) {
3771 if (result) {
3766 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3772 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3767 if (args[0]!=&returnValue) {
3773 if (args[0]!=&returnValue) {
3768 if (args[0]==NULL) {
3774 if (args[0]==NULL) {
3769 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
3775 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
3770 } else {
3776 } else {
3771 returnValue = *((bool*)args[0]);
3777 returnValue = *((bool*)args[0]);
3772 }
3778 }
3773 }
3779 }
3774 }
3780 }
3775 if (result) { Py_DECREF(result); }
3781 if (result) { Py_DECREF(result); }
3776 Py_DECREF(obj);
3782 Py_DECREF(obj);
3777 return returnValue;
3783 return returnValue;
3778 }
3784 }
3779 }
3785 }
3780 return SocExplorerPlot::hasHeightForWidth();
3786 return SocExplorerPlot::hasHeightForWidth();
3781 }
3787 }
3782 int PythonQtShell_SocExplorerPlot::heightForWidth(int arg__1) const
3788 int PythonQtShell_SocExplorerPlot::heightForWidth(int arg__1) const
3783 {
3789 {
3784 if (_wrapper) {
3790 if (_wrapper) {
3785 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
3791 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
3786 PyErr_Clear();
3792 PyErr_Clear();
3787 if (obj && !PythonQtSlotFunction_Check(obj)) {
3793 if (obj && !PythonQtSlotFunction_Check(obj)) {
3788 static const char* argumentList[] ={"int" , "int"};
3794 static const char* argumentList[] ={"int" , "int"};
3789 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3795 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3790 int returnValue;
3796 int returnValue;
3791 void* args[2] = {NULL, (void*)&arg__1};
3797 void* args[2] = {NULL, (void*)&arg__1};
3792 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3798 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3793 if (result) {
3799 if (result) {
3794 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3800 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3795 if (args[0]!=&returnValue) {
3801 if (args[0]!=&returnValue) {
3796 if (args[0]==NULL) {
3802 if (args[0]==NULL) {
3797 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
3803 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
3798 } else {
3804 } else {
3799 returnValue = *((int*)args[0]);
3805 returnValue = *((int*)args[0]);
3800 }
3806 }
3801 }
3807 }
3802 }
3808 }
3803 if (result) { Py_DECREF(result); }
3809 if (result) { Py_DECREF(result); }
3804 Py_DECREF(obj);
3810 Py_DECREF(obj);
3805 return returnValue;
3811 return returnValue;
3806 }
3812 }
3807 }
3813 }
3808 return SocExplorerPlot::heightForWidth(arg__1);
3814 return SocExplorerPlot::heightForWidth(arg__1);
3809 }
3815 }
3810 void PythonQtShell_SocExplorerPlot::hideEvent(QHideEvent* arg__1)
3816 void PythonQtShell_SocExplorerPlot::hideEvent(QHideEvent* arg__1)
3811 {
3817 {
3812 if (_wrapper) {
3818 if (_wrapper) {
3813 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
3819 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
3814 PyErr_Clear();
3820 PyErr_Clear();
3815 if (obj && !PythonQtSlotFunction_Check(obj)) {
3821 if (obj && !PythonQtSlotFunction_Check(obj)) {
3816 static const char* argumentList[] ={"" , "QHideEvent*"};
3822 static const char* argumentList[] ={"" , "QHideEvent*"};
3817 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3823 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3818 void* args[2] = {NULL, (void*)&arg__1};
3824 void* args[2] = {NULL, (void*)&arg__1};
3819 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3825 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3820 if (result) { Py_DECREF(result); }
3826 if (result) { Py_DECREF(result); }
3821 Py_DECREF(obj);
3827 Py_DECREF(obj);
3822 return;
3828 return;
3823 }
3829 }
3824 }
3830 }
3825 SocExplorerPlot::hideEvent(arg__1);
3831 SocExplorerPlot::hideEvent(arg__1);
3826 }
3832 }
3827 void PythonQtShell_SocExplorerPlot::initPainter(QPainter* painter) const
3833 void PythonQtShell_SocExplorerPlot::initPainter(QPainter* painter) const
3828 {
3834 {
3829 if (_wrapper) {
3835 if (_wrapper) {
3830 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
3836 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
3831 PyErr_Clear();
3837 PyErr_Clear();
3832 if (obj && !PythonQtSlotFunction_Check(obj)) {
3838 if (obj && !PythonQtSlotFunction_Check(obj)) {
3833 static const char* argumentList[] ={"" , "QPainter*"};
3839 static const char* argumentList[] ={"" , "QPainter*"};
3834 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3840 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3835 void* args[2] = {NULL, (void*)&painter};
3841 void* args[2] = {NULL, (void*)&painter};
3836 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3842 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3837 if (result) { Py_DECREF(result); }
3843 if (result) { Py_DECREF(result); }
3838 Py_DECREF(obj);
3844 Py_DECREF(obj);
3839 return;
3845 return;
3840 }
3846 }
3841 }
3847 }
3842 SocExplorerPlot::initPainter(painter);
3848 SocExplorerPlot::initPainter(painter);
3843 }
3849 }
3844 void PythonQtShell_SocExplorerPlot::inputMethodEvent(QInputMethodEvent* arg__1)
3850 void PythonQtShell_SocExplorerPlot::inputMethodEvent(QInputMethodEvent* arg__1)
3845 {
3851 {
3846 if (_wrapper) {
3852 if (_wrapper) {
3847 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
3853 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
3848 PyErr_Clear();
3854 PyErr_Clear();
3849 if (obj && !PythonQtSlotFunction_Check(obj)) {
3855 if (obj && !PythonQtSlotFunction_Check(obj)) {
3850 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
3856 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
3851 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3857 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3852 void* args[2] = {NULL, (void*)&arg__1};
3858 void* args[2] = {NULL, (void*)&arg__1};
3853 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3859 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3854 if (result) { Py_DECREF(result); }
3860 if (result) { Py_DECREF(result); }
3855 Py_DECREF(obj);
3861 Py_DECREF(obj);
3856 return;
3862 return;
3857 }
3863 }
3858 }
3864 }
3859 SocExplorerPlot::inputMethodEvent(arg__1);
3865 SocExplorerPlot::inputMethodEvent(arg__1);
3860 }
3866 }
3861 QVariant PythonQtShell_SocExplorerPlot::inputMethodQuery(Qt::InputMethodQuery arg__1) const
3867 QVariant PythonQtShell_SocExplorerPlot::inputMethodQuery(Qt::InputMethodQuery arg__1) const
3862 {
3868 {
3863 if (_wrapper) {
3869 if (_wrapper) {
3864 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
3870 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
3865 PyErr_Clear();
3871 PyErr_Clear();
3866 if (obj && !PythonQtSlotFunction_Check(obj)) {
3872 if (obj && !PythonQtSlotFunction_Check(obj)) {
3867 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
3873 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
3868 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3874 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3869 QVariant returnValue;
3875 QVariant returnValue;
3870 void* args[2] = {NULL, (void*)&arg__1};
3876 void* args[2] = {NULL, (void*)&arg__1};
3871 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3877 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3872 if (result) {
3878 if (result) {
3873 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3879 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3874 if (args[0]!=&returnValue) {
3880 if (args[0]!=&returnValue) {
3875 if (args[0]==NULL) {
3881 if (args[0]==NULL) {
3876 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
3882 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
3877 } else {
3883 } else {
3878 returnValue = *((QVariant*)args[0]);
3884 returnValue = *((QVariant*)args[0]);
3879 }
3885 }
3880 }
3886 }
3881 }
3887 }
3882 if (result) { Py_DECREF(result); }
3888 if (result) { Py_DECREF(result); }
3883 Py_DECREF(obj);
3889 Py_DECREF(obj);
3884 return returnValue;
3890 return returnValue;
3885 }
3891 }
3886 }
3892 }
3887 return SocExplorerPlot::inputMethodQuery(arg__1);
3893 return SocExplorerPlot::inputMethodQuery(arg__1);
3888 }
3894 }
3889 void PythonQtShell_SocExplorerPlot::keyPressEvent(QKeyEvent* arg__1)
3895 void PythonQtShell_SocExplorerPlot::keyPressEvent(QKeyEvent* arg__1)
3890 {
3896 {
3891 if (_wrapper) {
3897 if (_wrapper) {
3892 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
3898 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
3893 PyErr_Clear();
3899 PyErr_Clear();
3894 if (obj && !PythonQtSlotFunction_Check(obj)) {
3900 if (obj && !PythonQtSlotFunction_Check(obj)) {
3895 static const char* argumentList[] ={"" , "QKeyEvent*"};
3901 static const char* argumentList[] ={"" , "QKeyEvent*"};
3896 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3902 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3897 void* args[2] = {NULL, (void*)&arg__1};
3903 void* args[2] = {NULL, (void*)&arg__1};
3898 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3904 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3899 if (result) { Py_DECREF(result); }
3905 if (result) { Py_DECREF(result); }
3900 Py_DECREF(obj);
3906 Py_DECREF(obj);
3901 return;
3907 return;
3902 }
3908 }
3903 }
3909 }
3904 SocExplorerPlot::keyPressEvent(arg__1);
3910 SocExplorerPlot::keyPressEvent(arg__1);
3905 }
3911 }
3906 void PythonQtShell_SocExplorerPlot::keyReleaseEvent(QKeyEvent* arg__1)
3912 void PythonQtShell_SocExplorerPlot::keyReleaseEvent(QKeyEvent* arg__1)
3907 {
3913 {
3908 if (_wrapper) {
3914 if (_wrapper) {
3909 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
3915 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
3910 PyErr_Clear();
3916 PyErr_Clear();
3911 if (obj && !PythonQtSlotFunction_Check(obj)) {
3917 if (obj && !PythonQtSlotFunction_Check(obj)) {
3912 static const char* argumentList[] ={"" , "QKeyEvent*"};
3918 static const char* argumentList[] ={"" , "QKeyEvent*"};
3913 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3919 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3914 void* args[2] = {NULL, (void*)&arg__1};
3920 void* args[2] = {NULL, (void*)&arg__1};
3915 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3921 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3916 if (result) { Py_DECREF(result); }
3922 if (result) { Py_DECREF(result); }
3917 Py_DECREF(obj);
3923 Py_DECREF(obj);
3918 return;
3924 return;
3919 }
3925 }
3920 }
3926 }
3921 SocExplorerPlot::keyReleaseEvent(arg__1);
3927 SocExplorerPlot::keyReleaseEvent(arg__1);
3922 }
3928 }
3923 void PythonQtShell_SocExplorerPlot::leaveEvent(QEvent* arg__1)
3929 void PythonQtShell_SocExplorerPlot::leaveEvent(QEvent* arg__1)
3924 {
3930 {
3925 if (_wrapper) {
3931 if (_wrapper) {
3926 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
3932 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
3927 PyErr_Clear();
3933 PyErr_Clear();
3928 if (obj && !PythonQtSlotFunction_Check(obj)) {
3934 if (obj && !PythonQtSlotFunction_Check(obj)) {
3929 static const char* argumentList[] ={"" , "QEvent*"};
3935 static const char* argumentList[] ={"" , "QEvent*"};
3930 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3936 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3931 void* args[2] = {NULL, (void*)&arg__1};
3937 void* args[2] = {NULL, (void*)&arg__1};
3932 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3938 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3933 if (result) { Py_DECREF(result); }
3939 if (result) { Py_DECREF(result); }
3934 Py_DECREF(obj);
3940 Py_DECREF(obj);
3935 return;
3941 return;
3936 }
3942 }
3937 }
3943 }
3938 SocExplorerPlot::leaveEvent(arg__1);
3944 SocExplorerPlot::leaveEvent(arg__1);
3939 }
3945 }
3940 int PythonQtShell_SocExplorerPlot::metric(QPaintDevice::PaintDeviceMetric arg__1) const
3946 int PythonQtShell_SocExplorerPlot::metric(QPaintDevice::PaintDeviceMetric arg__1) const
3941 {
3947 {
3942 if (_wrapper) {
3948 if (_wrapper) {
3943 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
3949 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
3944 PyErr_Clear();
3950 PyErr_Clear();
3945 if (obj && !PythonQtSlotFunction_Check(obj)) {
3951 if (obj && !PythonQtSlotFunction_Check(obj)) {
3946 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
3952 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
3947 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3953 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3948 int returnValue;
3954 int returnValue;
3949 void* args[2] = {NULL, (void*)&arg__1};
3955 void* args[2] = {NULL, (void*)&arg__1};
3950 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3956 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3951 if (result) {
3957 if (result) {
3952 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3958 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3953 if (args[0]!=&returnValue) {
3959 if (args[0]!=&returnValue) {
3954 if (args[0]==NULL) {
3960 if (args[0]==NULL) {
3955 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
3961 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
3956 } else {
3962 } else {
3957 returnValue = *((int*)args[0]);
3963 returnValue = *((int*)args[0]);
3958 }
3964 }
3959 }
3965 }
3960 }
3966 }
3961 if (result) { Py_DECREF(result); }
3967 if (result) { Py_DECREF(result); }
3962 Py_DECREF(obj);
3968 Py_DECREF(obj);
3963 return returnValue;
3969 return returnValue;
3964 }
3970 }
3965 }
3971 }
3966 return SocExplorerPlot::metric(arg__1);
3972 return SocExplorerPlot::metric(arg__1);
3967 }
3973 }
3968 QSize PythonQtShell_SocExplorerPlot::minimumSizeHint() const
3974 QSize PythonQtShell_SocExplorerPlot::minimumSizeHint() const
3969 {
3975 {
3970 if (_wrapper) {
3976 if (_wrapper) {
3971 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
3977 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
3972 PyErr_Clear();
3978 PyErr_Clear();
3973 if (obj && !PythonQtSlotFunction_Check(obj)) {
3979 if (obj && !PythonQtSlotFunction_Check(obj)) {
3974 static const char* argumentList[] ={"QSize"};
3980 static const char* argumentList[] ={"QSize"};
3975 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3981 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3976 QSize returnValue;
3982 QSize returnValue;
3977 void* args[1] = {NULL};
3983 void* args[1] = {NULL};
3978 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3984 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3979 if (result) {
3985 if (result) {
3980 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3986 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3981 if (args[0]!=&returnValue) {
3987 if (args[0]!=&returnValue) {
3982 if (args[0]==NULL) {
3988 if (args[0]==NULL) {
3983 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
3989 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
3984 } else {
3990 } else {
3985 returnValue = *((QSize*)args[0]);
3991 returnValue = *((QSize*)args[0]);
3986 }
3992 }
3987 }
3993 }
3988 }
3994 }
3989 if (result) { Py_DECREF(result); }
3995 if (result) { Py_DECREF(result); }
3990 Py_DECREF(obj);
3996 Py_DECREF(obj);
3991 return returnValue;
3997 return returnValue;
3992 }
3998 }
3993 }
3999 }
3994 return SocExplorerPlot::minimumSizeHint();
4000 return SocExplorerPlot::minimumSizeHint();
3995 }
4001 }
3996 void PythonQtShell_SocExplorerPlot::mouseDoubleClickEvent(QMouseEvent* arg__1)
4002 void PythonQtShell_SocExplorerPlot::mouseDoubleClickEvent(QMouseEvent* arg__1)
3997 {
4003 {
3998 if (_wrapper) {
4004 if (_wrapper) {
3999 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
4005 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
4000 PyErr_Clear();
4006 PyErr_Clear();
4001 if (obj && !PythonQtSlotFunction_Check(obj)) {
4007 if (obj && !PythonQtSlotFunction_Check(obj)) {
4002 static const char* argumentList[] ={"" , "QMouseEvent*"};
4008 static const char* argumentList[] ={"" , "QMouseEvent*"};
4003 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4009 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4004 void* args[2] = {NULL, (void*)&arg__1};
4010 void* args[2] = {NULL, (void*)&arg__1};
4005 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4011 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4006 if (result) { Py_DECREF(result); }
4012 if (result) { Py_DECREF(result); }
4007 Py_DECREF(obj);
4013 Py_DECREF(obj);
4008 return;
4014 return;
4009 }
4015 }
4010 }
4016 }
4011 SocExplorerPlot::mouseDoubleClickEvent(arg__1);
4017 SocExplorerPlot::mouseDoubleClickEvent(arg__1);
4012 }
4018 }
4013 void PythonQtShell_SocExplorerPlot::mouseMoveEvent(QMouseEvent* arg__1)
4019 void PythonQtShell_SocExplorerPlot::mouseMoveEvent(QMouseEvent* arg__1)
4014 {
4020 {
4015 if (_wrapper) {
4021 if (_wrapper) {
4016 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
4022 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
4017 PyErr_Clear();
4023 PyErr_Clear();
4018 if (obj && !PythonQtSlotFunction_Check(obj)) {
4024 if (obj && !PythonQtSlotFunction_Check(obj)) {
4019 static const char* argumentList[] ={"" , "QMouseEvent*"};
4025 static const char* argumentList[] ={"" , "QMouseEvent*"};
4020 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4026 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4021 void* args[2] = {NULL, (void*)&arg__1};
4027 void* args[2] = {NULL, (void*)&arg__1};
4022 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4028 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4023 if (result) { Py_DECREF(result); }
4029 if (result) { Py_DECREF(result); }
4024 Py_DECREF(obj);
4030 Py_DECREF(obj);
4025 return;
4031 return;
4026 }
4032 }
4027 }
4033 }
4028 SocExplorerPlot::mouseMoveEvent(arg__1);
4034 SocExplorerPlot::mouseMoveEvent(arg__1);
4029 }
4035 }
4030 void PythonQtShell_SocExplorerPlot::mousePressEvent(QMouseEvent* arg__1)
4036 void PythonQtShell_SocExplorerPlot::mousePressEvent(QMouseEvent* arg__1)
4031 {
4037 {
4032 if (_wrapper) {
4038 if (_wrapper) {
4033 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
4039 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
4034 PyErr_Clear();
4040 PyErr_Clear();
4035 if (obj && !PythonQtSlotFunction_Check(obj)) {
4041 if (obj && !PythonQtSlotFunction_Check(obj)) {
4036 static const char* argumentList[] ={"" , "QMouseEvent*"};
4042 static const char* argumentList[] ={"" , "QMouseEvent*"};
4037 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4043 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4038 void* args[2] = {NULL, (void*)&arg__1};
4044 void* args[2] = {NULL, (void*)&arg__1};
4039 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4045 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4040 if (result) { Py_DECREF(result); }
4046 if (result) { Py_DECREF(result); }
4041 Py_DECREF(obj);
4047 Py_DECREF(obj);
4042 return;
4048 return;
4043 }
4049 }
4044 }
4050 }
4045 SocExplorerPlot::mousePressEvent(arg__1);
4051 SocExplorerPlot::mousePressEvent(arg__1);
4046 }
4052 }
4047 void PythonQtShell_SocExplorerPlot::mouseReleaseEvent(QMouseEvent* arg__1)
4053 void PythonQtShell_SocExplorerPlot::mouseReleaseEvent(QMouseEvent* arg__1)
4048 {
4054 {
4049 if (_wrapper) {
4055 if (_wrapper) {
4050 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
4056 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
4051 PyErr_Clear();
4057 PyErr_Clear();
4052 if (obj && !PythonQtSlotFunction_Check(obj)) {
4058 if (obj && !PythonQtSlotFunction_Check(obj)) {
4053 static const char* argumentList[] ={"" , "QMouseEvent*"};
4059 static const char* argumentList[] ={"" , "QMouseEvent*"};
4054 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4060 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4055 void* args[2] = {NULL, (void*)&arg__1};
4061 void* args[2] = {NULL, (void*)&arg__1};
4056 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4062 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4057 if (result) { Py_DECREF(result); }
4063 if (result) { Py_DECREF(result); }
4058 Py_DECREF(obj);
4064 Py_DECREF(obj);
4059 return;
4065 return;
4060 }
4066 }
4061 }
4067 }
4062 SocExplorerPlot::mouseReleaseEvent(arg__1);
4068 SocExplorerPlot::mouseReleaseEvent(arg__1);
4063 }
4069 }
4064 void PythonQtShell_SocExplorerPlot::moveEvent(QMoveEvent* arg__1)
4070 void PythonQtShell_SocExplorerPlot::moveEvent(QMoveEvent* arg__1)
4065 {
4071 {
4066 if (_wrapper) {
4072 if (_wrapper) {
4067 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
4073 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
4068 PyErr_Clear();
4074 PyErr_Clear();
4069 if (obj && !PythonQtSlotFunction_Check(obj)) {
4075 if (obj && !PythonQtSlotFunction_Check(obj)) {
4070 static const char* argumentList[] ={"" , "QMoveEvent*"};
4076 static const char* argumentList[] ={"" , "QMoveEvent*"};
4071 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4077 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4072 void* args[2] = {NULL, (void*)&arg__1};
4078 void* args[2] = {NULL, (void*)&arg__1};
4073 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4079 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4074 if (result) { Py_DECREF(result); }
4080 if (result) { Py_DECREF(result); }
4075 Py_DECREF(obj);
4081 Py_DECREF(obj);
4076 return;
4082 return;
4077 }
4083 }
4078 }
4084 }
4079 SocExplorerPlot::moveEvent(arg__1);
4085 SocExplorerPlot::moveEvent(arg__1);
4080 }
4086 }
4081 bool PythonQtShell_SocExplorerPlot::nativeEvent(const QByteArray& eventType, void* message, long* result)
4087 bool PythonQtShell_SocExplorerPlot::nativeEvent(const QByteArray& eventType, void* message, long* result)
4082 {
4088 {
4083 if (_wrapper) {
4089 if (_wrapper) {
4084 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
4090 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
4085 PyErr_Clear();
4091 PyErr_Clear();
4086 if (obj && !PythonQtSlotFunction_Check(obj)) {
4092 if (obj && !PythonQtSlotFunction_Check(obj)) {
4087 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
4093 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
4088 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
4094 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
4089 bool returnValue;
4095 bool returnValue;
4090 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
4096 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
4091 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4097 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4092 if (result) {
4098 if (result) {
4093 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4099 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4094 if (args[0]!=&returnValue) {
4100 if (args[0]!=&returnValue) {
4095 if (args[0]==NULL) {
4101 if (args[0]==NULL) {
4096 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
4102 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
4097 } else {
4103 } else {
4098 returnValue = *((bool*)args[0]);
4104 returnValue = *((bool*)args[0]);
4099 }
4105 }
4100 }
4106 }
4101 }
4107 }
4102 if (result) { Py_DECREF(result); }
4108 if (result) { Py_DECREF(result); }
4103 Py_DECREF(obj);
4109 Py_DECREF(obj);
4104 return returnValue;
4110 return returnValue;
4105 }
4111 }
4106 }
4112 }
4107 return SocExplorerPlot::nativeEvent(eventType, message, result);
4113 return SocExplorerPlot::nativeEvent(eventType, message, result);
4108 }
4114 }
4109 QPaintEngine* PythonQtShell_SocExplorerPlot::paintEngine() const
4115 QPaintEngine* PythonQtShell_SocExplorerPlot::paintEngine() const
4110 {
4116 {
4111 if (_wrapper) {
4117 if (_wrapper) {
4112 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
4118 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
4113 PyErr_Clear();
4119 PyErr_Clear();
4114 if (obj && !PythonQtSlotFunction_Check(obj)) {
4120 if (obj && !PythonQtSlotFunction_Check(obj)) {
4115 static const char* argumentList[] ={"QPaintEngine*"};
4121 static const char* argumentList[] ={"QPaintEngine*"};
4116 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4122 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4117 QPaintEngine* returnValue;
4123 QPaintEngine* returnValue;
4118 void* args[1] = {NULL};
4124 void* args[1] = {NULL};
4119 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4125 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4120 if (result) {
4126 if (result) {
4121 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4127 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4122 if (args[0]!=&returnValue) {
4128 if (args[0]!=&returnValue) {
4123 if (args[0]==NULL) {
4129 if (args[0]==NULL) {
4124 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
4130 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
4125 } else {
4131 } else {
4126 returnValue = *((QPaintEngine**)args[0]);
4132 returnValue = *((QPaintEngine**)args[0]);
4127 }
4133 }
4128 }
4134 }
4129 }
4135 }
4130 if (result) { Py_DECREF(result); }
4136 if (result) { Py_DECREF(result); }
4131 Py_DECREF(obj);
4137 Py_DECREF(obj);
4132 return returnValue;
4138 return returnValue;
4133 }
4139 }
4134 }
4140 }
4135 return SocExplorerPlot::paintEngine();
4141 return SocExplorerPlot::paintEngine();
4136 }
4142 }
4137 void PythonQtShell_SocExplorerPlot::paintEvent(QPaintEvent* arg__1)
4143 void PythonQtShell_SocExplorerPlot::paintEvent(QPaintEvent* arg__1)
4138 {
4144 {
4139 if (_wrapper) {
4145 if (_wrapper) {
4140 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
4146 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
4141 PyErr_Clear();
4147 PyErr_Clear();
4142 if (obj && !PythonQtSlotFunction_Check(obj)) {
4148 if (obj && !PythonQtSlotFunction_Check(obj)) {
4143 static const char* argumentList[] ={"" , "QPaintEvent*"};
4149 static const char* argumentList[] ={"" , "QPaintEvent*"};
4144 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4150 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4145 void* args[2] = {NULL, (void*)&arg__1};
4151 void* args[2] = {NULL, (void*)&arg__1};
4146 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4152 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4147 if (result) { Py_DECREF(result); }
4153 if (result) { Py_DECREF(result); }
4148 Py_DECREF(obj);
4154 Py_DECREF(obj);
4149 return;
4155 return;
4150 }
4156 }
4151 }
4157 }
4152 SocExplorerPlot::paintEvent(arg__1);
4158 SocExplorerPlot::paintEvent(arg__1);
4153 }
4159 }
4154 QPaintDevice* PythonQtShell_SocExplorerPlot::redirected(QPoint* offset) const
4160 QPaintDevice* PythonQtShell_SocExplorerPlot::redirected(QPoint* offset) const
4155 {
4161 {
4156 if (_wrapper) {
4162 if (_wrapper) {
4157 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
4163 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
4158 PyErr_Clear();
4164 PyErr_Clear();
4159 if (obj && !PythonQtSlotFunction_Check(obj)) {
4165 if (obj && !PythonQtSlotFunction_Check(obj)) {
4160 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
4166 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
4161 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4167 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4162 QPaintDevice* returnValue;
4168 QPaintDevice* returnValue;
4163 void* args[2] = {NULL, (void*)&offset};
4169 void* args[2] = {NULL, (void*)&offset};
4164 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4170 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4165 if (result) {
4171 if (result) {
4166 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4172 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4167 if (args[0]!=&returnValue) {
4173 if (args[0]!=&returnValue) {
4168 if (args[0]==NULL) {
4174 if (args[0]==NULL) {
4169 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
4175 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
4170 } else {
4176 } else {
4171 returnValue = *((QPaintDevice**)args[0]);
4177 returnValue = *((QPaintDevice**)args[0]);
4172 }
4178 }
4173 }
4179 }
4174 }
4180 }
4175 if (result) { Py_DECREF(result); }
4181 if (result) { Py_DECREF(result); }
4176 Py_DECREF(obj);
4182 Py_DECREF(obj);
4177 return returnValue;
4183 return returnValue;
4178 }
4184 }
4179 }
4185 }
4180 return SocExplorerPlot::redirected(offset);
4186 return SocExplorerPlot::redirected(offset);
4181 }
4187 }
4182 void PythonQtShell_SocExplorerPlot::resizeEvent(QResizeEvent* arg__1)
4188 void PythonQtShell_SocExplorerPlot::resizeEvent(QResizeEvent* arg__1)
4183 {
4189 {
4184 if (_wrapper) {
4190 if (_wrapper) {
4185 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
4191 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
4186 PyErr_Clear();
4192 PyErr_Clear();
4187 if (obj && !PythonQtSlotFunction_Check(obj)) {
4193 if (obj && !PythonQtSlotFunction_Check(obj)) {
4188 static const char* argumentList[] ={"" , "QResizeEvent*"};
4194 static const char* argumentList[] ={"" , "QResizeEvent*"};
4189 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4195 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4190 void* args[2] = {NULL, (void*)&arg__1};
4196 void* args[2] = {NULL, (void*)&arg__1};
4191 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4197 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4192 if (result) { Py_DECREF(result); }
4198 if (result) { Py_DECREF(result); }
4193 Py_DECREF(obj);
4199 Py_DECREF(obj);
4194 return;
4200 return;
4195 }
4201 }
4196 }
4202 }
4197 SocExplorerPlot::resizeEvent(arg__1);
4203 SocExplorerPlot::resizeEvent(arg__1);
4198 }
4204 }
4199 QPainter* PythonQtShell_SocExplorerPlot::sharedPainter() const
4205 QPainter* PythonQtShell_SocExplorerPlot::sharedPainter() const
4200 {
4206 {
4201 if (_wrapper) {
4207 if (_wrapper) {
4202 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
4208 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
4203 PyErr_Clear();
4209 PyErr_Clear();
4204 if (obj && !PythonQtSlotFunction_Check(obj)) {
4210 if (obj && !PythonQtSlotFunction_Check(obj)) {
4205 static const char* argumentList[] ={"QPainter*"};
4211 static const char* argumentList[] ={"QPainter*"};
4206 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4212 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4207 QPainter* returnValue;
4213 QPainter* returnValue;
4208 void* args[1] = {NULL};
4214 void* args[1] = {NULL};
4209 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4215 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4210 if (result) {
4216 if (result) {
4211 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4217 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4212 if (args[0]!=&returnValue) {
4218 if (args[0]!=&returnValue) {
4213 if (args[0]==NULL) {
4219 if (args[0]==NULL) {
4214 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
4220 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
4215 } else {
4221 } else {
4216 returnValue = *((QPainter**)args[0]);
4222 returnValue = *((QPainter**)args[0]);
4217 }
4223 }
4218 }
4224 }
4219 }
4225 }
4220 if (result) { Py_DECREF(result); }
4226 if (result) { Py_DECREF(result); }
4221 Py_DECREF(obj);
4227 Py_DECREF(obj);
4222 return returnValue;
4228 return returnValue;
4223 }
4229 }
4224 }
4230 }
4225 return SocExplorerPlot::sharedPainter();
4231 return SocExplorerPlot::sharedPainter();
4226 }
4232 }
4227 void PythonQtShell_SocExplorerPlot::showEvent(QShowEvent* arg__1)
4233 void PythonQtShell_SocExplorerPlot::showEvent(QShowEvent* arg__1)
4228 {
4234 {
4229 if (_wrapper) {
4235 if (_wrapper) {
4230 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
4236 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
4231 PyErr_Clear();
4237 PyErr_Clear();
4232 if (obj && !PythonQtSlotFunction_Check(obj)) {
4238 if (obj && !PythonQtSlotFunction_Check(obj)) {
4233 static const char* argumentList[] ={"" , "QShowEvent*"};
4239 static const char* argumentList[] ={"" , "QShowEvent*"};
4234 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4240 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4235 void* args[2] = {NULL, (void*)&arg__1};
4241 void* args[2] = {NULL, (void*)&arg__1};
4236 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4242 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4237 if (result) { Py_DECREF(result); }
4243 if (result) { Py_DECREF(result); }
4238 Py_DECREF(obj);
4244 Py_DECREF(obj);
4239 return;
4245 return;
4240 }
4246 }
4241 }
4247 }
4242 SocExplorerPlot::showEvent(arg__1);
4248 SocExplorerPlot::showEvent(arg__1);
4243 }
4249 }
4244 QSize PythonQtShell_SocExplorerPlot::sizeHint() const
4250 QSize PythonQtShell_SocExplorerPlot::sizeHint() const
4245 {
4251 {
4246 if (_wrapper) {
4252 if (_wrapper) {
4247 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
4253 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
4248 PyErr_Clear();
4254 PyErr_Clear();
4249 if (obj && !PythonQtSlotFunction_Check(obj)) {
4255 if (obj && !PythonQtSlotFunction_Check(obj)) {
4250 static const char* argumentList[] ={"QSize"};
4256 static const char* argumentList[] ={"QSize"};
4251 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4257 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4252 QSize returnValue;
4258 QSize returnValue;
4253 void* args[1] = {NULL};
4259 void* args[1] = {NULL};
4254 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4260 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4255 if (result) {
4261 if (result) {
4256 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4262 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4257 if (args[0]!=&returnValue) {
4263 if (args[0]!=&returnValue) {
4258 if (args[0]==NULL) {
4264 if (args[0]==NULL) {
4259 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
4265 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
4260 } else {
4266 } else {
4261 returnValue = *((QSize*)args[0]);
4267 returnValue = *((QSize*)args[0]);
4262 }
4268 }
4263 }
4269 }
4264 }
4270 }
4265 if (result) { Py_DECREF(result); }
4271 if (result) { Py_DECREF(result); }
4266 Py_DECREF(obj);
4272 Py_DECREF(obj);
4267 return returnValue;
4273 return returnValue;
4268 }
4274 }
4269 }
4275 }
4270 return SocExplorerPlot::sizeHint();
4276 return SocExplorerPlot::sizeHint();
4271 }
4277 }
4272 void PythonQtShell_SocExplorerPlot::tabletEvent(QTabletEvent* arg__1)
4278 void PythonQtShell_SocExplorerPlot::tabletEvent(QTabletEvent* arg__1)
4273 {
4279 {
4274 if (_wrapper) {
4280 if (_wrapper) {
4275 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
4281 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
4276 PyErr_Clear();
4282 PyErr_Clear();
4277 if (obj && !PythonQtSlotFunction_Check(obj)) {
4283 if (obj && !PythonQtSlotFunction_Check(obj)) {
4278 static const char* argumentList[] ={"" , "QTabletEvent*"};
4284 static const char* argumentList[] ={"" , "QTabletEvent*"};
4279 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4285 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4280 void* args[2] = {NULL, (void*)&arg__1};
4286 void* args[2] = {NULL, (void*)&arg__1};
4281 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4287 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4282 if (result) { Py_DECREF(result); }
4288 if (result) { Py_DECREF(result); }
4283 Py_DECREF(obj);
4289 Py_DECREF(obj);
4284 return;
4290 return;
4285 }
4291 }
4286 }
4292 }
4287 SocExplorerPlot::tabletEvent(arg__1);
4293 SocExplorerPlot::tabletEvent(arg__1);
4288 }
4294 }
4289 void PythonQtShell_SocExplorerPlot::timerEvent(QTimerEvent* arg__1)
4295 void PythonQtShell_SocExplorerPlot::timerEvent(QTimerEvent* arg__1)
4290 {
4296 {
4291 if (_wrapper) {
4297 if (_wrapper) {
4292 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
4298 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
4293 PyErr_Clear();
4299 PyErr_Clear();
4294 if (obj && !PythonQtSlotFunction_Check(obj)) {
4300 if (obj && !PythonQtSlotFunction_Check(obj)) {
4295 static const char* argumentList[] ={"" , "QTimerEvent*"};
4301 static const char* argumentList[] ={"" , "QTimerEvent*"};
4296 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4302 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4297 void* args[2] = {NULL, (void*)&arg__1};
4303 void* args[2] = {NULL, (void*)&arg__1};
4298 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4304 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4299 if (result) { Py_DECREF(result); }
4305 if (result) { Py_DECREF(result); }
4300 Py_DECREF(obj);
4306 Py_DECREF(obj);
4301 return;
4307 return;
4302 }
4308 }
4303 }
4309 }
4304 SocExplorerPlot::timerEvent(arg__1);
4310 SocExplorerPlot::timerEvent(arg__1);
4305 }
4311 }
4306 void PythonQtShell_SocExplorerPlot::wheelEvent(QWheelEvent* arg__1)
4312 void PythonQtShell_SocExplorerPlot::wheelEvent(QWheelEvent* arg__1)
4307 {
4313 {
4308 if (_wrapper) {
4314 if (_wrapper) {
4309 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
4315 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
4310 PyErr_Clear();
4316 PyErr_Clear();
4311 if (obj && !PythonQtSlotFunction_Check(obj)) {
4317 if (obj && !PythonQtSlotFunction_Check(obj)) {
4312 static const char* argumentList[] ={"" , "QWheelEvent*"};
4318 static const char* argumentList[] ={"" , "QWheelEvent*"};
4313 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4319 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4314 void* args[2] = {NULL, (void*)&arg__1};
4320 void* args[2] = {NULL, (void*)&arg__1};
4315 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4321 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4316 if (result) { Py_DECREF(result); }
4322 if (result) { Py_DECREF(result); }
4317 Py_DECREF(obj);
4323 Py_DECREF(obj);
4318 return;
4324 return;
4319 }
4325 }
4320 }
4326 }
4321 SocExplorerPlot::wheelEvent(arg__1);
4327 SocExplorerPlot::wheelEvent(arg__1);
4322 }
4328 }
4323 SocExplorerPlot* PythonQtWrapper_SocExplorerPlot::new_SocExplorerPlot(QWidget* parent)
4329 SocExplorerPlot* PythonQtWrapper_SocExplorerPlot::new_SocExplorerPlot(QWidget* parent)
4324 {
4330 {
4325 return new PythonQtShell_SocExplorerPlot(parent); }
4331 return new PythonQtShell_SocExplorerPlot(parent); }
4326
4332
4327 int PythonQtWrapper_SocExplorerPlot::addGraph(SocExplorerPlot* theWrappedObject)
4333 int PythonQtWrapper_SocExplorerPlot::addGraph(SocExplorerPlot* theWrappedObject)
4328 {
4334 {
4329 return ( theWrappedObject->addGraph());
4335 return ( theWrappedObject->addGraph());
4330 }
4336 }
4331
4337
4332 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4338 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4333 {
4339 {
4334 ( theWrappedObject->addGraphData(graphIndex, x, y));
4340 ( theWrappedObject->addGraphData(graphIndex, x, y));
4335 }
4341 }
4336
4342
4337 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y)
4343 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y)
4338 {
4344 {
4339 ( theWrappedObject->addGraphData(graphIndex, x, y));
4345 ( theWrappedObject->addGraphData(graphIndex, x, y));
4340 }
4346 }
4341
4347
4342 QPen PythonQtWrapper_SocExplorerPlot::getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex)
4348 QPen PythonQtWrapper_SocExplorerPlot::getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex)
4343 {
4349 {
4344 return ( theWrappedObject->getGraphPen(graphIndex));
4350 return ( theWrappedObject->getGraphPen(graphIndex));
4345 }
4351 }
4346
4352
4347 void PythonQtWrapper_SocExplorerPlot::keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4353 void PythonQtWrapper_SocExplorerPlot::keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4348 {
4354 {
4349 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyPressEvent(arg__1));
4355 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyPressEvent(arg__1));
4350 }
4356 }
4351
4357
4352 void PythonQtWrapper_SocExplorerPlot::keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4358 void PythonQtWrapper_SocExplorerPlot::keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4353 {
4359 {
4354 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyReleaseEvent(arg__1));
4360 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyReleaseEvent(arg__1));
4355 }
4361 }
4356
4362
4357 void PythonQtWrapper_SocExplorerPlot::mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4363 void PythonQtWrapper_SocExplorerPlot::mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4358 {
4364 {
4359 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseMoveEvent(arg__1));
4365 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseMoveEvent(arg__1));
4360 }
4366 }
4361
4367
4362 void PythonQtWrapper_SocExplorerPlot::mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4368 void PythonQtWrapper_SocExplorerPlot::mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4363 {
4369 {
4364 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mousePressEvent(arg__1));
4370 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mousePressEvent(arg__1));
4365 }
4371 }
4366
4372
4367 void PythonQtWrapper_SocExplorerPlot::mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4373 void PythonQtWrapper_SocExplorerPlot::mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4368 {
4374 {
4369 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseReleaseEvent(arg__1));
4375 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseReleaseEvent(arg__1));
4370 }
4376 }
4371
4377
4372 void PythonQtWrapper_SocExplorerPlot::rescaleAxis(SocExplorerPlot* theWrappedObject)
4378 void PythonQtWrapper_SocExplorerPlot::rescaleAxis(SocExplorerPlot* theWrappedObject)
4373 {
4379 {
4374 ( theWrappedObject->rescaleAxis());
4380 ( theWrappedObject->rescaleAxis());
4375 }
4381 }
4376
4382
4377 void PythonQtWrapper_SocExplorerPlot::setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable)
4383 void PythonQtWrapper_SocExplorerPlot::setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable)
4378 {
4384 {
4379 ( theWrappedObject->setAdaptativeSampling(graphIndex, enable));
4385 ( theWrappedObject->setAdaptativeSampling(graphIndex, enable));
4380 }
4386 }
4381
4387
4382 void PythonQtWrapper_SocExplorerPlot::setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4388 void PythonQtWrapper_SocExplorerPlot::setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4383 {
4389 {
4384 ( theWrappedObject->setGraphData(graphIndex, x, y));
4390 ( theWrappedObject->setGraphData(graphIndex, x, y));
4385 }
4391 }
4386
4392
4387 void PythonQtWrapper_SocExplorerPlot::setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle)
4393 void PythonQtWrapper_SocExplorerPlot::setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle)
4388 {
4394 {
4389 ( theWrappedObject->setGraphLineStyle(graphIndex, lineStyle));
4395 ( theWrappedObject->setGraphLineStyle(graphIndex, lineStyle));
4390 }
4396 }
4391
4397
4392 void PythonQtWrapper_SocExplorerPlot::setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name)
4398 void PythonQtWrapper_SocExplorerPlot::setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name)
4393 {
4399 {
4394 ( theWrappedObject->setGraphName(graphIndex, name));
4400 ( theWrappedObject->setGraphName(graphIndex, name));
4395 }
4401 }
4396
4402
4397 void PythonQtWrapper_SocExplorerPlot::setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen)
4403 void PythonQtWrapper_SocExplorerPlot::setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen)
4398 {
4404 {
4399 ( theWrappedObject->setGraphPen(graphIndex, pen));
4405 ( theWrappedObject->setGraphPen(graphIndex, pen));
4400 }
4406 }
4401
4407
4402 void PythonQtWrapper_SocExplorerPlot::setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle)
4408 void PythonQtWrapper_SocExplorerPlot::setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle)
4403 {
4409 {
4404 ( theWrappedObject->setGraphScatterStyle(graphIndex, scatterStyle));
4410 ( theWrappedObject->setGraphScatterStyle(graphIndex, scatterStyle));
4405 }
4411 }
4406
4412
4407 void PythonQtWrapper_SocExplorerPlot::setLegendFont(SocExplorerPlot* theWrappedObject, QFont font)
4413 void PythonQtWrapper_SocExplorerPlot::setLegendFont(SocExplorerPlot* theWrappedObject, QFont font)
4408 {
4414 {
4409 ( theWrappedObject->setLegendFont(font));
4415 ( theWrappedObject->setLegendFont(font));
4410 }
4416 }
4411
4417
4412 void PythonQtWrapper_SocExplorerPlot::setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font)
4418 void PythonQtWrapper_SocExplorerPlot::setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font)
4413 {
4419 {
4414 ( theWrappedObject->setLegendSelectedFont(font));
4420 ( theWrappedObject->setLegendSelectedFont(font));
4415 }
4421 }
4416
4422
4417 void PythonQtWrapper_SocExplorerPlot::setTitle(SocExplorerPlot* theWrappedObject, QString title)
4423 void PythonQtWrapper_SocExplorerPlot::setTitle(SocExplorerPlot* theWrappedObject, QString title)
4418 {
4424 {
4419 ( theWrappedObject->setTitle(title));
4425 ( theWrappedObject->setTitle(title));
4420 }
4426 }
4421
4427
4422 void PythonQtWrapper_SocExplorerPlot::setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4428 void PythonQtWrapper_SocExplorerPlot::setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4423 {
4429 {
4424 ( theWrappedObject->setXaxisLabel(label));
4430 ( theWrappedObject->setXaxisLabel(label));
4425 }
4431 }
4426
4432
4427 void PythonQtWrapper_SocExplorerPlot::setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4433 void PythonQtWrapper_SocExplorerPlot::setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4428 {
4434 {
4429 ( theWrappedObject->setXaxisRange(lower, upper));
4435 ( theWrappedObject->setXaxisRange(lower, upper));
4430 }
4436 }
4431
4437
4432 void PythonQtWrapper_SocExplorerPlot::setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4438 void PythonQtWrapper_SocExplorerPlot::setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4433 {
4439 {
4434 ( theWrappedObject->setYaxisLabel(label));
4440 ( theWrappedObject->setYaxisLabel(label));
4435 }
4441 }
4436
4442
4437 void PythonQtWrapper_SocExplorerPlot::setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4443 void PythonQtWrapper_SocExplorerPlot::setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4438 {
4444 {
4439 ( theWrappedObject->setYaxisRange(lower, upper));
4445 ( theWrappedObject->setYaxisRange(lower, upper));
4440 }
4446 }
4441
4447
4442 void PythonQtWrapper_SocExplorerPlot::show(SocExplorerPlot* theWrappedObject)
4448 void PythonQtWrapper_SocExplorerPlot::show(SocExplorerPlot* theWrappedObject)
4443 {
4449 {
4444 ( theWrappedObject->show());
4450 ( theWrappedObject->show());
4445 }
4451 }
4446
4452
4447 void PythonQtWrapper_SocExplorerPlot::wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1)
4453 void PythonQtWrapper_SocExplorerPlot::wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1)
4448 {
4454 {
4449 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_wheelEvent(arg__1));
4455 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_wheelEvent(arg__1));
4450 }
4456 }
4451
4457
4452
4458
4453
4459
4454 PythonQtShell_TCP_Terminal_Client::~PythonQtShell_TCP_Terminal_Client() {
4460 PythonQtShell_TCP_Terminal_Client::~PythonQtShell_TCP_Terminal_Client() {
4455 PythonQtPrivate* priv = PythonQt::priv();
4461 PythonQtPrivate* priv = PythonQt::priv();
4456 if (priv) { priv->shellClassDeleted(this); }
4462 if (priv) { priv->shellClassDeleted(this); }
4457 }
4463 }
4458 void PythonQtShell_TCP_Terminal_Client::childEvent(QChildEvent* arg__1)
4464 void PythonQtShell_TCP_Terminal_Client::childEvent(QChildEvent* arg__1)
4459 {
4465 {
4460 if (_wrapper) {
4466 if (_wrapper) {
4461 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
4467 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
4462 PyErr_Clear();
4468 PyErr_Clear();
4463 if (obj && !PythonQtSlotFunction_Check(obj)) {
4469 if (obj && !PythonQtSlotFunction_Check(obj)) {
4464 static const char* argumentList[] ={"" , "QChildEvent*"};
4470 static const char* argumentList[] ={"" , "QChildEvent*"};
4465 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4471 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4466 void* args[2] = {NULL, (void*)&arg__1};
4472 void* args[2] = {NULL, (void*)&arg__1};
4467 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4473 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4468 if (result) { Py_DECREF(result); }
4474 if (result) { Py_DECREF(result); }
4469 Py_DECREF(obj);
4475 Py_DECREF(obj);
4470 return;
4476 return;
4471 }
4477 }
4472 }
4478 }
4473 TCP_Terminal_Client::childEvent(arg__1);
4479 TCP_Terminal_Client::childEvent(arg__1);
4474 }
4480 }
4475 void PythonQtShell_TCP_Terminal_Client::customEvent(QEvent* arg__1)
4481 void PythonQtShell_TCP_Terminal_Client::customEvent(QEvent* arg__1)
4476 {
4482 {
4477 if (_wrapper) {
4483 if (_wrapper) {
4478 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
4484 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
4479 PyErr_Clear();
4485 PyErr_Clear();
4480 if (obj && !PythonQtSlotFunction_Check(obj)) {
4486 if (obj && !PythonQtSlotFunction_Check(obj)) {
4481 static const char* argumentList[] ={"" , "QEvent*"};
4487 static const char* argumentList[] ={"" , "QEvent*"};
4482 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4488 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4483 void* args[2] = {NULL, (void*)&arg__1};
4489 void* args[2] = {NULL, (void*)&arg__1};
4484 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4490 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4485 if (result) { Py_DECREF(result); }
4491 if (result) { Py_DECREF(result); }
4486 Py_DECREF(obj);
4492 Py_DECREF(obj);
4487 return;
4493 return;
4488 }
4494 }
4489 }
4495 }
4490 TCP_Terminal_Client::customEvent(arg__1);
4496 TCP_Terminal_Client::customEvent(arg__1);
4491 }
4497 }
4492 bool PythonQtShell_TCP_Terminal_Client::event(QEvent* arg__1)
4498 bool PythonQtShell_TCP_Terminal_Client::event(QEvent* arg__1)
4493 {
4499 {
4494 if (_wrapper) {
4500 if (_wrapper) {
4495 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
4501 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
4496 PyErr_Clear();
4502 PyErr_Clear();
4497 if (obj && !PythonQtSlotFunction_Check(obj)) {
4503 if (obj && !PythonQtSlotFunction_Check(obj)) {
4498 static const char* argumentList[] ={"bool" , "QEvent*"};
4504 static const char* argumentList[] ={"bool" , "QEvent*"};
4499 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4505 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4500 bool returnValue;
4506 bool returnValue;
4501 void* args[2] = {NULL, (void*)&arg__1};
4507 void* args[2] = {NULL, (void*)&arg__1};
4502 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4508 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4503 if (result) {
4509 if (result) {
4504 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4510 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4505 if (args[0]!=&returnValue) {
4511 if (args[0]!=&returnValue) {
4506 if (args[0]==NULL) {
4512 if (args[0]==NULL) {
4507 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
4513 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
4508 } else {
4514 } else {
4509 returnValue = *((bool*)args[0]);
4515 returnValue = *((bool*)args[0]);
4510 }
4516 }
4511 }
4517 }
4512 }
4518 }
4513 if (result) { Py_DECREF(result); }
4519 if (result) { Py_DECREF(result); }
4514 Py_DECREF(obj);
4520 Py_DECREF(obj);
4515 return returnValue;
4521 return returnValue;
4516 }
4522 }
4517 }
4523 }
4518 return TCP_Terminal_Client::event(arg__1);
4524 return TCP_Terminal_Client::event(arg__1);
4519 }
4525 }
4520 bool PythonQtShell_TCP_Terminal_Client::eventFilter(QObject* arg__1, QEvent* arg__2)
4526 bool PythonQtShell_TCP_Terminal_Client::eventFilter(QObject* arg__1, QEvent* arg__2)
4521 {
4527 {
4522 if (_wrapper) {
4528 if (_wrapper) {
4523 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
4529 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
4524 PyErr_Clear();
4530 PyErr_Clear();
4525 if (obj && !PythonQtSlotFunction_Check(obj)) {
4531 if (obj && !PythonQtSlotFunction_Check(obj)) {
4526 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4532 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4527 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4533 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4528 bool returnValue;
4534 bool returnValue;
4529 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
4535 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
4530 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4536 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4531 if (result) {
4537 if (result) {
4532 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4538 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4533 if (args[0]!=&returnValue) {
4539 if (args[0]!=&returnValue) {
4534 if (args[0]==NULL) {
4540 if (args[0]==NULL) {
4535 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
4541 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
4536 } else {
4542 } else {
4537 returnValue = *((bool*)args[0]);
4543 returnValue = *((bool*)args[0]);
4538 }
4544 }
4539 }
4545 }
4540 }
4546 }
4541 if (result) { Py_DECREF(result); }
4547 if (result) { Py_DECREF(result); }
4542 Py_DECREF(obj);
4548 Py_DECREF(obj);
4543 return returnValue;
4549 return returnValue;
4544 }
4550 }
4545 }
4551 }
4546 return TCP_Terminal_Client::eventFilter(arg__1, arg__2);
4552 return TCP_Terminal_Client::eventFilter(arg__1, arg__2);
4547 }
4553 }
4548 void PythonQtShell_TCP_Terminal_Client::timerEvent(QTimerEvent* arg__1)
4554 void PythonQtShell_TCP_Terminal_Client::timerEvent(QTimerEvent* arg__1)
4549 {
4555 {
4550 if (_wrapper) {
4556 if (_wrapper) {
4551 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
4557 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
4552 PyErr_Clear();
4558 PyErr_Clear();
4553 if (obj && !PythonQtSlotFunction_Check(obj)) {
4559 if (obj && !PythonQtSlotFunction_Check(obj)) {
4554 static const char* argumentList[] ={"" , "QTimerEvent*"};
4560 static const char* argumentList[] ={"" , "QTimerEvent*"};
4555 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4561 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4556 void* args[2] = {NULL, (void*)&arg__1};
4562 void* args[2] = {NULL, (void*)&arg__1};
4557 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4563 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4558 if (result) { Py_DECREF(result); }
4564 if (result) { Py_DECREF(result); }
4559 Py_DECREF(obj);
4565 Py_DECREF(obj);
4560 return;
4566 return;
4561 }
4567 }
4562 }
4568 }
4563 TCP_Terminal_Client::timerEvent(arg__1);
4569 TCP_Terminal_Client::timerEvent(arg__1);
4564 }
4570 }
4565 TCP_Terminal_Client* PythonQtWrapper_TCP_Terminal_Client::new_TCP_Terminal_Client(QObject* parent)
4571 TCP_Terminal_Client* PythonQtWrapper_TCP_Terminal_Client::new_TCP_Terminal_Client(QObject* parent)
4566 {
4572 {
4567 return new PythonQtShell_TCP_Terminal_Client(parent); }
4573 return new PythonQtShell_TCP_Terminal_Client(parent); }
4568
4574
4569 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject)
4575 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject)
4570 {
4576 {
4571 ( theWrappedObject->connectToServer());
4577 ( theWrappedObject->connectToServer());
4572 }
4578 }
4573
4579
4574 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port)
4580 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port)
4575 {
4581 {
4576 ( theWrappedObject->connectToServer(IP, port));
4582 ( theWrappedObject->connectToServer(IP, port));
4577 }
4583 }
4578
4584
4579 bool PythonQtWrapper_TCP_Terminal_Client::isConnected(TCP_Terminal_Client* theWrappedObject)
4585 bool PythonQtWrapper_TCP_Terminal_Client::isConnected(TCP_Terminal_Client* theWrappedObject)
4580 {
4586 {
4581 return ( theWrappedObject->isConnected());
4587 return ( theWrappedObject->isConnected());
4582 }
4588 }
4583
4589
4584 void PythonQtWrapper_TCP_Terminal_Client::sendText(TCP_Terminal_Client* theWrappedObject, const QString& text)
4590 void PythonQtWrapper_TCP_Terminal_Client::sendText(TCP_Terminal_Client* theWrappedObject, const QString& text)
4585 {
4591 {
4586 ( theWrappedObject->sendText(text));
4592 ( theWrappedObject->sendText(text));
4587 }
4593 }
4588
4594
4589 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject)
4595 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject)
4590 {
4596 {
4591 ( theWrappedObject->startServer());
4597 ( theWrappedObject->startServer());
4592 }
4598 }
4593
4599
4594 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject, int port)
4600 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject, int port)
4595 {
4601 {
4596 ( theWrappedObject->startServer(port));
4602 ( theWrappedObject->startServer(port));
4597 }
4603 }
4598
4604
4599
4605
4600
4606
4601 XByteArray* PythonQtWrapper_XByteArray::new_XByteArray()
4607 XByteArray* PythonQtWrapper_XByteArray::new_XByteArray()
4602 {
4608 {
4603 return new XByteArray(); }
4609 return new XByteArray(); }
4604
4610
4605 int PythonQtWrapper_XByteArray::addressOffset(XByteArray* theWrappedObject)
4611 int PythonQtWrapper_XByteArray::addressOffset(XByteArray* theWrappedObject)
4606 {
4612 {
4607 return ( theWrappedObject->addressOffset());
4613 return ( theWrappedObject->addressOffset());
4608 }
4614 }
4609
4615
4610 int PythonQtWrapper_XByteArray::addressWidth(XByteArray* theWrappedObject)
4616 int PythonQtWrapper_XByteArray::addressWidth(XByteArray* theWrappedObject)
4611 {
4617 {
4612 return ( theWrappedObject->addressWidth());
4618 return ( theWrappedObject->addressWidth());
4613 }
4619 }
4614
4620
4615 QChar PythonQtWrapper_XByteArray::asciiChar(XByteArray* theWrappedObject, int index)
4621 QChar PythonQtWrapper_XByteArray::asciiChar(XByteArray* theWrappedObject, int index)
4616 {
4622 {
4617 return ( theWrappedObject->asciiChar(index));
4623 return ( theWrappedObject->asciiChar(index));
4618 }
4624 }
4619
4625
4620 QByteArray* PythonQtWrapper_XByteArray::data(XByteArray* theWrappedObject)
4626 QByteArray* PythonQtWrapper_XByteArray::data(XByteArray* theWrappedObject)
4621 {
4627 {
4622 return &( theWrappedObject->data());
4628 return &( theWrappedObject->data());
4623 }
4629 }
4624
4630
4625 bool PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i)
4631 bool PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i)
4626 {
4632 {
4627 return ( theWrappedObject->dataChanged(i));
4633 return ( theWrappedObject->dataChanged(i));
4628 }
4634 }
4629
4635
4630 QByteArray PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i, int len)
4636 QByteArray PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i, int len)
4631 {
4637 {
4632 return ( theWrappedObject->dataChanged(i, len));
4638 return ( theWrappedObject->dataChanged(i, len));
4633 }
4639 }
4634
4640
4635 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, char ch)
4641 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, char ch)
4636 {
4642 {
4637 return &( theWrappedObject->insert(i, ch));
4643 return &( theWrappedObject->insert(i, ch));
4638 }
4644 }
4639
4645
4640 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, const QByteArray& ba)
4646 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, const QByteArray& ba)
4641 {
4647 {
4642 return &( theWrappedObject->insert(i, ba));
4648 return &( theWrappedObject->insert(i, ba));
4643 }
4649 }
4644
4650
4645 int PythonQtWrapper_XByteArray::realAddressNumbers(XByteArray* theWrappedObject)
4651 int PythonQtWrapper_XByteArray::realAddressNumbers(XByteArray* theWrappedObject)
4646 {
4652 {
4647 return ( theWrappedObject->realAddressNumbers());
4653 return ( theWrappedObject->realAddressNumbers());
4648 }
4654 }
4649
4655
4650 QByteArray* PythonQtWrapper_XByteArray::remove(XByteArray* theWrappedObject, int pos, int len)
4656 QByteArray* PythonQtWrapper_XByteArray::remove(XByteArray* theWrappedObject, int pos, int len)
4651 {
4657 {
4652 return &( theWrappedObject->remove(pos, len));
4658 return &( theWrappedObject->remove(pos, len));
4653 }
4659 }
4654
4660
4655 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, char ch)
4661 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, char ch)
4656 {
4662 {
4657 return &( theWrappedObject->replace(index, ch));
4663 return &( theWrappedObject->replace(index, ch));
4658 }
4664 }
4659
4665
4660 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, const QByteArray& ba)
4666 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, const QByteArray& ba)
4661 {
4667 {
4662 return &( theWrappedObject->replace(index, ba));
4668 return &( theWrappedObject->replace(index, ba));
4663 }
4669 }
4664
4670
4665 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba)
4671 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba)
4666 {
4672 {
4667 return &( theWrappedObject->replace(index, length, ba));
4673 return &( theWrappedObject->replace(index, length, ba));
4668 }
4674 }
4669
4675
4670 void PythonQtWrapper_XByteArray::setAddressOffset(XByteArray* theWrappedObject, int offset)
4676 void PythonQtWrapper_XByteArray::setAddressOffset(XByteArray* theWrappedObject, int offset)
4671 {
4677 {
4672 ( theWrappedObject->setAddressOffset(offset));
4678 ( theWrappedObject->setAddressOffset(offset));
4673 }
4679 }
4674
4680
4675 void PythonQtWrapper_XByteArray::setAddressWidth(XByteArray* theWrappedObject, int width)
4681 void PythonQtWrapper_XByteArray::setAddressWidth(XByteArray* theWrappedObject, int width)
4676 {
4682 {
4677 ( theWrappedObject->setAddressWidth(width));
4683 ( theWrappedObject->setAddressWidth(width));
4678 }
4684 }
4679
4685
4680 void PythonQtWrapper_XByteArray::setData(XByteArray* theWrappedObject, QByteArray data)
4686 void PythonQtWrapper_XByteArray::setData(XByteArray* theWrappedObject, QByteArray data)
4681 {
4687 {
4682 ( theWrappedObject->setData(data));
4688 ( theWrappedObject->setData(data));
4683 }
4689 }
4684
4690
4685 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, bool state)
4691 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, bool state)
4686 {
4692 {
4687 ( theWrappedObject->setDataChanged(i, state));
4693 ( theWrappedObject->setDataChanged(i, state));
4688 }
4694 }
4689
4695
4690 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state)
4696 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state)
4691 {
4697 {
4692 ( theWrappedObject->setDataChanged(i, state));
4698 ( theWrappedObject->setDataChanged(i, state));
4693 }
4699 }
4694
4700
4695 int PythonQtWrapper_XByteArray::size(XByteArray* theWrappedObject)
4701 int PythonQtWrapper_XByteArray::size(XByteArray* theWrappedObject)
4696 {
4702 {
4697 return ( theWrappedObject->size());
4703 return ( theWrappedObject->size());
4698 }
4704 }
4699
4705
4700 QString PythonQtWrapper_XByteArray::toRedableString(XByteArray* theWrappedObject, int start, int end)
4706 QString PythonQtWrapper_XByteArray::toRedableString(XByteArray* theWrappedObject, int start, int end)
4701 {
4707 {
4702 return ( theWrappedObject->toRedableString(start, end));
4708 return ( theWrappedObject->toRedableString(start, end));
4703 }
4709 }
4704
4710
4705
4711
4706
4712
4707 PythonQtShell_abstractExecFile::~PythonQtShell_abstractExecFile() {
4713 PythonQtShell_abstractBinFile::~PythonQtShell_abstractBinFile() {
4708 PythonQtPrivate* priv = PythonQt::priv();
4714 PythonQtPrivate* priv = PythonQt::priv();
4709 if (priv) { priv->shellClassDeleted(this); }
4715 if (priv) { priv->shellClassDeleted(this); }
4710 }
4716 }
4711 void PythonQtShell_abstractExecFile::childEvent(QChildEvent* arg__1)
4717 void PythonQtShell_abstractBinFile::childEvent(QChildEvent* arg__1)
4712 {
4718 {
4713 if (_wrapper) {
4719 if (_wrapper) {
4714 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
4720 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
4715 PyErr_Clear();
4721 PyErr_Clear();
4716 if (obj && !PythonQtSlotFunction_Check(obj)) {
4722 if (obj && !PythonQtSlotFunction_Check(obj)) {
4717 static const char* argumentList[] ={"" , "QChildEvent*"};
4723 static const char* argumentList[] ={"" , "QChildEvent*"};
4718 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4724 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4719 void* args[2] = {NULL, (void*)&arg__1};
4725 void* args[2] = {NULL, (void*)&arg__1};
4720 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4726 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4721 if (result) { Py_DECREF(result); }
4727 if (result) { Py_DECREF(result); }
4722 Py_DECREF(obj);
4728 Py_DECREF(obj);
4723 return;
4729 return;
4724 }
4730 }
4725 }
4731 }
4726 abstractExecFile::childEvent(arg__1);
4732 abstractBinFile::childEvent(arg__1);
4727 }
4733 }
4728 int PythonQtShell_abstractExecFile::closeFile()
4734 int PythonQtShell_abstractBinFile::closeFile()
4729 {
4735 {
4730 if (_wrapper) {
4736 if (_wrapper) {
4731 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
4737 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
4732 PyErr_Clear();
4738 PyErr_Clear();
4733 if (obj && !PythonQtSlotFunction_Check(obj)) {
4739 if (obj && !PythonQtSlotFunction_Check(obj)) {
4734 static const char* argumentList[] ={"int"};
4740 static const char* argumentList[] ={"int"};
4735 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4741 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4736 int returnValue;
4742 int returnValue;
4737 void* args[1] = {NULL};
4743 void* args[1] = {NULL};
4738 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4744 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4739 if (result) {
4745 if (result) {
4740 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4746 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4741 if (args[0]!=&returnValue) {
4747 if (args[0]!=&returnValue) {
4742 if (args[0]==NULL) {
4748 if (args[0]==NULL) {
4743 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
4749 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
4744 } else {
4750 } else {
4745 returnValue = *((int*)args[0]);
4751 returnValue = *((int*)args[0]);
4746 }
4752 }
4747 }
4753 }
4748 }
4754 }
4749 if (result) { Py_DECREF(result); }
4755 if (result) { Py_DECREF(result); }
4750 Py_DECREF(obj);
4756 Py_DECREF(obj);
4751 return returnValue;
4757 return returnValue;
4752 }
4758 }
4753 }
4759 }
4754 return int();
4760 return int();
4755 }
4761 }
4756 void PythonQtShell_abstractExecFile::customEvent(QEvent* arg__1)
4762 void PythonQtShell_abstractBinFile::customEvent(QEvent* arg__1)
4757 {
4763 {
4758 if (_wrapper) {
4764 if (_wrapper) {
4759 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
4765 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
4760 PyErr_Clear();
4766 PyErr_Clear();
4761 if (obj && !PythonQtSlotFunction_Check(obj)) {
4767 if (obj && !PythonQtSlotFunction_Check(obj)) {
4762 static const char* argumentList[] ={"" , "QEvent*"};
4768 static const char* argumentList[] ={"" , "QEvent*"};
4763 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4769 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4764 void* args[2] = {NULL, (void*)&arg__1};
4770 void* args[2] = {NULL, (void*)&arg__1};
4765 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4771 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4766 if (result) { Py_DECREF(result); }
4772 if (result) { Py_DECREF(result); }
4767 Py_DECREF(obj);
4773 Py_DECREF(obj);
4768 return;
4774 return;
4769 }
4775 }
4770 }
4776 }
4771 abstractExecFile::customEvent(arg__1);
4777 abstractBinFile::customEvent(arg__1);
4772 }
4778 }
4773 bool PythonQtShell_abstractExecFile::event(QEvent* arg__1)
4779 bool PythonQtShell_abstractBinFile::event(QEvent* arg__1)
4774 {
4780 {
4775 if (_wrapper) {
4781 if (_wrapper) {
4776 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
4782 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
4777 PyErr_Clear();
4783 PyErr_Clear();
4778 if (obj && !PythonQtSlotFunction_Check(obj)) {
4784 if (obj && !PythonQtSlotFunction_Check(obj)) {
4779 static const char* argumentList[] ={"bool" , "QEvent*"};
4785 static const char* argumentList[] ={"bool" , "QEvent*"};
4780 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4786 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4781 bool returnValue;
4787 bool returnValue;
4782 void* args[2] = {NULL, (void*)&arg__1};
4788 void* args[2] = {NULL, (void*)&arg__1};
4783 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4789 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4784 if (result) {
4790 if (result) {
4785 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4791 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4786 if (args[0]!=&returnValue) {
4792 if (args[0]!=&returnValue) {
4787 if (args[0]==NULL) {
4793 if (args[0]==NULL) {
4788 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
4794 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
4789 } else {
4795 } else {
4790 returnValue = *((bool*)args[0]);
4796 returnValue = *((bool*)args[0]);
4791 }
4797 }
4792 }
4798 }
4793 }
4799 }
4794 if (result) { Py_DECREF(result); }
4800 if (result) { Py_DECREF(result); }
4795 Py_DECREF(obj);
4801 Py_DECREF(obj);
4796 return returnValue;
4802 return returnValue;
4797 }
4803 }
4798 }
4804 }
4799 return abstractExecFile::event(arg__1);
4805 return abstractBinFile::event(arg__1);
4800 }
4806 }
4801 bool PythonQtShell_abstractExecFile::eventFilter(QObject* arg__1, QEvent* arg__2)
4807 bool PythonQtShell_abstractBinFile::eventFilter(QObject* arg__1, QEvent* arg__2)
4802 {
4808 {
4803 if (_wrapper) {
4809 if (_wrapper) {
4804 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
4810 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
4805 PyErr_Clear();
4811 PyErr_Clear();
4806 if (obj && !PythonQtSlotFunction_Check(obj)) {
4812 if (obj && !PythonQtSlotFunction_Check(obj)) {
4807 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4813 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4808 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4814 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4809 bool returnValue;
4815 bool returnValue;
4810 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
4816 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
4811 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4817 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4812 if (result) {
4818 if (result) {
4813 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4819 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4814 if (args[0]!=&returnValue) {
4820 if (args[0]!=&returnValue) {
4815 if (args[0]==NULL) {
4821 if (args[0]==NULL) {
4816 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
4822 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
4817 } else {
4823 } else {
4818 returnValue = *((bool*)args[0]);
4824 returnValue = *((bool*)args[0]);
4819 }
4825 }
4820 }
4826 }
4821 }
4827 }
4822 if (result) { Py_DECREF(result); }
4828 if (result) { Py_DECREF(result); }
4823 Py_DECREF(obj);
4829 Py_DECREF(obj);
4824 return returnValue;
4830 return returnValue;
4825 }
4831 }
4826 }
4832 }
4827 return abstractExecFile::eventFilter(arg__1, arg__2);
4833 return abstractBinFile::eventFilter(arg__1, arg__2);
4828 }
4834 }
4829 QList<codeFragment* > PythonQtShell_abstractExecFile::getFragments()
4835 QList<codeFragment* > PythonQtShell_abstractBinFile::getFragments()
4830 {
4836 {
4831 if (_wrapper) {
4837 if (_wrapper) {
4832 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
4838 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
4833 PyErr_Clear();
4839 PyErr_Clear();
4834 if (obj && !PythonQtSlotFunction_Check(obj)) {
4840 if (obj && !PythonQtSlotFunction_Check(obj)) {
4835 static const char* argumentList[] ={"QList<codeFragment* >"};
4841 static const char* argumentList[] ={"QList<codeFragment* >"};
4836 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4842 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4837 QList<codeFragment* > returnValue;
4843 QList<codeFragment* > returnValue;
4838 void* args[1] = {NULL};
4844 void* args[1] = {NULL};
4839 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4845 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4840 if (result) {
4846 if (result) {
4841 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4847 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4842 if (args[0]!=&returnValue) {
4848 if (args[0]!=&returnValue) {
4843 if (args[0]==NULL) {
4849 if (args[0]==NULL) {
4844 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
4850 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
4845 } else {
4851 } else {
4846 returnValue = *((QList<codeFragment* >*)args[0]);
4852 returnValue = *((QList<codeFragment* >*)args[0]);
4847 }
4853 }
4848 }
4854 }
4849 }
4855 }
4850 if (result) { Py_DECREF(result); }
4856 if (result) { Py_DECREF(result); }
4851 Py_DECREF(obj);
4857 Py_DECREF(obj);
4852 return returnValue;
4858 return returnValue;
4853 }
4859 }
4854 }
4860 }
4855 return QList<codeFragment* >();
4861 return QList<codeFragment* >();
4856 }
4862 }
4857 bool PythonQtShell_abstractExecFile::isopened()
4863 bool PythonQtShell_abstractBinFile::isopened()
4858 {
4864 {
4859 if (_wrapper) {
4865 if (_wrapper) {
4860 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
4866 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
4861 PyErr_Clear();
4867 PyErr_Clear();
4862 if (obj && !PythonQtSlotFunction_Check(obj)) {
4868 if (obj && !PythonQtSlotFunction_Check(obj)) {
4863 static const char* argumentList[] ={"bool"};
4869 static const char* argumentList[] ={"bool"};
4864 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4870 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4865 bool returnValue;
4871 bool returnValue;
4866 void* args[1] = {NULL};
4872 void* args[1] = {NULL};
4867 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4873 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4868 if (result) {
4874 if (result) {
4869 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4875 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4870 if (args[0]!=&returnValue) {
4876 if (args[0]!=&returnValue) {
4871 if (args[0]==NULL) {
4877 if (args[0]==NULL) {
4872 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
4878 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
4873 } else {
4879 } else {
4874 returnValue = *((bool*)args[0]);
4880 returnValue = *((bool*)args[0]);
4875 }
4881 }
4876 }
4882 }
4877 }
4883 }
4878 if (result) { Py_DECREF(result); }
4884 if (result) { Py_DECREF(result); }
4879 Py_DECREF(obj);
4885 Py_DECREF(obj);
4880 return returnValue;
4886 return returnValue;
4881 }
4887 }
4882 }
4888 }
4883 return bool();
4889 return bool();
4884 }
4890 }
4885 bool PythonQtShell_abstractExecFile::openFile(const QString& File)
4891 bool PythonQtShell_abstractBinFile::openFile(const QString& File)
4886 {
4892 {
4887 if (_wrapper) {
4893 if (_wrapper) {
4888 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
4894 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
4889 PyErr_Clear();
4895 PyErr_Clear();
4890 if (obj && !PythonQtSlotFunction_Check(obj)) {
4896 if (obj && !PythonQtSlotFunction_Check(obj)) {
4891 static const char* argumentList[] ={"bool" , "const QString&"};
4897 static const char* argumentList[] ={"bool" , "const QString&"};
4892 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4898 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4893 bool returnValue;
4899 bool returnValue;
4894 void* args[2] = {NULL, (void*)&File};
4900 void* args[2] = {NULL, (void*)&File};
4895 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4901 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4896 if (result) {
4902 if (result) {
4897 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4903 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4898 if (args[0]!=&returnValue) {
4904 if (args[0]!=&returnValue) {
4899 if (args[0]==NULL) {
4905 if (args[0]==NULL) {
4900 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
4906 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
4901 } else {
4907 } else {
4902 returnValue = *((bool*)args[0]);
4908 returnValue = *((bool*)args[0]);
4903 }
4909 }
4904 }
4910 }
4905 }
4911 }
4906 if (result) { Py_DECREF(result); }
4912 if (result) { Py_DECREF(result); }
4907 Py_DECREF(obj);
4913 Py_DECREF(obj);
4908 return returnValue;
4914 return returnValue;
4909 }
4915 }
4910 }
4916 }
4911 return bool();
4917 return bool();
4912 }
4918 }
4913 void PythonQtShell_abstractExecFile::timerEvent(QTimerEvent* arg__1)
4919 void PythonQtShell_abstractBinFile::timerEvent(QTimerEvent* arg__1)
4914 {
4920 {
4915 if (_wrapper) {
4921 if (_wrapper) {
4916 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
4922 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
4917 PyErr_Clear();
4923 PyErr_Clear();
4918 if (obj && !PythonQtSlotFunction_Check(obj)) {
4924 if (obj && !PythonQtSlotFunction_Check(obj)) {
4919 static const char* argumentList[] ={"" , "QTimerEvent*"};
4925 static const char* argumentList[] ={"" , "QTimerEvent*"};
4920 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4926 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4921 void* args[2] = {NULL, (void*)&arg__1};
4927 void* args[2] = {NULL, (void*)&arg__1};
4922 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4928 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4923 if (result) { Py_DECREF(result); }
4929 if (result) { Py_DECREF(result); }
4924 Py_DECREF(obj);
4930 Py_DECREF(obj);
4925 return;
4931 return;
4926 }
4932 }
4927 }
4933 }
4928 abstractExecFile::timerEvent(arg__1);
4934 abstractBinFile::timerEvent(arg__1);
4929 }
4935 }
4930 abstractExecFile* PythonQtWrapper_abstractExecFile::new_abstractExecFile()
4936 abstractBinFile* PythonQtWrapper_abstractBinFile::new_abstractBinFile()
4931 {
4937 {
4932 return new PythonQtShell_abstractExecFile(); }
4938 return new PythonQtShell_abstractBinFile(); }
4933
4939
4934
4940
4935
4941
4936 PythonQtShell_codeFragment::~PythonQtShell_codeFragment() {
4942 PythonQtShell_codeFragment::~PythonQtShell_codeFragment() {
4937 PythonQtPrivate* priv = PythonQt::priv();
4943 PythonQtPrivate* priv = PythonQt::priv();
4938 if (priv) { priv->shellClassDeleted(this); }
4944 if (priv) { priv->shellClassDeleted(this); }
4939 }
4945 }
4940 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment()
4946 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment()
4941 {
4947 {
4942 return new PythonQtShell_codeFragment(); }
4948 return new PythonQtShell_codeFragment(); }
4943
4949
4944 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment(char* data, unsigned int size, unsigned int address)
4950 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment(char* data, quint64 size, quint64 address)
4945 {
4951 {
4946 return new PythonQtShell_codeFragment(data, size, address); }
4952 return new PythonQtShell_codeFragment(data, size, address); }
4947
4953
4948
4954
4949
4955
4950 PythonQtShell_elfFileWidget::~PythonQtShell_elfFileWidget() {
4956 PythonQtShell_elfFileWidget::~PythonQtShell_elfFileWidget() {
4951 PythonQtPrivate* priv = PythonQt::priv();
4957 PythonQtPrivate* priv = PythonQt::priv();
4952 if (priv) { priv->shellClassDeleted(this); }
4958 if (priv) { priv->shellClassDeleted(this); }
4953 }
4959 }
4954 void PythonQtShell_elfFileWidget::actionEvent(QActionEvent* arg__1)
4960 void PythonQtShell_elfFileWidget::actionEvent(QActionEvent* arg__1)
4955 {
4961 {
4956 if (_wrapper) {
4962 if (_wrapper) {
4957 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
4963 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
4958 PyErr_Clear();
4964 PyErr_Clear();
4959 if (obj && !PythonQtSlotFunction_Check(obj)) {
4965 if (obj && !PythonQtSlotFunction_Check(obj)) {
4960 static const char* argumentList[] ={"" , "QActionEvent*"};
4966 static const char* argumentList[] ={"" , "QActionEvent*"};
4961 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4967 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4962 void* args[2] = {NULL, (void*)&arg__1};
4968 void* args[2] = {NULL, (void*)&arg__1};
4963 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4969 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4964 if (result) { Py_DECREF(result); }
4970 if (result) { Py_DECREF(result); }
4965 Py_DECREF(obj);
4971 Py_DECREF(obj);
4966 return;
4972 return;
4967 }
4973 }
4968 }
4974 }
4969 elfFileWidget::actionEvent(arg__1);
4975 elfFileWidget::actionEvent(arg__1);
4970 }
4976 }
4971 void PythonQtShell_elfFileWidget::changeEvent(QEvent* arg__1)
4977 void PythonQtShell_elfFileWidget::changeEvent(QEvent* arg__1)
4972 {
4978 {
4973 if (_wrapper) {
4979 if (_wrapper) {
4974 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
4980 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
4975 PyErr_Clear();
4981 PyErr_Clear();
4976 if (obj && !PythonQtSlotFunction_Check(obj)) {
4982 if (obj && !PythonQtSlotFunction_Check(obj)) {
4977 static const char* argumentList[] ={"" , "QEvent*"};
4983 static const char* argumentList[] ={"" , "QEvent*"};
4978 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4984 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4979 void* args[2] = {NULL, (void*)&arg__1};
4985 void* args[2] = {NULL, (void*)&arg__1};
4980 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4986 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4981 if (result) { Py_DECREF(result); }
4987 if (result) { Py_DECREF(result); }
4982 Py_DECREF(obj);
4988 Py_DECREF(obj);
4983 return;
4989 return;
4984 }
4990 }
4985 }
4991 }
4986 elfFileWidget::changeEvent(arg__1);
4992 elfFileWidget::changeEvent(arg__1);
4987 }
4993 }
4988 void PythonQtShell_elfFileWidget::childEvent(QChildEvent* arg__1)
4994 void PythonQtShell_elfFileWidget::childEvent(QChildEvent* arg__1)
4989 {
4995 {
4990 if (_wrapper) {
4996 if (_wrapper) {
4991 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
4997 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
4992 PyErr_Clear();
4998 PyErr_Clear();
4993 if (obj && !PythonQtSlotFunction_Check(obj)) {
4999 if (obj && !PythonQtSlotFunction_Check(obj)) {
4994 static const char* argumentList[] ={"" , "QChildEvent*"};
5000 static const char* argumentList[] ={"" , "QChildEvent*"};
4995 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5001 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4996 void* args[2] = {NULL, (void*)&arg__1};
5002 void* args[2] = {NULL, (void*)&arg__1};
4997 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5003 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4998 if (result) { Py_DECREF(result); }
5004 if (result) { Py_DECREF(result); }
4999 Py_DECREF(obj);
5005 Py_DECREF(obj);
5000 return;
5006 return;
5001 }
5007 }
5002 }
5008 }
5003 elfFileWidget::childEvent(arg__1);
5009 elfFileWidget::childEvent(arg__1);
5004 }
5010 }
5005 void PythonQtShell_elfFileWidget::closeEvent(QCloseEvent* arg__1)
5011 void PythonQtShell_elfFileWidget::closeEvent(QCloseEvent* arg__1)
5006 {
5012 {
5007 if (_wrapper) {
5013 if (_wrapper) {
5008 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
5014 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
5009 PyErr_Clear();
5015 PyErr_Clear();
5010 if (obj && !PythonQtSlotFunction_Check(obj)) {
5016 if (obj && !PythonQtSlotFunction_Check(obj)) {
5011 static const char* argumentList[] ={"" , "QCloseEvent*"};
5017 static const char* argumentList[] ={"" , "QCloseEvent*"};
5012 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5018 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5013 void* args[2] = {NULL, (void*)&arg__1};
5019 void* args[2] = {NULL, (void*)&arg__1};
5014 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5020 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5015 if (result) { Py_DECREF(result); }
5021 if (result) { Py_DECREF(result); }
5016 Py_DECREF(obj);
5022 Py_DECREF(obj);
5017 return;
5023 return;
5018 }
5024 }
5019 }
5025 }
5020 elfFileWidget::closeEvent(arg__1);
5026 elfFileWidget::closeEvent(arg__1);
5021 }
5027 }
5022 void PythonQtShell_elfFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
5028 void PythonQtShell_elfFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
5023 {
5029 {
5024 if (_wrapper) {
5030 if (_wrapper) {
5025 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
5031 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
5026 PyErr_Clear();
5032 PyErr_Clear();
5027 if (obj && !PythonQtSlotFunction_Check(obj)) {
5033 if (obj && !PythonQtSlotFunction_Check(obj)) {
5028 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
5034 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
5029 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5035 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5030 void* args[2] = {NULL, (void*)&arg__1};
5036 void* args[2] = {NULL, (void*)&arg__1};
5031 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5037 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5032 if (result) { Py_DECREF(result); }
5038 if (result) { Py_DECREF(result); }
5033 Py_DECREF(obj);
5039 Py_DECREF(obj);
5034 return;
5040 return;
5035 }
5041 }
5036 }
5042 }
5037 elfFileWidget::contextMenuEvent(arg__1);
5043 elfFileWidget::contextMenuEvent(arg__1);
5038 }
5044 }
5039 void PythonQtShell_elfFileWidget::customEvent(QEvent* arg__1)
5045 void PythonQtShell_elfFileWidget::customEvent(QEvent* arg__1)
5040 {
5046 {
5041 if (_wrapper) {
5047 if (_wrapper) {
5042 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
5048 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
5043 PyErr_Clear();
5049 PyErr_Clear();
5044 if (obj && !PythonQtSlotFunction_Check(obj)) {
5050 if (obj && !PythonQtSlotFunction_Check(obj)) {
5045 static const char* argumentList[] ={"" , "QEvent*"};
5051 static const char* argumentList[] ={"" , "QEvent*"};
5046 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5052 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5047 void* args[2] = {NULL, (void*)&arg__1};
5053 void* args[2] = {NULL, (void*)&arg__1};
5048 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5054 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5049 if (result) { Py_DECREF(result); }
5055 if (result) { Py_DECREF(result); }
5050 Py_DECREF(obj);
5056 Py_DECREF(obj);
5051 return;
5057 return;
5052 }
5058 }
5053 }
5059 }
5054 elfFileWidget::customEvent(arg__1);
5060 elfFileWidget::customEvent(arg__1);
5055 }
5061 }
5056 int PythonQtShell_elfFileWidget::devType() const
5062 int PythonQtShell_elfFileWidget::devType() const
5057 {
5063 {
5058 if (_wrapper) {
5064 if (_wrapper) {
5059 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
5065 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
5060 PyErr_Clear();
5066 PyErr_Clear();
5061 if (obj && !PythonQtSlotFunction_Check(obj)) {
5067 if (obj && !PythonQtSlotFunction_Check(obj)) {
5062 static const char* argumentList[] ={"int"};
5068 static const char* argumentList[] ={"int"};
5063 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5069 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5064 int returnValue;
5070 int returnValue;
5065 void* args[1] = {NULL};
5071 void* args[1] = {NULL};
5066 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5072 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5067 if (result) {
5073 if (result) {
5068 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5074 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5069 if (args[0]!=&returnValue) {
5075 if (args[0]!=&returnValue) {
5070 if (args[0]==NULL) {
5076 if (args[0]==NULL) {
5071 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
5077 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
5072 } else {
5078 } else {
5073 returnValue = *((int*)args[0]);
5079 returnValue = *((int*)args[0]);
5074 }
5080 }
5075 }
5081 }
5076 }
5082 }
5077 if (result) { Py_DECREF(result); }
5083 if (result) { Py_DECREF(result); }
5078 Py_DECREF(obj);
5084 Py_DECREF(obj);
5079 return returnValue;
5085 return returnValue;
5080 }
5086 }
5081 }
5087 }
5082 return elfFileWidget::devType();
5088 return elfFileWidget::devType();
5083 }
5089 }
5084 void PythonQtShell_elfFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
5090 void PythonQtShell_elfFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
5085 {
5091 {
5086 if (_wrapper) {
5092 if (_wrapper) {
5087 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
5093 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
5088 PyErr_Clear();
5094 PyErr_Clear();
5089 if (obj && !PythonQtSlotFunction_Check(obj)) {
5095 if (obj && !PythonQtSlotFunction_Check(obj)) {
5090 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
5096 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
5091 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5097 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5092 void* args[2] = {NULL, (void*)&arg__1};
5098 void* args[2] = {NULL, (void*)&arg__1};
5093 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5099 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5094 if (result) { Py_DECREF(result); }
5100 if (result) { Py_DECREF(result); }
5095 Py_DECREF(obj);
5101 Py_DECREF(obj);
5096 return;
5102 return;
5097 }
5103 }
5098 }
5104 }
5099 elfFileWidget::dragEnterEvent(arg__1);
5105 elfFileWidget::dragEnterEvent(arg__1);
5100 }
5106 }
5101 void PythonQtShell_elfFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
5107 void PythonQtShell_elfFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
5102 {
5108 {
5103 if (_wrapper) {
5109 if (_wrapper) {
5104 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
5110 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
5105 PyErr_Clear();
5111 PyErr_Clear();
5106 if (obj && !PythonQtSlotFunction_Check(obj)) {
5112 if (obj && !PythonQtSlotFunction_Check(obj)) {
5107 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
5113 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
5108 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5114 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5109 void* args[2] = {NULL, (void*)&arg__1};
5115 void* args[2] = {NULL, (void*)&arg__1};
5110 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5116 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5111 if (result) { Py_DECREF(result); }
5117 if (result) { Py_DECREF(result); }
5112 Py_DECREF(obj);
5118 Py_DECREF(obj);
5113 return;
5119 return;
5114 }
5120 }
5115 }
5121 }
5116 elfFileWidget::dragLeaveEvent(arg__1);
5122 elfFileWidget::dragLeaveEvent(arg__1);
5117 }
5123 }
5118 void PythonQtShell_elfFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
5124 void PythonQtShell_elfFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
5119 {
5125 {
5120 if (_wrapper) {
5126 if (_wrapper) {
5121 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
5127 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
5122 PyErr_Clear();
5128 PyErr_Clear();
5123 if (obj && !PythonQtSlotFunction_Check(obj)) {
5129 if (obj && !PythonQtSlotFunction_Check(obj)) {
5124 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
5130 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
5125 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5131 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5126 void* args[2] = {NULL, (void*)&arg__1};
5132 void* args[2] = {NULL, (void*)&arg__1};
5127 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5133 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5128 if (result) { Py_DECREF(result); }
5134 if (result) { Py_DECREF(result); }
5129 Py_DECREF(obj);
5135 Py_DECREF(obj);
5130 return;
5136 return;
5131 }
5137 }
5132 }
5138 }
5133 elfFileWidget::dragMoveEvent(arg__1);
5139 elfFileWidget::dragMoveEvent(arg__1);
5134 }
5140 }
5135 void PythonQtShell_elfFileWidget::dropEvent(QDropEvent* arg__1)
5141 void PythonQtShell_elfFileWidget::dropEvent(QDropEvent* arg__1)
5136 {
5142 {
5137 if (_wrapper) {
5143 if (_wrapper) {
5138 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
5144 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
5139 PyErr_Clear();
5145 PyErr_Clear();
5140 if (obj && !PythonQtSlotFunction_Check(obj)) {
5146 if (obj && !PythonQtSlotFunction_Check(obj)) {
5141 static const char* argumentList[] ={"" , "QDropEvent*"};
5147 static const char* argumentList[] ={"" , "QDropEvent*"};
5142 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5148 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5143 void* args[2] = {NULL, (void*)&arg__1};
5149 void* args[2] = {NULL, (void*)&arg__1};
5144 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5150 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5145 if (result) { Py_DECREF(result); }
5151 if (result) { Py_DECREF(result); }
5146 Py_DECREF(obj);
5152 Py_DECREF(obj);
5147 return;
5153 return;
5148 }
5154 }
5149 }
5155 }
5150 elfFileWidget::dropEvent(arg__1);
5156 elfFileWidget::dropEvent(arg__1);
5151 }
5157 }
5152 void PythonQtShell_elfFileWidget::enterEvent(QEvent* arg__1)
5158 void PythonQtShell_elfFileWidget::enterEvent(QEvent* arg__1)
5153 {
5159 {
5154 if (_wrapper) {
5160 if (_wrapper) {
5155 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
5161 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
5156 PyErr_Clear();
5162 PyErr_Clear();
5157 if (obj && !PythonQtSlotFunction_Check(obj)) {
5163 if (obj && !PythonQtSlotFunction_Check(obj)) {
5158 static const char* argumentList[] ={"" , "QEvent*"};
5164 static const char* argumentList[] ={"" , "QEvent*"};
5159 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5165 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5160 void* args[2] = {NULL, (void*)&arg__1};
5166 void* args[2] = {NULL, (void*)&arg__1};
5161 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5167 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5162 if (result) { Py_DECREF(result); }
5168 if (result) { Py_DECREF(result); }
5163 Py_DECREF(obj);
5169 Py_DECREF(obj);
5164 return;
5170 return;
5165 }
5171 }
5166 }
5172 }
5167 elfFileWidget::enterEvent(arg__1);
5173 elfFileWidget::enterEvent(arg__1);
5168 }
5174 }
5169 bool PythonQtShell_elfFileWidget::event(QEvent* arg__1)
5175 bool PythonQtShell_elfFileWidget::event(QEvent* arg__1)
5170 {
5176 {
5171 if (_wrapper) {
5177 if (_wrapper) {
5172 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
5178 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
5173 PyErr_Clear();
5179 PyErr_Clear();
5174 if (obj && !PythonQtSlotFunction_Check(obj)) {
5180 if (obj && !PythonQtSlotFunction_Check(obj)) {
5175 static const char* argumentList[] ={"bool" , "QEvent*"};
5181 static const char* argumentList[] ={"bool" , "QEvent*"};
5176 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5182 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5177 bool returnValue;
5183 bool returnValue;
5178 void* args[2] = {NULL, (void*)&arg__1};
5184 void* args[2] = {NULL, (void*)&arg__1};
5179 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5185 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5180 if (result) {
5186 if (result) {
5181 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5187 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5182 if (args[0]!=&returnValue) {
5188 if (args[0]!=&returnValue) {
5183 if (args[0]==NULL) {
5189 if (args[0]==NULL) {
5184 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
5190 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
5185 } else {
5191 } else {
5186 returnValue = *((bool*)args[0]);
5192 returnValue = *((bool*)args[0]);
5187 }
5193 }
5188 }
5194 }
5189 }
5195 }
5190 if (result) { Py_DECREF(result); }
5196 if (result) { Py_DECREF(result); }
5191 Py_DECREF(obj);
5197 Py_DECREF(obj);
5192 return returnValue;
5198 return returnValue;
5193 }
5199 }
5194 }
5200 }
5195 return elfFileWidget::event(arg__1);
5201 return elfFileWidget::event(arg__1);
5196 }
5202 }
5197 bool PythonQtShell_elfFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
5203 bool PythonQtShell_elfFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
5198 {
5204 {
5199 if (_wrapper) {
5205 if (_wrapper) {
5200 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
5206 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
5201 PyErr_Clear();
5207 PyErr_Clear();
5202 if (obj && !PythonQtSlotFunction_Check(obj)) {
5208 if (obj && !PythonQtSlotFunction_Check(obj)) {
5203 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5209 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5204 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5210 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5205 bool returnValue;
5211 bool returnValue;
5206 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
5212 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
5207 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5213 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5208 if (result) {
5214 if (result) {
5209 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5215 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5210 if (args[0]!=&returnValue) {
5216 if (args[0]!=&returnValue) {
5211 if (args[0]==NULL) {
5217 if (args[0]==NULL) {
5212 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
5218 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
5213 } else {
5219 } else {
5214 returnValue = *((bool*)args[0]);
5220 returnValue = *((bool*)args[0]);
5215 }
5221 }
5216 }
5222 }
5217 }
5223 }
5218 if (result) { Py_DECREF(result); }
5224 if (result) { Py_DECREF(result); }
5219 Py_DECREF(obj);
5225 Py_DECREF(obj);
5220 return returnValue;
5226 return returnValue;
5221 }
5227 }
5222 }
5228 }
5223 return elfFileWidget::eventFilter(arg__1, arg__2);
5229 return elfFileWidget::eventFilter(arg__1, arg__2);
5224 }
5230 }
5225 void PythonQtShell_elfFileWidget::focusInEvent(QFocusEvent* arg__1)
5231 void PythonQtShell_elfFileWidget::focusInEvent(QFocusEvent* arg__1)
5226 {
5232 {
5227 if (_wrapper) {
5233 if (_wrapper) {
5228 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
5234 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
5229 PyErr_Clear();
5235 PyErr_Clear();
5230 if (obj && !PythonQtSlotFunction_Check(obj)) {
5236 if (obj && !PythonQtSlotFunction_Check(obj)) {
5231 static const char* argumentList[] ={"" , "QFocusEvent*"};
5237 static const char* argumentList[] ={"" , "QFocusEvent*"};
5232 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5238 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5233 void* args[2] = {NULL, (void*)&arg__1};
5239 void* args[2] = {NULL, (void*)&arg__1};
5234 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5240 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5235 if (result) { Py_DECREF(result); }
5241 if (result) { Py_DECREF(result); }
5236 Py_DECREF(obj);
5242 Py_DECREF(obj);
5237 return;
5243 return;
5238 }
5244 }
5239 }
5245 }
5240 elfFileWidget::focusInEvent(arg__1);
5246 elfFileWidget::focusInEvent(arg__1);
5241 }
5247 }
5242 bool PythonQtShell_elfFileWidget::focusNextPrevChild(bool next)
5248 bool PythonQtShell_elfFileWidget::focusNextPrevChild(bool next)
5243 {
5249 {
5244 if (_wrapper) {
5250 if (_wrapper) {
5245 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
5251 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
5246 PyErr_Clear();
5252 PyErr_Clear();
5247 if (obj && !PythonQtSlotFunction_Check(obj)) {
5253 if (obj && !PythonQtSlotFunction_Check(obj)) {
5248 static const char* argumentList[] ={"bool" , "bool"};
5254 static const char* argumentList[] ={"bool" , "bool"};
5249 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5255 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5250 bool returnValue;
5256 bool returnValue;
5251 void* args[2] = {NULL, (void*)&next};
5257 void* args[2] = {NULL, (void*)&next};
5252 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5258 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5253 if (result) {
5259 if (result) {
5254 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5260 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5255 if (args[0]!=&returnValue) {
5261 if (args[0]!=&returnValue) {
5256 if (args[0]==NULL) {
5262 if (args[0]==NULL) {
5257 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
5263 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
5258 } else {
5264 } else {
5259 returnValue = *((bool*)args[0]);
5265 returnValue = *((bool*)args[0]);
5260 }
5266 }
5261 }
5267 }
5262 }
5268 }
5263 if (result) { Py_DECREF(result); }
5269 if (result) { Py_DECREF(result); }
5264 Py_DECREF(obj);
5270 Py_DECREF(obj);
5265 return returnValue;
5271 return returnValue;
5266 }
5272 }
5267 }
5273 }
5268 return elfFileWidget::focusNextPrevChild(next);
5274 return elfFileWidget::focusNextPrevChild(next);
5269 }
5275 }
5270 void PythonQtShell_elfFileWidget::focusOutEvent(QFocusEvent* arg__1)
5276 void PythonQtShell_elfFileWidget::focusOutEvent(QFocusEvent* arg__1)
5271 {
5277 {
5272 if (_wrapper) {
5278 if (_wrapper) {
5273 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
5279 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
5274 PyErr_Clear();
5280 PyErr_Clear();
5275 if (obj && !PythonQtSlotFunction_Check(obj)) {
5281 if (obj && !PythonQtSlotFunction_Check(obj)) {
5276 static const char* argumentList[] ={"" , "QFocusEvent*"};
5282 static const char* argumentList[] ={"" , "QFocusEvent*"};
5277 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5283 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5278 void* args[2] = {NULL, (void*)&arg__1};
5284 void* args[2] = {NULL, (void*)&arg__1};
5279 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5285 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5280 if (result) { Py_DECREF(result); }
5286 if (result) { Py_DECREF(result); }
5281 Py_DECREF(obj);
5287 Py_DECREF(obj);
5282 return;
5288 return;
5283 }
5289 }
5284 }
5290 }
5285 elfFileWidget::focusOutEvent(arg__1);
5291 elfFileWidget::focusOutEvent(arg__1);
5286 }
5292 }
5287 bool PythonQtShell_elfFileWidget::hasHeightForWidth() const
5293 bool PythonQtShell_elfFileWidget::hasHeightForWidth() const
5288 {
5294 {
5289 if (_wrapper) {
5295 if (_wrapper) {
5290 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
5296 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
5291 PyErr_Clear();
5297 PyErr_Clear();
5292 if (obj && !PythonQtSlotFunction_Check(obj)) {
5298 if (obj && !PythonQtSlotFunction_Check(obj)) {
5293 static const char* argumentList[] ={"bool"};
5299 static const char* argumentList[] ={"bool"};
5294 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5300 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5295 bool returnValue;
5301 bool returnValue;
5296 void* args[1] = {NULL};
5302 void* args[1] = {NULL};
5297 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5303 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5298 if (result) {
5304 if (result) {
5299 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5305 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5300 if (args[0]!=&returnValue) {
5306 if (args[0]!=&returnValue) {
5301 if (args[0]==NULL) {
5307 if (args[0]==NULL) {
5302 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
5308 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
5303 } else {
5309 } else {
5304 returnValue = *((bool*)args[0]);
5310 returnValue = *((bool*)args[0]);
5305 }
5311 }
5306 }
5312 }
5307 }
5313 }
5308 if (result) { Py_DECREF(result); }
5314 if (result) { Py_DECREF(result); }
5309 Py_DECREF(obj);
5315 Py_DECREF(obj);
5310 return returnValue;
5316 return returnValue;
5311 }
5317 }
5312 }
5318 }
5313 return elfFileWidget::hasHeightForWidth();
5319 return elfFileWidget::hasHeightForWidth();
5314 }
5320 }
5315 int PythonQtShell_elfFileWidget::heightForWidth(int arg__1) const
5321 int PythonQtShell_elfFileWidget::heightForWidth(int arg__1) const
5316 {
5322 {
5317 if (_wrapper) {
5323 if (_wrapper) {
5318 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
5324 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
5319 PyErr_Clear();
5325 PyErr_Clear();
5320 if (obj && !PythonQtSlotFunction_Check(obj)) {
5326 if (obj && !PythonQtSlotFunction_Check(obj)) {
5321 static const char* argumentList[] ={"int" , "int"};
5327 static const char* argumentList[] ={"int" , "int"};
5322 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5328 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5323 int returnValue;
5329 int returnValue;
5324 void* args[2] = {NULL, (void*)&arg__1};
5330 void* args[2] = {NULL, (void*)&arg__1};
5325 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5331 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5326 if (result) {
5332 if (result) {
5327 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5333 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5328 if (args[0]!=&returnValue) {
5334 if (args[0]!=&returnValue) {
5329 if (args[0]==NULL) {
5335 if (args[0]==NULL) {
5330 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
5336 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
5331 } else {
5337 } else {
5332 returnValue = *((int*)args[0]);
5338 returnValue = *((int*)args[0]);
5333 }
5339 }
5334 }
5340 }
5335 }
5341 }
5336 if (result) { Py_DECREF(result); }
5342 if (result) { Py_DECREF(result); }
5337 Py_DECREF(obj);
5343 Py_DECREF(obj);
5338 return returnValue;
5344 return returnValue;
5339 }
5345 }
5340 }
5346 }
5341 return elfFileWidget::heightForWidth(arg__1);
5347 return elfFileWidget::heightForWidth(arg__1);
5342 }
5348 }
5343 void PythonQtShell_elfFileWidget::hideEvent(QHideEvent* arg__1)
5349 void PythonQtShell_elfFileWidget::hideEvent(QHideEvent* arg__1)
5344 {
5350 {
5345 if (_wrapper) {
5351 if (_wrapper) {
5346 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
5352 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
5347 PyErr_Clear();
5353 PyErr_Clear();
5348 if (obj && !PythonQtSlotFunction_Check(obj)) {
5354 if (obj && !PythonQtSlotFunction_Check(obj)) {
5349 static const char* argumentList[] ={"" , "QHideEvent*"};
5355 static const char* argumentList[] ={"" , "QHideEvent*"};
5350 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5356 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5351 void* args[2] = {NULL, (void*)&arg__1};
5357 void* args[2] = {NULL, (void*)&arg__1};
5352 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5358 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5353 if (result) { Py_DECREF(result); }
5359 if (result) { Py_DECREF(result); }
5354 Py_DECREF(obj);
5360 Py_DECREF(obj);
5355 return;
5361 return;
5356 }
5362 }
5357 }
5363 }
5358 elfFileWidget::hideEvent(arg__1);
5364 elfFileWidget::hideEvent(arg__1);
5359 }
5365 }
5360 void PythonQtShell_elfFileWidget::initPainter(QPainter* painter) const
5366 void PythonQtShell_elfFileWidget::initPainter(QPainter* painter) const
5361 {
5367 {
5362 if (_wrapper) {
5368 if (_wrapper) {
5363 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
5369 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
5364 PyErr_Clear();
5370 PyErr_Clear();
5365 if (obj && !PythonQtSlotFunction_Check(obj)) {
5371 if (obj && !PythonQtSlotFunction_Check(obj)) {
5366 static const char* argumentList[] ={"" , "QPainter*"};
5372 static const char* argumentList[] ={"" , "QPainter*"};
5367 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5373 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5368 void* args[2] = {NULL, (void*)&painter};
5374 void* args[2] = {NULL, (void*)&painter};
5369 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5375 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5370 if (result) { Py_DECREF(result); }
5376 if (result) { Py_DECREF(result); }
5371 Py_DECREF(obj);
5377 Py_DECREF(obj);
5372 return;
5378 return;
5373 }
5379 }
5374 }
5380 }
5375 elfFileWidget::initPainter(painter);
5381 elfFileWidget::initPainter(painter);
5376 }
5382 }
5377 void PythonQtShell_elfFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
5383 void PythonQtShell_elfFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
5378 {
5384 {
5379 if (_wrapper) {
5385 if (_wrapper) {
5380 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
5386 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
5381 PyErr_Clear();
5387 PyErr_Clear();
5382 if (obj && !PythonQtSlotFunction_Check(obj)) {
5388 if (obj && !PythonQtSlotFunction_Check(obj)) {
5383 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
5389 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
5384 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5390 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5385 void* args[2] = {NULL, (void*)&arg__1};
5391 void* args[2] = {NULL, (void*)&arg__1};
5386 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5392 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5387 if (result) { Py_DECREF(result); }
5393 if (result) { Py_DECREF(result); }
5388 Py_DECREF(obj);
5394 Py_DECREF(obj);
5389 return;
5395 return;
5390 }
5396 }
5391 }
5397 }
5392 elfFileWidget::inputMethodEvent(arg__1);
5398 elfFileWidget::inputMethodEvent(arg__1);
5393 }
5399 }
5394 QVariant PythonQtShell_elfFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
5400 QVariant PythonQtShell_elfFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
5395 {
5401 {
5396 if (_wrapper) {
5402 if (_wrapper) {
5397 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
5403 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
5398 PyErr_Clear();
5404 PyErr_Clear();
5399 if (obj && !PythonQtSlotFunction_Check(obj)) {
5405 if (obj && !PythonQtSlotFunction_Check(obj)) {
5400 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
5406 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
5401 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5407 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5402 QVariant returnValue;
5408 QVariant returnValue;
5403 void* args[2] = {NULL, (void*)&arg__1};
5409 void* args[2] = {NULL, (void*)&arg__1};
5404 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5410 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5405 if (result) {
5411 if (result) {
5406 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5412 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5407 if (args[0]!=&returnValue) {
5413 if (args[0]!=&returnValue) {
5408 if (args[0]==NULL) {
5414 if (args[0]==NULL) {
5409 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
5415 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
5410 } else {
5416 } else {
5411 returnValue = *((QVariant*)args[0]);
5417 returnValue = *((QVariant*)args[0]);
5412 }
5418 }
5413 }
5419 }
5414 }
5420 }
5415 if (result) { Py_DECREF(result); }
5421 if (result) { Py_DECREF(result); }
5416 Py_DECREF(obj);
5422 Py_DECREF(obj);
5417 return returnValue;
5423 return returnValue;
5418 }
5424 }
5419 }
5425 }
5420 return elfFileWidget::inputMethodQuery(arg__1);
5426 return elfFileWidget::inputMethodQuery(arg__1);
5421 }
5427 }
5422 void PythonQtShell_elfFileWidget::keyPressEvent(QKeyEvent* arg__1)
5428 void PythonQtShell_elfFileWidget::keyPressEvent(QKeyEvent* arg__1)
5423 {
5429 {
5424 if (_wrapper) {
5430 if (_wrapper) {
5425 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
5431 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
5426 PyErr_Clear();
5432 PyErr_Clear();
5427 if (obj && !PythonQtSlotFunction_Check(obj)) {
5433 if (obj && !PythonQtSlotFunction_Check(obj)) {
5428 static const char* argumentList[] ={"" , "QKeyEvent*"};
5434 static const char* argumentList[] ={"" , "QKeyEvent*"};
5429 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5435 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5430 void* args[2] = {NULL, (void*)&arg__1};
5436 void* args[2] = {NULL, (void*)&arg__1};
5431 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5437 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5432 if (result) { Py_DECREF(result); }
5438 if (result) { Py_DECREF(result); }
5433 Py_DECREF(obj);
5439 Py_DECREF(obj);
5434 return;
5440 return;
5435 }
5441 }
5436 }
5442 }
5437 elfFileWidget::keyPressEvent(arg__1);
5443 elfFileWidget::keyPressEvent(arg__1);
5438 }
5444 }
5439 void PythonQtShell_elfFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
5445 void PythonQtShell_elfFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
5440 {
5446 {
5441 if (_wrapper) {
5447 if (_wrapper) {
5442 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
5448 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
5443 PyErr_Clear();
5449 PyErr_Clear();
5444 if (obj && !PythonQtSlotFunction_Check(obj)) {
5450 if (obj && !PythonQtSlotFunction_Check(obj)) {
5445 static const char* argumentList[] ={"" , "QKeyEvent*"};
5451 static const char* argumentList[] ={"" , "QKeyEvent*"};
5446 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5452 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5447 void* args[2] = {NULL, (void*)&arg__1};
5453 void* args[2] = {NULL, (void*)&arg__1};
5448 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5454 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5449 if (result) { Py_DECREF(result); }
5455 if (result) { Py_DECREF(result); }
5450 Py_DECREF(obj);
5456 Py_DECREF(obj);
5451 return;
5457 return;
5452 }
5458 }
5453 }
5459 }
5454 elfFileWidget::keyReleaseEvent(arg__1);
5460 elfFileWidget::keyReleaseEvent(arg__1);
5455 }
5461 }
5456 void PythonQtShell_elfFileWidget::leaveEvent(QEvent* arg__1)
5462 void PythonQtShell_elfFileWidget::leaveEvent(QEvent* arg__1)
5457 {
5463 {
5458 if (_wrapper) {
5464 if (_wrapper) {
5459 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
5465 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
5460 PyErr_Clear();
5466 PyErr_Clear();
5461 if (obj && !PythonQtSlotFunction_Check(obj)) {
5467 if (obj && !PythonQtSlotFunction_Check(obj)) {
5462 static const char* argumentList[] ={"" , "QEvent*"};
5468 static const char* argumentList[] ={"" , "QEvent*"};
5463 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5469 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5464 void* args[2] = {NULL, (void*)&arg__1};
5470 void* args[2] = {NULL, (void*)&arg__1};
5465 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5471 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5466 if (result) { Py_DECREF(result); }
5472 if (result) { Py_DECREF(result); }
5467 Py_DECREF(obj);
5473 Py_DECREF(obj);
5468 return;
5474 return;
5469 }
5475 }
5470 }
5476 }
5471 elfFileWidget::leaveEvent(arg__1);
5477 elfFileWidget::leaveEvent(arg__1);
5472 }
5478 }
5473 int PythonQtShell_elfFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
5479 int PythonQtShell_elfFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
5474 {
5480 {
5475 if (_wrapper) {
5481 if (_wrapper) {
5476 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
5482 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
5477 PyErr_Clear();
5483 PyErr_Clear();
5478 if (obj && !PythonQtSlotFunction_Check(obj)) {
5484 if (obj && !PythonQtSlotFunction_Check(obj)) {
5479 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
5485 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
5480 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5486 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5481 int returnValue;
5487 int returnValue;
5482 void* args[2] = {NULL, (void*)&arg__1};
5488 void* args[2] = {NULL, (void*)&arg__1};
5483 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5489 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5484 if (result) {
5490 if (result) {
5485 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5491 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5486 if (args[0]!=&returnValue) {
5492 if (args[0]!=&returnValue) {
5487 if (args[0]==NULL) {
5493 if (args[0]==NULL) {
5488 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
5494 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
5489 } else {
5495 } else {
5490 returnValue = *((int*)args[0]);
5496 returnValue = *((int*)args[0]);
5491 }
5497 }
5492 }
5498 }
5493 }
5499 }
5494 if (result) { Py_DECREF(result); }
5500 if (result) { Py_DECREF(result); }
5495 Py_DECREF(obj);
5501 Py_DECREF(obj);
5496 return returnValue;
5502 return returnValue;
5497 }
5503 }
5498 }
5504 }
5499 return elfFileWidget::metric(arg__1);
5505 return elfFileWidget::metric(arg__1);
5500 }
5506 }
5501 QSize PythonQtShell_elfFileWidget::minimumSizeHint() const
5507 QSize PythonQtShell_elfFileWidget::minimumSizeHint() const
5502 {
5508 {
5503 if (_wrapper) {
5509 if (_wrapper) {
5504 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
5510 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
5505 PyErr_Clear();
5511 PyErr_Clear();
5506 if (obj && !PythonQtSlotFunction_Check(obj)) {
5512 if (obj && !PythonQtSlotFunction_Check(obj)) {
5507 static const char* argumentList[] ={"QSize"};
5513 static const char* argumentList[] ={"QSize"};
5508 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5514 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5509 QSize returnValue;
5515 QSize returnValue;
5510 void* args[1] = {NULL};
5516 void* args[1] = {NULL};
5511 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5517 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5512 if (result) {
5518 if (result) {
5513 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5519 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5514 if (args[0]!=&returnValue) {
5520 if (args[0]!=&returnValue) {
5515 if (args[0]==NULL) {
5521 if (args[0]==NULL) {
5516 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
5522 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
5517 } else {
5523 } else {
5518 returnValue = *((QSize*)args[0]);
5524 returnValue = *((QSize*)args[0]);
5519 }
5525 }
5520 }
5526 }
5521 }
5527 }
5522 if (result) { Py_DECREF(result); }
5528 if (result) { Py_DECREF(result); }
5523 Py_DECREF(obj);
5529 Py_DECREF(obj);
5524 return returnValue;
5530 return returnValue;
5525 }
5531 }
5526 }
5532 }
5527 return elfFileWidget::minimumSizeHint();
5533 return elfFileWidget::minimumSizeHint();
5528 }
5534 }
5529 void PythonQtShell_elfFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
5535 void PythonQtShell_elfFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
5530 {
5536 {
5531 if (_wrapper) {
5537 if (_wrapper) {
5532 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
5538 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
5533 PyErr_Clear();
5539 PyErr_Clear();
5534 if (obj && !PythonQtSlotFunction_Check(obj)) {
5540 if (obj && !PythonQtSlotFunction_Check(obj)) {
5535 static const char* argumentList[] ={"" , "QMouseEvent*"};
5541 static const char* argumentList[] ={"" , "QMouseEvent*"};
5536 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5542 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5537 void* args[2] = {NULL, (void*)&arg__1};
5543 void* args[2] = {NULL, (void*)&arg__1};
5538 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5544 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5539 if (result) { Py_DECREF(result); }
5545 if (result) { Py_DECREF(result); }
5540 Py_DECREF(obj);
5546 Py_DECREF(obj);
5541 return;
5547 return;
5542 }
5548 }
5543 }
5549 }
5544 elfFileWidget::mouseDoubleClickEvent(arg__1);
5550 elfFileWidget::mouseDoubleClickEvent(arg__1);
5545 }
5551 }
5546 void PythonQtShell_elfFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
5552 void PythonQtShell_elfFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
5547 {
5553 {
5548 if (_wrapper) {
5554 if (_wrapper) {
5549 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
5555 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
5550 PyErr_Clear();
5556 PyErr_Clear();
5551 if (obj && !PythonQtSlotFunction_Check(obj)) {
5557 if (obj && !PythonQtSlotFunction_Check(obj)) {
5552 static const char* argumentList[] ={"" , "QMouseEvent*"};
5558 static const char* argumentList[] ={"" , "QMouseEvent*"};
5553 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5559 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5554 void* args[2] = {NULL, (void*)&arg__1};
5560 void* args[2] = {NULL, (void*)&arg__1};
5555 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5561 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5556 if (result) { Py_DECREF(result); }
5562 if (result) { Py_DECREF(result); }
5557 Py_DECREF(obj);
5563 Py_DECREF(obj);
5558 return;
5564 return;
5559 }
5565 }
5560 }
5566 }
5561 elfFileWidget::mouseMoveEvent(arg__1);
5567 elfFileWidget::mouseMoveEvent(arg__1);
5562 }
5568 }
5563 void PythonQtShell_elfFileWidget::mousePressEvent(QMouseEvent* arg__1)
5569 void PythonQtShell_elfFileWidget::mousePressEvent(QMouseEvent* arg__1)
5564 {
5570 {
5565 if (_wrapper) {
5571 if (_wrapper) {
5566 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
5572 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
5567 PyErr_Clear();
5573 PyErr_Clear();
5568 if (obj && !PythonQtSlotFunction_Check(obj)) {
5574 if (obj && !PythonQtSlotFunction_Check(obj)) {
5569 static const char* argumentList[] ={"" , "QMouseEvent*"};
5575 static const char* argumentList[] ={"" , "QMouseEvent*"};
5570 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5576 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5571 void* args[2] = {NULL, (void*)&arg__1};
5577 void* args[2] = {NULL, (void*)&arg__1};
5572 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5578 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5573 if (result) { Py_DECREF(result); }
5579 if (result) { Py_DECREF(result); }
5574 Py_DECREF(obj);
5580 Py_DECREF(obj);
5575 return;
5581 return;
5576 }
5582 }
5577 }
5583 }
5578 elfFileWidget::mousePressEvent(arg__1);
5584 elfFileWidget::mousePressEvent(arg__1);
5579 }
5585 }
5580 void PythonQtShell_elfFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
5586 void PythonQtShell_elfFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
5581 {
5587 {
5582 if (_wrapper) {
5588 if (_wrapper) {
5583 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
5589 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
5584 PyErr_Clear();
5590 PyErr_Clear();
5585 if (obj && !PythonQtSlotFunction_Check(obj)) {
5591 if (obj && !PythonQtSlotFunction_Check(obj)) {
5586 static const char* argumentList[] ={"" , "QMouseEvent*"};
5592 static const char* argumentList[] ={"" , "QMouseEvent*"};
5587 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5593 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5588 void* args[2] = {NULL, (void*)&arg__1};
5594 void* args[2] = {NULL, (void*)&arg__1};
5589 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5595 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5590 if (result) { Py_DECREF(result); }
5596 if (result) { Py_DECREF(result); }
5591 Py_DECREF(obj);
5597 Py_DECREF(obj);
5592 return;
5598 return;
5593 }
5599 }
5594 }
5600 }
5595 elfFileWidget::mouseReleaseEvent(arg__1);
5601 elfFileWidget::mouseReleaseEvent(arg__1);
5596 }
5602 }
5597 void PythonQtShell_elfFileWidget::moveEvent(QMoveEvent* arg__1)
5603 void PythonQtShell_elfFileWidget::moveEvent(QMoveEvent* arg__1)
5598 {
5604 {
5599 if (_wrapper) {
5605 if (_wrapper) {
5600 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
5606 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
5601 PyErr_Clear();
5607 PyErr_Clear();
5602 if (obj && !PythonQtSlotFunction_Check(obj)) {
5608 if (obj && !PythonQtSlotFunction_Check(obj)) {
5603 static const char* argumentList[] ={"" , "QMoveEvent*"};
5609 static const char* argumentList[] ={"" , "QMoveEvent*"};
5604 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5610 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5605 void* args[2] = {NULL, (void*)&arg__1};
5611 void* args[2] = {NULL, (void*)&arg__1};
5606 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5612 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5607 if (result) { Py_DECREF(result); }
5613 if (result) { Py_DECREF(result); }
5608 Py_DECREF(obj);
5614 Py_DECREF(obj);
5609 return;
5615 return;
5610 }
5616 }
5611 }
5617 }
5612 elfFileWidget::moveEvent(arg__1);
5618 elfFileWidget::moveEvent(arg__1);
5613 }
5619 }
5614 bool PythonQtShell_elfFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result)
5620 bool PythonQtShell_elfFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result)
5615 {
5621 {
5616 if (_wrapper) {
5622 if (_wrapper) {
5617 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
5623 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
5618 PyErr_Clear();
5624 PyErr_Clear();
5619 if (obj && !PythonQtSlotFunction_Check(obj)) {
5625 if (obj && !PythonQtSlotFunction_Check(obj)) {
5620 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
5626 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
5621 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
5627 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
5622 bool returnValue;
5628 bool returnValue;
5623 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
5629 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
5624 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5630 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5625 if (result) {
5631 if (result) {
5626 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5632 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5627 if (args[0]!=&returnValue) {
5633 if (args[0]!=&returnValue) {
5628 if (args[0]==NULL) {
5634 if (args[0]==NULL) {
5629 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
5635 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
5630 } else {
5636 } else {
5631 returnValue = *((bool*)args[0]);
5637 returnValue = *((bool*)args[0]);
5632 }
5638 }
5633 }
5639 }
5634 }
5640 }
5635 if (result) { Py_DECREF(result); }
5641 if (result) { Py_DECREF(result); }
5636 Py_DECREF(obj);
5642 Py_DECREF(obj);
5637 return returnValue;
5643 return returnValue;
5638 }
5644 }
5639 }
5645 }
5640 return elfFileWidget::nativeEvent(eventType, message, result);
5646 return elfFileWidget::nativeEvent(eventType, message, result);
5641 }
5647 }
5642 QPaintEngine* PythonQtShell_elfFileWidget::paintEngine() const
5648 QPaintEngine* PythonQtShell_elfFileWidget::paintEngine() const
5643 {
5649 {
5644 if (_wrapper) {
5650 if (_wrapper) {
5645 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
5651 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
5646 PyErr_Clear();
5652 PyErr_Clear();
5647 if (obj && !PythonQtSlotFunction_Check(obj)) {
5653 if (obj && !PythonQtSlotFunction_Check(obj)) {
5648 static const char* argumentList[] ={"QPaintEngine*"};
5654 static const char* argumentList[] ={"QPaintEngine*"};
5649 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5655 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5650 QPaintEngine* returnValue;
5656 QPaintEngine* returnValue;
5651 void* args[1] = {NULL};
5657 void* args[1] = {NULL};
5652 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5658 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5653 if (result) {
5659 if (result) {
5654 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5660 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5655 if (args[0]!=&returnValue) {
5661 if (args[0]!=&returnValue) {
5656 if (args[0]==NULL) {
5662 if (args[0]==NULL) {
5657 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
5663 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
5658 } else {
5664 } else {
5659 returnValue = *((QPaintEngine**)args[0]);
5665 returnValue = *((QPaintEngine**)args[0]);
5660 }
5666 }
5661 }
5667 }
5662 }
5668 }
5663 if (result) { Py_DECREF(result); }
5669 if (result) { Py_DECREF(result); }
5664 Py_DECREF(obj);
5670 Py_DECREF(obj);
5665 return returnValue;
5671 return returnValue;
5666 }
5672 }
5667 }
5673 }
5668 return elfFileWidget::paintEngine();
5674 return elfFileWidget::paintEngine();
5669 }
5675 }
5670 void PythonQtShell_elfFileWidget::paintEvent(QPaintEvent* arg__1)
5676 void PythonQtShell_elfFileWidget::paintEvent(QPaintEvent* arg__1)
5671 {
5677 {
5672 if (_wrapper) {
5678 if (_wrapper) {
5673 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
5679 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
5674 PyErr_Clear();
5680 PyErr_Clear();
5675 if (obj && !PythonQtSlotFunction_Check(obj)) {
5681 if (obj && !PythonQtSlotFunction_Check(obj)) {
5676 static const char* argumentList[] ={"" , "QPaintEvent*"};
5682 static const char* argumentList[] ={"" , "QPaintEvent*"};
5677 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5683 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5678 void* args[2] = {NULL, (void*)&arg__1};
5684 void* args[2] = {NULL, (void*)&arg__1};
5679 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5685 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5680 if (result) { Py_DECREF(result); }
5686 if (result) { Py_DECREF(result); }
5681 Py_DECREF(obj);
5687 Py_DECREF(obj);
5682 return;
5688 return;
5683 }
5689 }
5684 }
5690 }
5685 elfFileWidget::paintEvent(arg__1);
5691 elfFileWidget::paintEvent(arg__1);
5686 }
5692 }
5687 QPaintDevice* PythonQtShell_elfFileWidget::redirected(QPoint* offset) const
5693 QPaintDevice* PythonQtShell_elfFileWidget::redirected(QPoint* offset) const
5688 {
5694 {
5689 if (_wrapper) {
5695 if (_wrapper) {
5690 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
5696 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
5691 PyErr_Clear();
5697 PyErr_Clear();
5692 if (obj && !PythonQtSlotFunction_Check(obj)) {
5698 if (obj && !PythonQtSlotFunction_Check(obj)) {
5693 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
5699 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
5694 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5700 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5695 QPaintDevice* returnValue;
5701 QPaintDevice* returnValue;
5696 void* args[2] = {NULL, (void*)&offset};
5702 void* args[2] = {NULL, (void*)&offset};
5697 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5703 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5698 if (result) {
5704 if (result) {
5699 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5705 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5700 if (args[0]!=&returnValue) {
5706 if (args[0]!=&returnValue) {
5701 if (args[0]==NULL) {
5707 if (args[0]==NULL) {
5702 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
5708 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
5703 } else {
5709 } else {
5704 returnValue = *((QPaintDevice**)args[0]);
5710 returnValue = *((QPaintDevice**)args[0]);
5705 }
5711 }
5706 }
5712 }
5707 }
5713 }
5708 if (result) { Py_DECREF(result); }
5714 if (result) { Py_DECREF(result); }
5709 Py_DECREF(obj);
5715 Py_DECREF(obj);
5710 return returnValue;
5716 return returnValue;
5711 }
5717 }
5712 }
5718 }
5713 return elfFileWidget::redirected(offset);
5719 return elfFileWidget::redirected(offset);
5714 }
5720 }
5715 void PythonQtShell_elfFileWidget::resizeEvent(QResizeEvent* arg__1)
5721 void PythonQtShell_elfFileWidget::resizeEvent(QResizeEvent* arg__1)
5716 {
5722 {
5717 if (_wrapper) {
5723 if (_wrapper) {
5718 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
5724 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
5719 PyErr_Clear();
5725 PyErr_Clear();
5720 if (obj && !PythonQtSlotFunction_Check(obj)) {
5726 if (obj && !PythonQtSlotFunction_Check(obj)) {
5721 static const char* argumentList[] ={"" , "QResizeEvent*"};
5727 static const char* argumentList[] ={"" , "QResizeEvent*"};
5722 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5728 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5723 void* args[2] = {NULL, (void*)&arg__1};
5729 void* args[2] = {NULL, (void*)&arg__1};
5724 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5730 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5725 if (result) { Py_DECREF(result); }
5731 if (result) { Py_DECREF(result); }
5726 Py_DECREF(obj);
5732 Py_DECREF(obj);
5727 return;
5733 return;
5728 }
5734 }
5729 }
5735 }
5730 elfFileWidget::resizeEvent(arg__1);
5736 elfFileWidget::resizeEvent(arg__1);
5731 }
5737 }
5732 QPainter* PythonQtShell_elfFileWidget::sharedPainter() const
5738 QPainter* PythonQtShell_elfFileWidget::sharedPainter() const
5733 {
5739 {
5734 if (_wrapper) {
5740 if (_wrapper) {
5735 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
5741 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
5736 PyErr_Clear();
5742 PyErr_Clear();
5737 if (obj && !PythonQtSlotFunction_Check(obj)) {
5743 if (obj && !PythonQtSlotFunction_Check(obj)) {
5738 static const char* argumentList[] ={"QPainter*"};
5744 static const char* argumentList[] ={"QPainter*"};
5739 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5745 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5740 QPainter* returnValue;
5746 QPainter* returnValue;
5741 void* args[1] = {NULL};
5747 void* args[1] = {NULL};
5742 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5748 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5743 if (result) {
5749 if (result) {
5744 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5750 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5745 if (args[0]!=&returnValue) {
5751 if (args[0]!=&returnValue) {
5746 if (args[0]==NULL) {
5752 if (args[0]==NULL) {
5747 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
5753 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
5748 } else {
5754 } else {
5749 returnValue = *((QPainter**)args[0]);
5755 returnValue = *((QPainter**)args[0]);
5750 }
5756 }
5751 }
5757 }
5752 }
5758 }
5753 if (result) { Py_DECREF(result); }
5759 if (result) { Py_DECREF(result); }
5754 Py_DECREF(obj);
5760 Py_DECREF(obj);
5755 return returnValue;
5761 return returnValue;
5756 }
5762 }
5757 }
5763 }
5758 return elfFileWidget::sharedPainter();
5764 return elfFileWidget::sharedPainter();
5759 }
5765 }
5760 void PythonQtShell_elfFileWidget::showEvent(QShowEvent* arg__1)
5766 void PythonQtShell_elfFileWidget::showEvent(QShowEvent* arg__1)
5761 {
5767 {
5762 if (_wrapper) {
5768 if (_wrapper) {
5763 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
5769 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
5764 PyErr_Clear();
5770 PyErr_Clear();
5765 if (obj && !PythonQtSlotFunction_Check(obj)) {
5771 if (obj && !PythonQtSlotFunction_Check(obj)) {
5766 static const char* argumentList[] ={"" , "QShowEvent*"};
5772 static const char* argumentList[] ={"" , "QShowEvent*"};
5767 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5773 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5768 void* args[2] = {NULL, (void*)&arg__1};
5774 void* args[2] = {NULL, (void*)&arg__1};
5769 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5775 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5770 if (result) { Py_DECREF(result); }
5776 if (result) { Py_DECREF(result); }
5771 Py_DECREF(obj);
5777 Py_DECREF(obj);
5772 return;
5778 return;
5773 }
5779 }
5774 }
5780 }
5775 elfFileWidget::showEvent(arg__1);
5781 elfFileWidget::showEvent(arg__1);
5776 }
5782 }
5777 QSize PythonQtShell_elfFileWidget::sizeHint() const
5783 QSize PythonQtShell_elfFileWidget::sizeHint() const
5778 {
5784 {
5779 if (_wrapper) {
5785 if (_wrapper) {
5780 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
5786 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
5781 PyErr_Clear();
5787 PyErr_Clear();
5782 if (obj && !PythonQtSlotFunction_Check(obj)) {
5788 if (obj && !PythonQtSlotFunction_Check(obj)) {
5783 static const char* argumentList[] ={"QSize"};
5789 static const char* argumentList[] ={"QSize"};
5784 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5790 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5785 QSize returnValue;
5791 QSize returnValue;
5786 void* args[1] = {NULL};
5792 void* args[1] = {NULL};
5787 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5793 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5788 if (result) {
5794 if (result) {
5789 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5795 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5790 if (args[0]!=&returnValue) {
5796 if (args[0]!=&returnValue) {
5791 if (args[0]==NULL) {
5797 if (args[0]==NULL) {
5792 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
5798 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
5793 } else {
5799 } else {
5794 returnValue = *((QSize*)args[0]);
5800 returnValue = *((QSize*)args[0]);
5795 }
5801 }
5796 }
5802 }
5797 }
5803 }
5798 if (result) { Py_DECREF(result); }
5804 if (result) { Py_DECREF(result); }
5799 Py_DECREF(obj);
5805 Py_DECREF(obj);
5800 return returnValue;
5806 return returnValue;
5801 }
5807 }
5802 }
5808 }
5803 return elfFileWidget::sizeHint();
5809 return elfFileWidget::sizeHint();
5804 }
5810 }
5805 void PythonQtShell_elfFileWidget::tabletEvent(QTabletEvent* arg__1)
5811 void PythonQtShell_elfFileWidget::tabletEvent(QTabletEvent* arg__1)
5806 {
5812 {
5807 if (_wrapper) {
5813 if (_wrapper) {
5808 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
5814 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
5809 PyErr_Clear();
5815 PyErr_Clear();
5810 if (obj && !PythonQtSlotFunction_Check(obj)) {
5816 if (obj && !PythonQtSlotFunction_Check(obj)) {
5811 static const char* argumentList[] ={"" , "QTabletEvent*"};
5817 static const char* argumentList[] ={"" , "QTabletEvent*"};
5812 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5818 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5813 void* args[2] = {NULL, (void*)&arg__1};
5819 void* args[2] = {NULL, (void*)&arg__1};
5814 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5820 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5815 if (result) { Py_DECREF(result); }
5821 if (result) { Py_DECREF(result); }
5816 Py_DECREF(obj);
5822 Py_DECREF(obj);
5817 return;
5823 return;
5818 }
5824 }
5819 }
5825 }
5820 elfFileWidget::tabletEvent(arg__1);
5826 elfFileWidget::tabletEvent(arg__1);
5821 }
5827 }
5822 void PythonQtShell_elfFileWidget::timerEvent(QTimerEvent* arg__1)
5828 void PythonQtShell_elfFileWidget::timerEvent(QTimerEvent* arg__1)
5823 {
5829 {
5824 if (_wrapper) {
5830 if (_wrapper) {
5825 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
5831 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
5826 PyErr_Clear();
5832 PyErr_Clear();
5827 if (obj && !PythonQtSlotFunction_Check(obj)) {
5833 if (obj && !PythonQtSlotFunction_Check(obj)) {
5828 static const char* argumentList[] ={"" , "QTimerEvent*"};
5834 static const char* argumentList[] ={"" , "QTimerEvent*"};
5829 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5835 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5830 void* args[2] = {NULL, (void*)&arg__1};
5836 void* args[2] = {NULL, (void*)&arg__1};
5831 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5837 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5832 if (result) { Py_DECREF(result); }
5838 if (result) { Py_DECREF(result); }
5833 Py_DECREF(obj);
5839 Py_DECREF(obj);
5834 return;
5840 return;
5835 }
5841 }
5836 }
5842 }
5837 elfFileWidget::timerEvent(arg__1);
5843 elfFileWidget::timerEvent(arg__1);
5838 }
5844 }
5839 void PythonQtShell_elfFileWidget::wheelEvent(QWheelEvent* arg__1)
5845 void PythonQtShell_elfFileWidget::wheelEvent(QWheelEvent* arg__1)
5840 {
5846 {
5841 if (_wrapper) {
5847 if (_wrapper) {
5842 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
5848 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
5843 PyErr_Clear();
5849 PyErr_Clear();
5844 if (obj && !PythonQtSlotFunction_Check(obj)) {
5850 if (obj && !PythonQtSlotFunction_Check(obj)) {
5845 static const char* argumentList[] ={"" , "QWheelEvent*"};
5851 static const char* argumentList[] ={"" , "QWheelEvent*"};
5846 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5852 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5847 void* args[2] = {NULL, (void*)&arg__1};
5853 void* args[2] = {NULL, (void*)&arg__1};
5848 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5854 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5849 if (result) { Py_DECREF(result); }
5855 if (result) { Py_DECREF(result); }
5850 Py_DECREF(obj);
5856 Py_DECREF(obj);
5851 return;
5857 return;
5852 }
5858 }
5853 }
5859 }
5854 elfFileWidget::wheelEvent(arg__1);
5860 elfFileWidget::wheelEvent(arg__1);
5855 }
5861 }
5856 elfFileWidget* PythonQtWrapper_elfFileWidget::new_elfFileWidget(QWidget* parent)
5862 elfFileWidget* PythonQtWrapper_elfFileWidget::new_elfFileWidget(QWidget* parent)
5857 {
5863 {
5858 return new PythonQtShell_elfFileWidget(parent); }
5864 return new PythonQtShell_elfFileWidget(parent); }
5859
5865
5860
5866
5861
5867
5862 PythonQtShell_elfInfoWdgt::~PythonQtShell_elfInfoWdgt() {
5868 PythonQtShell_elfInfoWdgt::~PythonQtShell_elfInfoWdgt() {
5863 PythonQtPrivate* priv = PythonQt::priv();
5869 PythonQtPrivate* priv = PythonQt::priv();
5864 if (priv) { priv->shellClassDeleted(this); }
5870 if (priv) { priv->shellClassDeleted(this); }
5865 }
5871 }
5866 void PythonQtShell_elfInfoWdgt::actionEvent(QActionEvent* arg__1)
5872 void PythonQtShell_elfInfoWdgt::actionEvent(QActionEvent* arg__1)
5867 {
5873 {
5868 if (_wrapper) {
5874 if (_wrapper) {
5869 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
5875 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
5870 PyErr_Clear();
5876 PyErr_Clear();
5871 if (obj && !PythonQtSlotFunction_Check(obj)) {
5877 if (obj && !PythonQtSlotFunction_Check(obj)) {
5872 static const char* argumentList[] ={"" , "QActionEvent*"};
5878 static const char* argumentList[] ={"" , "QActionEvent*"};
5873 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5879 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5874 void* args[2] = {NULL, (void*)&arg__1};
5880 void* args[2] = {NULL, (void*)&arg__1};
5875 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5881 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5876 if (result) { Py_DECREF(result); }
5882 if (result) { Py_DECREF(result); }
5877 Py_DECREF(obj);
5883 Py_DECREF(obj);
5878 return;
5884 return;
5879 }
5885 }
5880 }
5886 }
5881 elfInfoWdgt::actionEvent(arg__1);
5887 elfInfoWdgt::actionEvent(arg__1);
5882 }
5888 }
5883 void PythonQtShell_elfInfoWdgt::changeEvent(QEvent* arg__1)
5889 void PythonQtShell_elfInfoWdgt::changeEvent(QEvent* arg__1)
5884 {
5890 {
5885 if (_wrapper) {
5891 if (_wrapper) {
5886 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
5892 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
5887 PyErr_Clear();
5893 PyErr_Clear();
5888 if (obj && !PythonQtSlotFunction_Check(obj)) {
5894 if (obj && !PythonQtSlotFunction_Check(obj)) {
5889 static const char* argumentList[] ={"" , "QEvent*"};
5895 static const char* argumentList[] ={"" , "QEvent*"};
5890 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5896 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5891 void* args[2] = {NULL, (void*)&arg__1};
5897 void* args[2] = {NULL, (void*)&arg__1};
5892 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5898 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5893 if (result) { Py_DECREF(result); }
5899 if (result) { Py_DECREF(result); }
5894 Py_DECREF(obj);
5900 Py_DECREF(obj);
5895 return;
5901 return;
5896 }
5902 }
5897 }
5903 }
5898 elfInfoWdgt::changeEvent(arg__1);
5904 elfInfoWdgt::changeEvent(arg__1);
5899 }
5905 }
5900 void PythonQtShell_elfInfoWdgt::childEvent(QChildEvent* arg__1)
5906 void PythonQtShell_elfInfoWdgt::childEvent(QChildEvent* arg__1)
5901 {
5907 {
5902 if (_wrapper) {
5908 if (_wrapper) {
5903 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
5909 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
5904 PyErr_Clear();
5910 PyErr_Clear();
5905 if (obj && !PythonQtSlotFunction_Check(obj)) {
5911 if (obj && !PythonQtSlotFunction_Check(obj)) {
5906 static const char* argumentList[] ={"" , "QChildEvent*"};
5912 static const char* argumentList[] ={"" , "QChildEvent*"};
5907 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5913 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5908 void* args[2] = {NULL, (void*)&arg__1};
5914 void* args[2] = {NULL, (void*)&arg__1};
5909 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5915 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5910 if (result) { Py_DECREF(result); }
5916 if (result) { Py_DECREF(result); }
5911 Py_DECREF(obj);
5917 Py_DECREF(obj);
5912 return;
5918 return;
5913 }
5919 }
5914 }
5920 }
5915 elfInfoWdgt::childEvent(arg__1);
5921 elfInfoWdgt::childEvent(arg__1);
5916 }
5922 }
5917 void PythonQtShell_elfInfoWdgt::closeEvent(QCloseEvent* arg__1)
5923 void PythonQtShell_elfInfoWdgt::closeEvent(QCloseEvent* arg__1)
5918 {
5924 {
5919 if (_wrapper) {
5925 if (_wrapper) {
5920 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
5926 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
5921 PyErr_Clear();
5927 PyErr_Clear();
5922 if (obj && !PythonQtSlotFunction_Check(obj)) {
5928 if (obj && !PythonQtSlotFunction_Check(obj)) {
5923 static const char* argumentList[] ={"" , "QCloseEvent*"};
5929 static const char* argumentList[] ={"" , "QCloseEvent*"};
5924 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5930 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5925 void* args[2] = {NULL, (void*)&arg__1};
5931 void* args[2] = {NULL, (void*)&arg__1};
5926 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5932 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5927 if (result) { Py_DECREF(result); }
5933 if (result) { Py_DECREF(result); }
5928 Py_DECREF(obj);
5934 Py_DECREF(obj);
5929 return;
5935 return;
5930 }
5936 }
5931 }
5937 }
5932 elfInfoWdgt::closeEvent(arg__1);
5938 elfInfoWdgt::closeEvent(arg__1);
5933 }
5939 }
5934 void PythonQtShell_elfInfoWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
5940 void PythonQtShell_elfInfoWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
5935 {
5941 {
5936 if (_wrapper) {
5942 if (_wrapper) {
5937 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
5943 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
5938 PyErr_Clear();
5944 PyErr_Clear();
5939 if (obj && !PythonQtSlotFunction_Check(obj)) {
5945 if (obj && !PythonQtSlotFunction_Check(obj)) {
5940 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
5946 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
5941 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5947 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5942 void* args[2] = {NULL, (void*)&arg__1};
5948 void* args[2] = {NULL, (void*)&arg__1};
5943 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5949 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5944 if (result) { Py_DECREF(result); }
5950 if (result) { Py_DECREF(result); }
5945 Py_DECREF(obj);
5951 Py_DECREF(obj);
5946 return;
5952 return;
5947 }
5953 }
5948 }
5954 }
5949 elfInfoWdgt::contextMenuEvent(arg__1);
5955 elfInfoWdgt::contextMenuEvent(arg__1);
5950 }
5956 }
5951 void PythonQtShell_elfInfoWdgt::customEvent(QEvent* arg__1)
5957 void PythonQtShell_elfInfoWdgt::customEvent(QEvent* arg__1)
5952 {
5958 {
5953 if (_wrapper) {
5959 if (_wrapper) {
5954 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
5960 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
5955 PyErr_Clear();
5961 PyErr_Clear();
5956 if (obj && !PythonQtSlotFunction_Check(obj)) {
5962 if (obj && !PythonQtSlotFunction_Check(obj)) {
5957 static const char* argumentList[] ={"" , "QEvent*"};
5963 static const char* argumentList[] ={"" , "QEvent*"};
5958 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5964 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5959 void* args[2] = {NULL, (void*)&arg__1};
5965 void* args[2] = {NULL, (void*)&arg__1};
5960 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5966 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5961 if (result) { Py_DECREF(result); }
5967 if (result) { Py_DECREF(result); }
5962 Py_DECREF(obj);
5968 Py_DECREF(obj);
5963 return;
5969 return;
5964 }
5970 }
5965 }
5971 }
5966 elfInfoWdgt::customEvent(arg__1);
5972 elfInfoWdgt::customEvent(arg__1);
5967 }
5973 }
5968 int PythonQtShell_elfInfoWdgt::devType() const
5974 int PythonQtShell_elfInfoWdgt::devType() const
5969 {
5975 {
5970 if (_wrapper) {
5976 if (_wrapper) {
5971 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
5977 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
5972 PyErr_Clear();
5978 PyErr_Clear();
5973 if (obj && !PythonQtSlotFunction_Check(obj)) {
5979 if (obj && !PythonQtSlotFunction_Check(obj)) {
5974 static const char* argumentList[] ={"int"};
5980 static const char* argumentList[] ={"int"};
5975 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5981 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5976 int returnValue;
5982 int returnValue;
5977 void* args[1] = {NULL};
5983 void* args[1] = {NULL};
5978 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5984 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5979 if (result) {
5985 if (result) {
5980 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5986 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5981 if (args[0]!=&returnValue) {
5987 if (args[0]!=&returnValue) {
5982 if (args[0]==NULL) {
5988 if (args[0]==NULL) {
5983 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
5989 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
5984 } else {
5990 } else {
5985 returnValue = *((int*)args[0]);
5991 returnValue = *((int*)args[0]);
5986 }
5992 }
5987 }
5993 }
5988 }
5994 }
5989 if (result) { Py_DECREF(result); }
5995 if (result) { Py_DECREF(result); }
5990 Py_DECREF(obj);
5996 Py_DECREF(obj);
5991 return returnValue;
5997 return returnValue;
5992 }
5998 }
5993 }
5999 }
5994 return elfInfoWdgt::devType();
6000 return elfInfoWdgt::devType();
5995 }
6001 }
5996 void PythonQtShell_elfInfoWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
6002 void PythonQtShell_elfInfoWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
5997 {
6003 {
5998 if (_wrapper) {
6004 if (_wrapper) {
5999 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
6005 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
6000 PyErr_Clear();
6006 PyErr_Clear();
6001 if (obj && !PythonQtSlotFunction_Check(obj)) {
6007 if (obj && !PythonQtSlotFunction_Check(obj)) {
6002 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
6008 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
6003 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6009 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6004 void* args[2] = {NULL, (void*)&arg__1};
6010 void* args[2] = {NULL, (void*)&arg__1};
6005 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6011 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6006 if (result) { Py_DECREF(result); }
6012 if (result) { Py_DECREF(result); }
6007 Py_DECREF(obj);
6013 Py_DECREF(obj);
6008 return;
6014 return;
6009 }
6015 }
6010 }
6016 }
6011 elfInfoWdgt::dragEnterEvent(arg__1);
6017 elfInfoWdgt::dragEnterEvent(arg__1);
6012 }
6018 }
6013 void PythonQtShell_elfInfoWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
6019 void PythonQtShell_elfInfoWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
6014 {
6020 {
6015 if (_wrapper) {
6021 if (_wrapper) {
6016 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
6022 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
6017 PyErr_Clear();
6023 PyErr_Clear();
6018 if (obj && !PythonQtSlotFunction_Check(obj)) {
6024 if (obj && !PythonQtSlotFunction_Check(obj)) {
6019 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
6025 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
6020 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6026 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6021 void* args[2] = {NULL, (void*)&arg__1};
6027 void* args[2] = {NULL, (void*)&arg__1};
6022 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6028 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6023 if (result) { Py_DECREF(result); }
6029 if (result) { Py_DECREF(result); }
6024 Py_DECREF(obj);
6030 Py_DECREF(obj);
6025 return;
6031 return;
6026 }
6032 }
6027 }
6033 }
6028 elfInfoWdgt::dragLeaveEvent(arg__1);
6034 elfInfoWdgt::dragLeaveEvent(arg__1);
6029 }
6035 }
6030 void PythonQtShell_elfInfoWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
6036 void PythonQtShell_elfInfoWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
6031 {
6037 {
6032 if (_wrapper) {
6038 if (_wrapper) {
6033 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
6039 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
6034 PyErr_Clear();
6040 PyErr_Clear();
6035 if (obj && !PythonQtSlotFunction_Check(obj)) {
6041 if (obj && !PythonQtSlotFunction_Check(obj)) {
6036 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
6042 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
6037 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6043 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6038 void* args[2] = {NULL, (void*)&arg__1};
6044 void* args[2] = {NULL, (void*)&arg__1};
6039 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6045 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6040 if (result) { Py_DECREF(result); }
6046 if (result) { Py_DECREF(result); }
6041 Py_DECREF(obj);
6047 Py_DECREF(obj);
6042 return;
6048 return;
6043 }
6049 }
6044 }
6050 }
6045 elfInfoWdgt::dragMoveEvent(arg__1);
6051 elfInfoWdgt::dragMoveEvent(arg__1);
6046 }
6052 }
6047 void PythonQtShell_elfInfoWdgt::dropEvent(QDropEvent* arg__1)
6053 void PythonQtShell_elfInfoWdgt::dropEvent(QDropEvent* arg__1)
6048 {
6054 {
6049 if (_wrapper) {
6055 if (_wrapper) {
6050 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
6056 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
6051 PyErr_Clear();
6057 PyErr_Clear();
6052 if (obj && !PythonQtSlotFunction_Check(obj)) {
6058 if (obj && !PythonQtSlotFunction_Check(obj)) {
6053 static const char* argumentList[] ={"" , "QDropEvent*"};
6059 static const char* argumentList[] ={"" , "QDropEvent*"};
6054 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6060 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6055 void* args[2] = {NULL, (void*)&arg__1};
6061 void* args[2] = {NULL, (void*)&arg__1};
6056 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6062 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6057 if (result) { Py_DECREF(result); }
6063 if (result) { Py_DECREF(result); }
6058 Py_DECREF(obj);
6064 Py_DECREF(obj);
6059 return;
6065 return;
6060 }
6066 }
6061 }
6067 }
6062 elfInfoWdgt::dropEvent(arg__1);
6068 elfInfoWdgt::dropEvent(arg__1);
6063 }
6069 }
6064 void PythonQtShell_elfInfoWdgt::enterEvent(QEvent* arg__1)
6070 void PythonQtShell_elfInfoWdgt::enterEvent(QEvent* arg__1)
6065 {
6071 {
6066 if (_wrapper) {
6072 if (_wrapper) {
6067 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
6073 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
6068 PyErr_Clear();
6074 PyErr_Clear();
6069 if (obj && !PythonQtSlotFunction_Check(obj)) {
6075 if (obj && !PythonQtSlotFunction_Check(obj)) {
6070 static const char* argumentList[] ={"" , "QEvent*"};
6076 static const char* argumentList[] ={"" , "QEvent*"};
6071 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6077 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6072 void* args[2] = {NULL, (void*)&arg__1};
6078 void* args[2] = {NULL, (void*)&arg__1};
6073 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6079 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6074 if (result) { Py_DECREF(result); }
6080 if (result) { Py_DECREF(result); }
6075 Py_DECREF(obj);
6081 Py_DECREF(obj);
6076 return;
6082 return;
6077 }
6083 }
6078 }
6084 }
6079 elfInfoWdgt::enterEvent(arg__1);
6085 elfInfoWdgt::enterEvent(arg__1);
6080 }
6086 }
6081 bool PythonQtShell_elfInfoWdgt::event(QEvent* arg__1)
6087 bool PythonQtShell_elfInfoWdgt::event(QEvent* arg__1)
6082 {
6088 {
6083 if (_wrapper) {
6089 if (_wrapper) {
6084 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
6090 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
6085 PyErr_Clear();
6091 PyErr_Clear();
6086 if (obj && !PythonQtSlotFunction_Check(obj)) {
6092 if (obj && !PythonQtSlotFunction_Check(obj)) {
6087 static const char* argumentList[] ={"bool" , "QEvent*"};
6093 static const char* argumentList[] ={"bool" , "QEvent*"};
6088 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6094 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6089 bool returnValue;
6095 bool returnValue;
6090 void* args[2] = {NULL, (void*)&arg__1};
6096 void* args[2] = {NULL, (void*)&arg__1};
6091 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6097 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6092 if (result) {
6098 if (result) {
6093 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6099 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6094 if (args[0]!=&returnValue) {
6100 if (args[0]!=&returnValue) {
6095 if (args[0]==NULL) {
6101 if (args[0]==NULL) {
6096 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
6102 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
6097 } else {
6103 } else {
6098 returnValue = *((bool*)args[0]);
6104 returnValue = *((bool*)args[0]);
6099 }
6105 }
6100 }
6106 }
6101 }
6107 }
6102 if (result) { Py_DECREF(result); }
6108 if (result) { Py_DECREF(result); }
6103 Py_DECREF(obj);
6109 Py_DECREF(obj);
6104 return returnValue;
6110 return returnValue;
6105 }
6111 }
6106 }
6112 }
6107 return elfInfoWdgt::event(arg__1);
6113 return elfInfoWdgt::event(arg__1);
6108 }
6114 }
6109 bool PythonQtShell_elfInfoWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
6115 bool PythonQtShell_elfInfoWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
6110 {
6116 {
6111 if (_wrapper) {
6117 if (_wrapper) {
6112 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
6118 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
6113 PyErr_Clear();
6119 PyErr_Clear();
6114 if (obj && !PythonQtSlotFunction_Check(obj)) {
6120 if (obj && !PythonQtSlotFunction_Check(obj)) {
6115 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
6121 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
6116 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
6122 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
6117 bool returnValue;
6123 bool returnValue;
6118 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
6124 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
6119 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6125 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6120 if (result) {
6126 if (result) {
6121 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6127 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6122 if (args[0]!=&returnValue) {
6128 if (args[0]!=&returnValue) {
6123 if (args[0]==NULL) {
6129 if (args[0]==NULL) {
6124 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
6130 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
6125 } else {
6131 } else {
6126 returnValue = *((bool*)args[0]);
6132 returnValue = *((bool*)args[0]);
6127 }
6133 }
6128 }
6134 }
6129 }
6135 }
6130 if (result) { Py_DECREF(result); }
6136 if (result) { Py_DECREF(result); }
6131 Py_DECREF(obj);
6137 Py_DECREF(obj);
6132 return returnValue;
6138 return returnValue;
6133 }
6139 }
6134 }
6140 }
6135 return elfInfoWdgt::eventFilter(arg__1, arg__2);
6141 return elfInfoWdgt::eventFilter(arg__1, arg__2);
6136 }
6142 }
6137 void PythonQtShell_elfInfoWdgt::focusInEvent(QFocusEvent* arg__1)
6143 void PythonQtShell_elfInfoWdgt::focusInEvent(QFocusEvent* arg__1)
6138 {
6144 {
6139 if (_wrapper) {
6145 if (_wrapper) {
6140 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
6146 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
6141 PyErr_Clear();
6147 PyErr_Clear();
6142 if (obj && !PythonQtSlotFunction_Check(obj)) {
6148 if (obj && !PythonQtSlotFunction_Check(obj)) {
6143 static const char* argumentList[] ={"" , "QFocusEvent*"};
6149 static const char* argumentList[] ={"" , "QFocusEvent*"};
6144 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6150 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6145 void* args[2] = {NULL, (void*)&arg__1};
6151 void* args[2] = {NULL, (void*)&arg__1};
6146 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6152 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6147 if (result) { Py_DECREF(result); }
6153 if (result) { Py_DECREF(result); }
6148 Py_DECREF(obj);
6154 Py_DECREF(obj);
6149 return;
6155 return;
6150 }
6156 }
6151 }
6157 }
6152 elfInfoWdgt::focusInEvent(arg__1);
6158 elfInfoWdgt::focusInEvent(arg__1);
6153 }
6159 }
6154 bool PythonQtShell_elfInfoWdgt::focusNextPrevChild(bool next)
6160 bool PythonQtShell_elfInfoWdgt::focusNextPrevChild(bool next)
6155 {
6161 {
6156 if (_wrapper) {
6162 if (_wrapper) {
6157 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
6163 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
6158 PyErr_Clear();
6164 PyErr_Clear();
6159 if (obj && !PythonQtSlotFunction_Check(obj)) {
6165 if (obj && !PythonQtSlotFunction_Check(obj)) {
6160 static const char* argumentList[] ={"bool" , "bool"};
6166 static const char* argumentList[] ={"bool" , "bool"};
6161 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6167 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6162 bool returnValue;
6168 bool returnValue;
6163 void* args[2] = {NULL, (void*)&next};
6169 void* args[2] = {NULL, (void*)&next};
6164 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6170 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6165 if (result) {
6171 if (result) {
6166 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6172 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6167 if (args[0]!=&returnValue) {
6173 if (args[0]!=&returnValue) {
6168 if (args[0]==NULL) {
6174 if (args[0]==NULL) {
6169 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
6175 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
6170 } else {
6176 } else {
6171 returnValue = *((bool*)args[0]);
6177 returnValue = *((bool*)args[0]);
6172 }
6178 }
6173 }
6179 }
6174 }
6180 }
6175 if (result) { Py_DECREF(result); }
6181 if (result) { Py_DECREF(result); }
6176 Py_DECREF(obj);
6182 Py_DECREF(obj);
6177 return returnValue;
6183 return returnValue;
6178 }
6184 }
6179 }
6185 }
6180 return elfInfoWdgt::focusNextPrevChild(next);
6186 return elfInfoWdgt::focusNextPrevChild(next);
6181 }
6187 }
6182 void PythonQtShell_elfInfoWdgt::focusOutEvent(QFocusEvent* arg__1)
6188 void PythonQtShell_elfInfoWdgt::focusOutEvent(QFocusEvent* arg__1)
6183 {
6189 {
6184 if (_wrapper) {
6190 if (_wrapper) {
6185 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
6191 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
6186 PyErr_Clear();
6192 PyErr_Clear();
6187 if (obj && !PythonQtSlotFunction_Check(obj)) {
6193 if (obj && !PythonQtSlotFunction_Check(obj)) {
6188 static const char* argumentList[] ={"" , "QFocusEvent*"};
6194 static const char* argumentList[] ={"" , "QFocusEvent*"};
6189 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6195 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6190 void* args[2] = {NULL, (void*)&arg__1};
6196 void* args[2] = {NULL, (void*)&arg__1};
6191 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6197 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6192 if (result) { Py_DECREF(result); }
6198 if (result) { Py_DECREF(result); }
6193 Py_DECREF(obj);
6199 Py_DECREF(obj);
6194 return;
6200 return;
6195 }
6201 }
6196 }
6202 }
6197 elfInfoWdgt::focusOutEvent(arg__1);
6203 elfInfoWdgt::focusOutEvent(arg__1);
6198 }
6204 }
6199 bool PythonQtShell_elfInfoWdgt::hasHeightForWidth() const
6205 bool PythonQtShell_elfInfoWdgt::hasHeightForWidth() const
6200 {
6206 {
6201 if (_wrapper) {
6207 if (_wrapper) {
6202 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
6208 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
6203 PyErr_Clear();
6209 PyErr_Clear();
6204 if (obj && !PythonQtSlotFunction_Check(obj)) {
6210 if (obj && !PythonQtSlotFunction_Check(obj)) {
6205 static const char* argumentList[] ={"bool"};
6211 static const char* argumentList[] ={"bool"};
6206 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6212 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6207 bool returnValue;
6213 bool returnValue;
6208 void* args[1] = {NULL};
6214 void* args[1] = {NULL};
6209 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6215 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6210 if (result) {
6216 if (result) {
6211 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6217 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6212 if (args[0]!=&returnValue) {
6218 if (args[0]!=&returnValue) {
6213 if (args[0]==NULL) {
6219 if (args[0]==NULL) {
6214 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
6220 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
6215 } else {
6221 } else {
6216 returnValue = *((bool*)args[0]);
6222 returnValue = *((bool*)args[0]);
6217 }
6223 }
6218 }
6224 }
6219 }
6225 }
6220 if (result) { Py_DECREF(result); }
6226 if (result) { Py_DECREF(result); }
6221 Py_DECREF(obj);
6227 Py_DECREF(obj);
6222 return returnValue;
6228 return returnValue;
6223 }
6229 }
6224 }
6230 }
6225 return elfInfoWdgt::hasHeightForWidth();
6231 return elfInfoWdgt::hasHeightForWidth();
6226 }
6232 }
6227 int PythonQtShell_elfInfoWdgt::heightForWidth(int arg__1) const
6233 int PythonQtShell_elfInfoWdgt::heightForWidth(int arg__1) const
6228 {
6234 {
6229 if (_wrapper) {
6235 if (_wrapper) {
6230 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
6236 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
6231 PyErr_Clear();
6237 PyErr_Clear();
6232 if (obj && !PythonQtSlotFunction_Check(obj)) {
6238 if (obj && !PythonQtSlotFunction_Check(obj)) {
6233 static const char* argumentList[] ={"int" , "int"};
6239 static const char* argumentList[] ={"int" , "int"};
6234 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6240 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6235 int returnValue;
6241 int returnValue;
6236 void* args[2] = {NULL, (void*)&arg__1};
6242 void* args[2] = {NULL, (void*)&arg__1};
6237 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6243 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6238 if (result) {
6244 if (result) {
6239 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6245 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6240 if (args[0]!=&returnValue) {
6246 if (args[0]!=&returnValue) {
6241 if (args[0]==NULL) {
6247 if (args[0]==NULL) {
6242 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
6248 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
6243 } else {
6249 } else {
6244 returnValue = *((int*)args[0]);
6250 returnValue = *((int*)args[0]);
6245 }
6251 }
6246 }
6252 }
6247 }
6253 }
6248 if (result) { Py_DECREF(result); }
6254 if (result) { Py_DECREF(result); }
6249 Py_DECREF(obj);
6255 Py_DECREF(obj);
6250 return returnValue;
6256 return returnValue;
6251 }
6257 }
6252 }
6258 }
6253 return elfInfoWdgt::heightForWidth(arg__1);
6259 return elfInfoWdgt::heightForWidth(arg__1);
6254 }
6260 }
6255 void PythonQtShell_elfInfoWdgt::hideEvent(QHideEvent* arg__1)
6261 void PythonQtShell_elfInfoWdgt::hideEvent(QHideEvent* arg__1)
6256 {
6262 {
6257 if (_wrapper) {
6263 if (_wrapper) {
6258 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
6264 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
6259 PyErr_Clear();
6265 PyErr_Clear();
6260 if (obj && !PythonQtSlotFunction_Check(obj)) {
6266 if (obj && !PythonQtSlotFunction_Check(obj)) {
6261 static const char* argumentList[] ={"" , "QHideEvent*"};
6267 static const char* argumentList[] ={"" , "QHideEvent*"};
6262 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6268 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6263 void* args[2] = {NULL, (void*)&arg__1};
6269 void* args[2] = {NULL, (void*)&arg__1};
6264 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6270 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6265 if (result) { Py_DECREF(result); }
6271 if (result) { Py_DECREF(result); }
6266 Py_DECREF(obj);
6272 Py_DECREF(obj);
6267 return;
6273 return;
6268 }
6274 }
6269 }
6275 }
6270 elfInfoWdgt::hideEvent(arg__1);
6276 elfInfoWdgt::hideEvent(arg__1);
6271 }
6277 }
6272 void PythonQtShell_elfInfoWdgt::initPainter(QPainter* painter) const
6278 void PythonQtShell_elfInfoWdgt::initPainter(QPainter* painter) const
6273 {
6279 {
6274 if (_wrapper) {
6280 if (_wrapper) {
6275 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
6281 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
6276 PyErr_Clear();
6282 PyErr_Clear();
6277 if (obj && !PythonQtSlotFunction_Check(obj)) {
6283 if (obj && !PythonQtSlotFunction_Check(obj)) {
6278 static const char* argumentList[] ={"" , "QPainter*"};
6284 static const char* argumentList[] ={"" , "QPainter*"};
6279 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6285 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6280 void* args[2] = {NULL, (void*)&painter};
6286 void* args[2] = {NULL, (void*)&painter};
6281 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6287 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6282 if (result) { Py_DECREF(result); }
6288 if (result) { Py_DECREF(result); }
6283 Py_DECREF(obj);
6289 Py_DECREF(obj);
6284 return;
6290 return;
6285 }
6291 }
6286 }
6292 }
6287 elfInfoWdgt::initPainter(painter);
6293 elfInfoWdgt::initPainter(painter);
6288 }
6294 }
6289 void PythonQtShell_elfInfoWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
6295 void PythonQtShell_elfInfoWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
6290 {
6296 {
6291 if (_wrapper) {
6297 if (_wrapper) {
6292 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
6298 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
6293 PyErr_Clear();
6299 PyErr_Clear();
6294 if (obj && !PythonQtSlotFunction_Check(obj)) {
6300 if (obj && !PythonQtSlotFunction_Check(obj)) {
6295 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
6301 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
6296 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6302 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6297 void* args[2] = {NULL, (void*)&arg__1};
6303 void* args[2] = {NULL, (void*)&arg__1};
6298 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6304 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6299 if (result) { Py_DECREF(result); }
6305 if (result) { Py_DECREF(result); }
6300 Py_DECREF(obj);
6306 Py_DECREF(obj);
6301 return;
6307 return;
6302 }
6308 }
6303 }
6309 }
6304 elfInfoWdgt::inputMethodEvent(arg__1);
6310 elfInfoWdgt::inputMethodEvent(arg__1);
6305 }
6311 }
6306 QVariant PythonQtShell_elfInfoWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
6312 QVariant PythonQtShell_elfInfoWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
6307 {
6313 {
6308 if (_wrapper) {
6314 if (_wrapper) {
6309 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
6315 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
6310 PyErr_Clear();
6316 PyErr_Clear();
6311 if (obj && !PythonQtSlotFunction_Check(obj)) {
6317 if (obj && !PythonQtSlotFunction_Check(obj)) {
6312 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
6318 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
6313 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6319 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6314 QVariant returnValue;
6320 QVariant returnValue;
6315 void* args[2] = {NULL, (void*)&arg__1};
6321 void* args[2] = {NULL, (void*)&arg__1};
6316 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6322 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6317 if (result) {
6323 if (result) {
6318 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6324 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6319 if (args[0]!=&returnValue) {
6325 if (args[0]!=&returnValue) {
6320 if (args[0]==NULL) {
6326 if (args[0]==NULL) {
6321 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
6327 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
6322 } else {
6328 } else {
6323 returnValue = *((QVariant*)args[0]);
6329 returnValue = *((QVariant*)args[0]);
6324 }
6330 }
6325 }
6331 }
6326 }
6332 }
6327 if (result) { Py_DECREF(result); }
6333 if (result) { Py_DECREF(result); }
6328 Py_DECREF(obj);
6334 Py_DECREF(obj);
6329 return returnValue;
6335 return returnValue;
6330 }
6336 }
6331 }
6337 }
6332 return elfInfoWdgt::inputMethodQuery(arg__1);
6338 return elfInfoWdgt::inputMethodQuery(arg__1);
6333 }
6339 }
6334 void PythonQtShell_elfInfoWdgt::keyPressEvent(QKeyEvent* arg__1)
6340 void PythonQtShell_elfInfoWdgt::keyPressEvent(QKeyEvent* arg__1)
6335 {
6341 {
6336 if (_wrapper) {
6342 if (_wrapper) {
6337 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
6343 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
6338 PyErr_Clear();
6344 PyErr_Clear();
6339 if (obj && !PythonQtSlotFunction_Check(obj)) {
6345 if (obj && !PythonQtSlotFunction_Check(obj)) {
6340 static const char* argumentList[] ={"" , "QKeyEvent*"};
6346 static const char* argumentList[] ={"" , "QKeyEvent*"};
6341 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6347 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6342 void* args[2] = {NULL, (void*)&arg__1};
6348 void* args[2] = {NULL, (void*)&arg__1};
6343 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6349 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6344 if (result) { Py_DECREF(result); }
6350 if (result) { Py_DECREF(result); }
6345 Py_DECREF(obj);
6351 Py_DECREF(obj);
6346 return;
6352 return;
6347 }
6353 }
6348 }
6354 }
6349 elfInfoWdgt::keyPressEvent(arg__1);
6355 elfInfoWdgt::keyPressEvent(arg__1);
6350 }
6356 }
6351 void PythonQtShell_elfInfoWdgt::keyReleaseEvent(QKeyEvent* arg__1)
6357 void PythonQtShell_elfInfoWdgt::keyReleaseEvent(QKeyEvent* arg__1)
6352 {
6358 {
6353 if (_wrapper) {
6359 if (_wrapper) {
6354 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
6360 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
6355 PyErr_Clear();
6361 PyErr_Clear();
6356 if (obj && !PythonQtSlotFunction_Check(obj)) {
6362 if (obj && !PythonQtSlotFunction_Check(obj)) {
6357 static const char* argumentList[] ={"" , "QKeyEvent*"};
6363 static const char* argumentList[] ={"" , "QKeyEvent*"};
6358 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6364 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6359 void* args[2] = {NULL, (void*)&arg__1};
6365 void* args[2] = {NULL, (void*)&arg__1};
6360 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6366 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6361 if (result) { Py_DECREF(result); }
6367 if (result) { Py_DECREF(result); }
6362 Py_DECREF(obj);
6368 Py_DECREF(obj);
6363 return;
6369 return;
6364 }
6370 }
6365 }
6371 }
6366 elfInfoWdgt::keyReleaseEvent(arg__1);
6372 elfInfoWdgt::keyReleaseEvent(arg__1);
6367 }
6373 }
6368 void PythonQtShell_elfInfoWdgt::leaveEvent(QEvent* arg__1)
6374 void PythonQtShell_elfInfoWdgt::leaveEvent(QEvent* arg__1)
6369 {
6375 {
6370 if (_wrapper) {
6376 if (_wrapper) {
6371 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
6377 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
6372 PyErr_Clear();
6378 PyErr_Clear();
6373 if (obj && !PythonQtSlotFunction_Check(obj)) {
6379 if (obj && !PythonQtSlotFunction_Check(obj)) {
6374 static const char* argumentList[] ={"" , "QEvent*"};
6380 static const char* argumentList[] ={"" , "QEvent*"};
6375 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6381 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6376 void* args[2] = {NULL, (void*)&arg__1};
6382 void* args[2] = {NULL, (void*)&arg__1};
6377 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6383 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6378 if (result) { Py_DECREF(result); }
6384 if (result) { Py_DECREF(result); }
6379 Py_DECREF(obj);
6385 Py_DECREF(obj);
6380 return;
6386 return;
6381 }
6387 }
6382 }
6388 }
6383 elfInfoWdgt::leaveEvent(arg__1);
6389 elfInfoWdgt::leaveEvent(arg__1);
6384 }
6390 }
6385 int PythonQtShell_elfInfoWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
6391 int PythonQtShell_elfInfoWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
6386 {
6392 {
6387 if (_wrapper) {
6393 if (_wrapper) {
6388 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
6394 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
6389 PyErr_Clear();
6395 PyErr_Clear();
6390 if (obj && !PythonQtSlotFunction_Check(obj)) {
6396 if (obj && !PythonQtSlotFunction_Check(obj)) {
6391 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
6397 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
6392 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6398 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6393 int returnValue;
6399 int returnValue;
6394 void* args[2] = {NULL, (void*)&arg__1};
6400 void* args[2] = {NULL, (void*)&arg__1};
6395 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6401 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6396 if (result) {
6402 if (result) {
6397 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6403 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6398 if (args[0]!=&returnValue) {
6404 if (args[0]!=&returnValue) {
6399 if (args[0]==NULL) {
6405 if (args[0]==NULL) {
6400 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
6406 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
6401 } else {
6407 } else {
6402 returnValue = *((int*)args[0]);
6408 returnValue = *((int*)args[0]);
6403 }
6409 }
6404 }
6410 }
6405 }
6411 }
6406 if (result) { Py_DECREF(result); }
6412 if (result) { Py_DECREF(result); }
6407 Py_DECREF(obj);
6413 Py_DECREF(obj);
6408 return returnValue;
6414 return returnValue;
6409 }
6415 }
6410 }
6416 }
6411 return elfInfoWdgt::metric(arg__1);
6417 return elfInfoWdgt::metric(arg__1);
6412 }
6418 }
6413 QSize PythonQtShell_elfInfoWdgt::minimumSizeHint() const
6419 QSize PythonQtShell_elfInfoWdgt::minimumSizeHint() const
6414 {
6420 {
6415 if (_wrapper) {
6421 if (_wrapper) {
6416 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
6422 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
6417 PyErr_Clear();
6423 PyErr_Clear();
6418 if (obj && !PythonQtSlotFunction_Check(obj)) {
6424 if (obj && !PythonQtSlotFunction_Check(obj)) {
6419 static const char* argumentList[] ={"QSize"};
6425 static const char* argumentList[] ={"QSize"};
6420 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6426 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6421 QSize returnValue;
6427 QSize returnValue;
6422 void* args[1] = {NULL};
6428 void* args[1] = {NULL};
6423 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6429 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6424 if (result) {
6430 if (result) {
6425 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6431 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6426 if (args[0]!=&returnValue) {
6432 if (args[0]!=&returnValue) {
6427 if (args[0]==NULL) {
6433 if (args[0]==NULL) {
6428 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
6434 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
6429 } else {
6435 } else {
6430 returnValue = *((QSize*)args[0]);
6436 returnValue = *((QSize*)args[0]);
6431 }
6437 }
6432 }
6438 }
6433 }
6439 }
6434 if (result) { Py_DECREF(result); }
6440 if (result) { Py_DECREF(result); }
6435 Py_DECREF(obj);
6441 Py_DECREF(obj);
6436 return returnValue;
6442 return returnValue;
6437 }
6443 }
6438 }
6444 }
6439 return elfInfoWdgt::minimumSizeHint();
6445 return elfInfoWdgt::minimumSizeHint();
6440 }
6446 }
6441 void PythonQtShell_elfInfoWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
6447 void PythonQtShell_elfInfoWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
6442 {
6448 {
6443 if (_wrapper) {
6449 if (_wrapper) {
6444 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
6450 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
6445 PyErr_Clear();
6451 PyErr_Clear();
6446 if (obj && !PythonQtSlotFunction_Check(obj)) {
6452 if (obj && !PythonQtSlotFunction_Check(obj)) {
6447 static const char* argumentList[] ={"" , "QMouseEvent*"};
6453 static const char* argumentList[] ={"" , "QMouseEvent*"};
6448 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6454 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6449 void* args[2] = {NULL, (void*)&arg__1};
6455 void* args[2] = {NULL, (void*)&arg__1};
6450 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6456 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6451 if (result) { Py_DECREF(result); }
6457 if (result) { Py_DECREF(result); }
6452 Py_DECREF(obj);
6458 Py_DECREF(obj);
6453 return;
6459 return;
6454 }
6460 }
6455 }
6461 }
6456 elfInfoWdgt::mouseDoubleClickEvent(arg__1);
6462 elfInfoWdgt::mouseDoubleClickEvent(arg__1);
6457 }
6463 }
6458 void PythonQtShell_elfInfoWdgt::mouseMoveEvent(QMouseEvent* arg__1)
6464 void PythonQtShell_elfInfoWdgt::mouseMoveEvent(QMouseEvent* arg__1)
6459 {
6465 {
6460 if (_wrapper) {
6466 if (_wrapper) {
6461 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
6467 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
6462 PyErr_Clear();
6468 PyErr_Clear();
6463 if (obj && !PythonQtSlotFunction_Check(obj)) {
6469 if (obj && !PythonQtSlotFunction_Check(obj)) {
6464 static const char* argumentList[] ={"" , "QMouseEvent*"};
6470 static const char* argumentList[] ={"" , "QMouseEvent*"};
6465 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6471 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6466 void* args[2] = {NULL, (void*)&arg__1};
6472 void* args[2] = {NULL, (void*)&arg__1};
6467 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6473 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6468 if (result) { Py_DECREF(result); }
6474 if (result) { Py_DECREF(result); }
6469 Py_DECREF(obj);
6475 Py_DECREF(obj);
6470 return;
6476 return;
6471 }
6477 }
6472 }
6478 }
6473 elfInfoWdgt::mouseMoveEvent(arg__1);
6479 elfInfoWdgt::mouseMoveEvent(arg__1);
6474 }
6480 }
6475 void PythonQtShell_elfInfoWdgt::mousePressEvent(QMouseEvent* arg__1)
6481 void PythonQtShell_elfInfoWdgt::mousePressEvent(QMouseEvent* arg__1)
6476 {
6482 {
6477 if (_wrapper) {
6483 if (_wrapper) {
6478 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
6484 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
6479 PyErr_Clear();
6485 PyErr_Clear();
6480 if (obj && !PythonQtSlotFunction_Check(obj)) {
6486 if (obj && !PythonQtSlotFunction_Check(obj)) {
6481 static const char* argumentList[] ={"" , "QMouseEvent*"};
6487 static const char* argumentList[] ={"" , "QMouseEvent*"};
6482 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6488 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6483 void* args[2] = {NULL, (void*)&arg__1};
6489 void* args[2] = {NULL, (void*)&arg__1};
6484 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6490 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6485 if (result) { Py_DECREF(result); }
6491 if (result) { Py_DECREF(result); }
6486 Py_DECREF(obj);
6492 Py_DECREF(obj);
6487 return;
6493 return;
6488 }
6494 }
6489 }
6495 }
6490 elfInfoWdgt::mousePressEvent(arg__1);
6496 elfInfoWdgt::mousePressEvent(arg__1);
6491 }
6497 }
6492 void PythonQtShell_elfInfoWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
6498 void PythonQtShell_elfInfoWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
6493 {
6499 {
6494 if (_wrapper) {
6500 if (_wrapper) {
6495 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
6501 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
6496 PyErr_Clear();
6502 PyErr_Clear();
6497 if (obj && !PythonQtSlotFunction_Check(obj)) {
6503 if (obj && !PythonQtSlotFunction_Check(obj)) {
6498 static const char* argumentList[] ={"" , "QMouseEvent*"};
6504 static const char* argumentList[] ={"" , "QMouseEvent*"};
6499 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6505 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6500 void* args[2] = {NULL, (void*)&arg__1};
6506 void* args[2] = {NULL, (void*)&arg__1};
6501 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6507 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6502 if (result) { Py_DECREF(result); }
6508 if (result) { Py_DECREF(result); }
6503 Py_DECREF(obj);
6509 Py_DECREF(obj);
6504 return;
6510 return;
6505 }
6511 }
6506 }
6512 }
6507 elfInfoWdgt::mouseReleaseEvent(arg__1);
6513 elfInfoWdgt::mouseReleaseEvent(arg__1);
6508 }
6514 }
6509 void PythonQtShell_elfInfoWdgt::moveEvent(QMoveEvent* arg__1)
6515 void PythonQtShell_elfInfoWdgt::moveEvent(QMoveEvent* arg__1)
6510 {
6516 {
6511 if (_wrapper) {
6517 if (_wrapper) {
6512 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
6518 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
6513 PyErr_Clear();
6519 PyErr_Clear();
6514 if (obj && !PythonQtSlotFunction_Check(obj)) {
6520 if (obj && !PythonQtSlotFunction_Check(obj)) {
6515 static const char* argumentList[] ={"" , "QMoveEvent*"};
6521 static const char* argumentList[] ={"" , "QMoveEvent*"};
6516 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6522 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6517 void* args[2] = {NULL, (void*)&arg__1};
6523 void* args[2] = {NULL, (void*)&arg__1};
6518 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6524 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6519 if (result) { Py_DECREF(result); }
6525 if (result) { Py_DECREF(result); }
6520 Py_DECREF(obj);
6526 Py_DECREF(obj);
6521 return;
6527 return;
6522 }
6528 }
6523 }
6529 }
6524 elfInfoWdgt::moveEvent(arg__1);
6530 elfInfoWdgt::moveEvent(arg__1);
6525 }
6531 }
6526 bool PythonQtShell_elfInfoWdgt::nativeEvent(const QByteArray& eventType, void* message, long* result)
6532 bool PythonQtShell_elfInfoWdgt::nativeEvent(const QByteArray& eventType, void* message, long* result)
6527 {
6533 {
6528 if (_wrapper) {
6534 if (_wrapper) {
6529 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
6535 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
6530 PyErr_Clear();
6536 PyErr_Clear();
6531 if (obj && !PythonQtSlotFunction_Check(obj)) {
6537 if (obj && !PythonQtSlotFunction_Check(obj)) {
6532 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
6538 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
6533 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
6539 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
6534 bool returnValue;
6540 bool returnValue;
6535 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
6541 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
6536 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6542 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6537 if (result) {
6543 if (result) {
6538 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6544 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6539 if (args[0]!=&returnValue) {
6545 if (args[0]!=&returnValue) {
6540 if (args[0]==NULL) {
6546 if (args[0]==NULL) {
6541 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
6547 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
6542 } else {
6548 } else {
6543 returnValue = *((bool*)args[0]);
6549 returnValue = *((bool*)args[0]);
6544 }
6550 }
6545 }
6551 }
6546 }
6552 }
6547 if (result) { Py_DECREF(result); }
6553 if (result) { Py_DECREF(result); }
6548 Py_DECREF(obj);
6554 Py_DECREF(obj);
6549 return returnValue;
6555 return returnValue;
6550 }
6556 }
6551 }
6557 }
6552 return elfInfoWdgt::nativeEvent(eventType, message, result);
6558 return elfInfoWdgt::nativeEvent(eventType, message, result);
6553 }
6559 }
6554 QPaintEngine* PythonQtShell_elfInfoWdgt::paintEngine() const
6560 QPaintEngine* PythonQtShell_elfInfoWdgt::paintEngine() const
6555 {
6561 {
6556 if (_wrapper) {
6562 if (_wrapper) {
6557 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
6563 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
6558 PyErr_Clear();
6564 PyErr_Clear();
6559 if (obj && !PythonQtSlotFunction_Check(obj)) {
6565 if (obj && !PythonQtSlotFunction_Check(obj)) {
6560 static const char* argumentList[] ={"QPaintEngine*"};
6566 static const char* argumentList[] ={"QPaintEngine*"};
6561 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6567 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6562 QPaintEngine* returnValue;
6568 QPaintEngine* returnValue;
6563 void* args[1] = {NULL};
6569 void* args[1] = {NULL};
6564 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6570 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6565 if (result) {
6571 if (result) {
6566 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6572 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6567 if (args[0]!=&returnValue) {
6573 if (args[0]!=&returnValue) {
6568 if (args[0]==NULL) {
6574 if (args[0]==NULL) {
6569 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
6575 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
6570 } else {
6576 } else {
6571 returnValue = *((QPaintEngine**)args[0]);
6577 returnValue = *((QPaintEngine**)args[0]);
6572 }
6578 }
6573 }
6579 }
6574 }
6580 }
6575 if (result) { Py_DECREF(result); }
6581 if (result) { Py_DECREF(result); }
6576 Py_DECREF(obj);
6582 Py_DECREF(obj);
6577 return returnValue;
6583 return returnValue;
6578 }
6584 }
6579 }
6585 }
6580 return elfInfoWdgt::paintEngine();
6586 return elfInfoWdgt::paintEngine();
6581 }
6587 }
6582 void PythonQtShell_elfInfoWdgt::paintEvent(QPaintEvent* arg__1)
6588 void PythonQtShell_elfInfoWdgt::paintEvent(QPaintEvent* arg__1)
6583 {
6589 {
6584 if (_wrapper) {
6590 if (_wrapper) {
6585 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
6591 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
6586 PyErr_Clear();
6592 PyErr_Clear();
6587 if (obj && !PythonQtSlotFunction_Check(obj)) {
6593 if (obj && !PythonQtSlotFunction_Check(obj)) {
6588 static const char* argumentList[] ={"" , "QPaintEvent*"};
6594 static const char* argumentList[] ={"" , "QPaintEvent*"};
6589 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6595 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6590 void* args[2] = {NULL, (void*)&arg__1};
6596 void* args[2] = {NULL, (void*)&arg__1};
6591 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6597 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6592 if (result) { Py_DECREF(result); }
6598 if (result) { Py_DECREF(result); }
6593 Py_DECREF(obj);
6599 Py_DECREF(obj);
6594 return;
6600 return;
6595 }
6601 }
6596 }
6602 }
6597 elfInfoWdgt::paintEvent(arg__1);
6603 elfInfoWdgt::paintEvent(arg__1);
6598 }
6604 }
6599 QPaintDevice* PythonQtShell_elfInfoWdgt::redirected(QPoint* offset) const
6605 QPaintDevice* PythonQtShell_elfInfoWdgt::redirected(QPoint* offset) const
6600 {
6606 {
6601 if (_wrapper) {
6607 if (_wrapper) {
6602 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
6608 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
6603 PyErr_Clear();
6609 PyErr_Clear();
6604 if (obj && !PythonQtSlotFunction_Check(obj)) {
6610 if (obj && !PythonQtSlotFunction_Check(obj)) {
6605 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
6611 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
6606 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6612 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6607 QPaintDevice* returnValue;
6613 QPaintDevice* returnValue;
6608 void* args[2] = {NULL, (void*)&offset};
6614 void* args[2] = {NULL, (void*)&offset};
6609 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6615 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6610 if (result) {
6616 if (result) {
6611 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6617 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6612 if (args[0]!=&returnValue) {
6618 if (args[0]!=&returnValue) {
6613 if (args[0]==NULL) {
6619 if (args[0]==NULL) {
6614 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
6620 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
6615 } else {
6621 } else {
6616 returnValue = *((QPaintDevice**)args[0]);
6622 returnValue = *((QPaintDevice**)args[0]);
6617 }
6623 }
6618 }
6624 }
6619 }
6625 }
6620 if (result) { Py_DECREF(result); }
6626 if (result) { Py_DECREF(result); }
6621 Py_DECREF(obj);
6627 Py_DECREF(obj);
6622 return returnValue;
6628 return returnValue;
6623 }
6629 }
6624 }
6630 }
6625 return elfInfoWdgt::redirected(offset);
6631 return elfInfoWdgt::redirected(offset);
6626 }
6632 }
6627 void PythonQtShell_elfInfoWdgt::resizeEvent(QResizeEvent* arg__1)
6633 void PythonQtShell_elfInfoWdgt::resizeEvent(QResizeEvent* arg__1)
6628 {
6634 {
6629 if (_wrapper) {
6635 if (_wrapper) {
6630 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
6636 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
6631 PyErr_Clear();
6637 PyErr_Clear();
6632 if (obj && !PythonQtSlotFunction_Check(obj)) {
6638 if (obj && !PythonQtSlotFunction_Check(obj)) {
6633 static const char* argumentList[] ={"" , "QResizeEvent*"};
6639 static const char* argumentList[] ={"" , "QResizeEvent*"};
6634 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6640 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6635 void* args[2] = {NULL, (void*)&arg__1};
6641 void* args[2] = {NULL, (void*)&arg__1};
6636 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6642 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6637 if (result) { Py_DECREF(result); }
6643 if (result) { Py_DECREF(result); }
6638 Py_DECREF(obj);
6644 Py_DECREF(obj);
6639 return;
6645 return;
6640 }
6646 }
6641 }
6647 }
6642 elfInfoWdgt::resizeEvent(arg__1);
6648 elfInfoWdgt::resizeEvent(arg__1);
6643 }
6649 }
6644 QPainter* PythonQtShell_elfInfoWdgt::sharedPainter() const
6650 QPainter* PythonQtShell_elfInfoWdgt::sharedPainter() const
6645 {
6651 {
6646 if (_wrapper) {
6652 if (_wrapper) {
6647 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
6653 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
6648 PyErr_Clear();
6654 PyErr_Clear();
6649 if (obj && !PythonQtSlotFunction_Check(obj)) {
6655 if (obj && !PythonQtSlotFunction_Check(obj)) {
6650 static const char* argumentList[] ={"QPainter*"};
6656 static const char* argumentList[] ={"QPainter*"};
6651 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6657 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6652 QPainter* returnValue;
6658 QPainter* returnValue;
6653 void* args[1] = {NULL};
6659 void* args[1] = {NULL};
6654 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6660 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6655 if (result) {
6661 if (result) {
6656 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6662 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6657 if (args[0]!=&returnValue) {
6663 if (args[0]!=&returnValue) {
6658 if (args[0]==NULL) {
6664 if (args[0]==NULL) {
6659 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
6665 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
6660 } else {
6666 } else {
6661 returnValue = *((QPainter**)args[0]);
6667 returnValue = *((QPainter**)args[0]);
6662 }
6668 }
6663 }
6669 }
6664 }
6670 }
6665 if (result) { Py_DECREF(result); }
6671 if (result) { Py_DECREF(result); }
6666 Py_DECREF(obj);
6672 Py_DECREF(obj);
6667 return returnValue;
6673 return returnValue;
6668 }
6674 }
6669 }
6675 }
6670 return elfInfoWdgt::sharedPainter();
6676 return elfInfoWdgt::sharedPainter();
6671 }
6677 }
6672 void PythonQtShell_elfInfoWdgt::showEvent(QShowEvent* arg__1)
6678 void PythonQtShell_elfInfoWdgt::showEvent(QShowEvent* arg__1)
6673 {
6679 {
6674 if (_wrapper) {
6680 if (_wrapper) {
6675 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
6681 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
6676 PyErr_Clear();
6682 PyErr_Clear();
6677 if (obj && !PythonQtSlotFunction_Check(obj)) {
6683 if (obj && !PythonQtSlotFunction_Check(obj)) {
6678 static const char* argumentList[] ={"" , "QShowEvent*"};
6684 static const char* argumentList[] ={"" , "QShowEvent*"};
6679 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6685 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6680 void* args[2] = {NULL, (void*)&arg__1};
6686 void* args[2] = {NULL, (void*)&arg__1};
6681 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6687 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6682 if (result) { Py_DECREF(result); }
6688 if (result) { Py_DECREF(result); }
6683 Py_DECREF(obj);
6689 Py_DECREF(obj);
6684 return;
6690 return;
6685 }
6691 }
6686 }
6692 }
6687 elfInfoWdgt::showEvent(arg__1);
6693 elfInfoWdgt::showEvent(arg__1);
6688 }
6694 }
6689 QSize PythonQtShell_elfInfoWdgt::sizeHint() const
6695 QSize PythonQtShell_elfInfoWdgt::sizeHint() const
6690 {
6696 {
6691 if (_wrapper) {
6697 if (_wrapper) {
6692 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
6698 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
6693 PyErr_Clear();
6699 PyErr_Clear();
6694 if (obj && !PythonQtSlotFunction_Check(obj)) {
6700 if (obj && !PythonQtSlotFunction_Check(obj)) {
6695 static const char* argumentList[] ={"QSize"};
6701 static const char* argumentList[] ={"QSize"};
6696 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6702 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6697 QSize returnValue;
6703 QSize returnValue;
6698 void* args[1] = {NULL};
6704 void* args[1] = {NULL};
6699 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6705 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6700 if (result) {
6706 if (result) {
6701 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6707 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6702 if (args[0]!=&returnValue) {
6708 if (args[0]!=&returnValue) {
6703 if (args[0]==NULL) {
6709 if (args[0]==NULL) {
6704 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
6710 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
6705 } else {
6711 } else {
6706 returnValue = *((QSize*)args[0]);
6712 returnValue = *((QSize*)args[0]);
6707 }
6713 }
6708 }
6714 }
6709 }
6715 }
6710 if (result) { Py_DECREF(result); }
6716 if (result) { Py_DECREF(result); }
6711 Py_DECREF(obj);
6717 Py_DECREF(obj);
6712 return returnValue;
6718 return returnValue;
6713 }
6719 }
6714 }
6720 }
6715 return elfInfoWdgt::sizeHint();
6721 return elfInfoWdgt::sizeHint();
6716 }
6722 }
6717 void PythonQtShell_elfInfoWdgt::tabletEvent(QTabletEvent* arg__1)
6723 void PythonQtShell_elfInfoWdgt::tabletEvent(QTabletEvent* arg__1)
6718 {
6724 {
6719 if (_wrapper) {
6725 if (_wrapper) {
6720 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
6726 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
6721 PyErr_Clear();
6727 PyErr_Clear();
6722 if (obj && !PythonQtSlotFunction_Check(obj)) {
6728 if (obj && !PythonQtSlotFunction_Check(obj)) {
6723 static const char* argumentList[] ={"" , "QTabletEvent*"};
6729 static const char* argumentList[] ={"" , "QTabletEvent*"};
6724 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6730 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6725 void* args[2] = {NULL, (void*)&arg__1};
6731 void* args[2] = {NULL, (void*)&arg__1};
6726 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6732 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6727 if (result) { Py_DECREF(result); }
6733 if (result) { Py_DECREF(result); }
6728 Py_DECREF(obj);
6734 Py_DECREF(obj);
6729 return;
6735 return;
6730 }
6736 }
6731 }
6737 }
6732 elfInfoWdgt::tabletEvent(arg__1);
6738 elfInfoWdgt::tabletEvent(arg__1);
6733 }
6739 }
6734 void PythonQtShell_elfInfoWdgt::timerEvent(QTimerEvent* arg__1)
6740 void PythonQtShell_elfInfoWdgt::timerEvent(QTimerEvent* arg__1)
6735 {
6741 {
6736 if (_wrapper) {
6742 if (_wrapper) {
6737 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
6743 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
6738 PyErr_Clear();
6744 PyErr_Clear();
6739 if (obj && !PythonQtSlotFunction_Check(obj)) {
6745 if (obj && !PythonQtSlotFunction_Check(obj)) {
6740 static const char* argumentList[] ={"" , "QTimerEvent*"};
6746 static const char* argumentList[] ={"" , "QTimerEvent*"};
6741 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6747 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6742 void* args[2] = {NULL, (void*)&arg__1};
6748 void* args[2] = {NULL, (void*)&arg__1};
6743 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6749 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6744 if (result) { Py_DECREF(result); }
6750 if (result) { Py_DECREF(result); }
6745 Py_DECREF(obj);
6751 Py_DECREF(obj);
6746 return;
6752 return;
6747 }
6753 }
6748 }
6754 }
6749 elfInfoWdgt::timerEvent(arg__1);
6755 elfInfoWdgt::timerEvent(arg__1);
6750 }
6756 }
6751 void PythonQtShell_elfInfoWdgt::wheelEvent(QWheelEvent* arg__1)
6757 void PythonQtShell_elfInfoWdgt::wheelEvent(QWheelEvent* arg__1)
6752 {
6758 {
6753 if (_wrapper) {
6759 if (_wrapper) {
6754 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
6760 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
6755 PyErr_Clear();
6761 PyErr_Clear();
6756 if (obj && !PythonQtSlotFunction_Check(obj)) {
6762 if (obj && !PythonQtSlotFunction_Check(obj)) {
6757 static const char* argumentList[] ={"" , "QWheelEvent*"};
6763 static const char* argumentList[] ={"" , "QWheelEvent*"};
6758 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6764 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6759 void* args[2] = {NULL, (void*)&arg__1};
6765 void* args[2] = {NULL, (void*)&arg__1};
6760 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6766 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6761 if (result) { Py_DECREF(result); }
6767 if (result) { Py_DECREF(result); }
6762 Py_DECREF(obj);
6768 Py_DECREF(obj);
6763 return;
6769 return;
6764 }
6770 }
6765 }
6771 }
6766 elfInfoWdgt::wheelEvent(arg__1);
6772 elfInfoWdgt::wheelEvent(arg__1);
6767 }
6773 }
6768 elfInfoWdgt* PythonQtWrapper_elfInfoWdgt::new_elfInfoWdgt(QWidget* parent)
6774 elfInfoWdgt* PythonQtWrapper_elfInfoWdgt::new_elfInfoWdgt(QWidget* parent)
6769 {
6775 {
6770 return new PythonQtShell_elfInfoWdgt(parent); }
6776 return new PythonQtShell_elfInfoWdgt(parent); }
6771
6777
6772
6778
6773
6779
6774 elfparser* PythonQtWrapper_elfparser::new_elfparser()
6780 elfparser* PythonQtWrapper_elfparser::new_elfparser()
6775 {
6781 {
6776 return new elfparser(); }
6782 return new elfparser(); }
6777
6783
6778 int PythonQtWrapper_elfparser::closeFile(elfparser* theWrappedObject)
6784 int PythonQtWrapper_elfparser::closeFile(elfparser* theWrappedObject)
6779 {
6785 {
6780 return ( theWrappedObject->closeFile());
6786 return ( theWrappedObject->closeFile());
6781 }
6787 }
6782
6788
6783 QString PythonQtWrapper_elfparser::getABI(elfparser* theWrappedObject)
6789 QString PythonQtWrapper_elfparser::getABI(elfparser* theWrappedObject)
6784 {
6790 {
6785 return ( theWrappedObject->getABI());
6791 return ( theWrappedObject->getABI());
6786 }
6792 }
6787
6793
6788 QString PythonQtWrapper_elfparser::getArchitecture(elfparser* theWrappedObject)
6794 QString PythonQtWrapper_elfparser::getArchitecture(elfparser* theWrappedObject)
6789 {
6795 {
6790 return ( theWrappedObject->getArchitecture());
6796 return ( theWrappedObject->getArchitecture());
6791 }
6797 }
6792
6798
6793 QString PythonQtWrapper_elfparser::getClass(elfparser* theWrappedObject)
6799 QString PythonQtWrapper_elfparser::getClass(elfparser* theWrappedObject)
6794 {
6800 {
6795 return ( theWrappedObject->getClass());
6801 return ( theWrappedObject->getClass());
6796 }
6802 }
6797
6803
6798 QString PythonQtWrapper_elfparser::getEndianness(elfparser* theWrappedObject)
6804 QString PythonQtWrapper_elfparser::getEndianness(elfparser* theWrappedObject)
6799 {
6805 {
6800 return ( theWrappedObject->getEndianness());
6806 return ( theWrappedObject->getEndianness());
6801 }
6807 }
6802
6808
6803 qint64 PythonQtWrapper_elfparser::getEntryPointAddress(elfparser* theWrappedObject)
6809 qint64 PythonQtWrapper_elfparser::getEntryPointAddress(elfparser* theWrappedObject)
6804 {
6810 {
6805 return ( theWrappedObject->getEntryPointAddress());
6811 return ( theWrappedObject->getEntryPointAddress());
6806 }
6812 }
6807
6813
6808 bool PythonQtWrapper_elfparser::getSectionData(elfparser* theWrappedObject, int index, char** buffer)
6814 bool PythonQtWrapper_elfparser::getSectionData(elfparser* theWrappedObject, int index, char** buffer)
6809 {
6815 {
6810 return ( theWrappedObject->getSectionData(index, buffer));
6816 return ( theWrappedObject->getSectionData(index, buffer));
6811 }
6817 }
6812
6818
6813 qint64 PythonQtWrapper_elfparser::getSectionDatasz(elfparser* theWrappedObject, int index)
6819 qint64 PythonQtWrapper_elfparser::getSectionDatasz(elfparser* theWrappedObject, int index)
6814 {
6820 {
6815 return ( theWrappedObject->getSectionDatasz(index));
6821 return ( theWrappedObject->getSectionDatasz(index));
6816 }
6822 }
6817
6823
6818 qint64 PythonQtWrapper_elfparser::getSectionMemsz(elfparser* theWrappedObject, int index)
6824 qint64 PythonQtWrapper_elfparser::getSectionMemsz(elfparser* theWrappedObject, int index)
6819 {
6825 {
6820 return ( theWrappedObject->getSectionMemsz(index));
6826 return ( theWrappedObject->getSectionMemsz(index));
6821 }
6827 }
6822
6828
6823 QString PythonQtWrapper_elfparser::getSectionName(elfparser* theWrappedObject, int index)
6829 QString PythonQtWrapper_elfparser::getSectionName(elfparser* theWrappedObject, int index)
6824 {
6830 {
6825 return ( theWrappedObject->getSectionName(index));
6831 return ( theWrappedObject->getSectionName(index));
6826 }
6832 }
6827
6833
6828 qint64 PythonQtWrapper_elfparser::getSectionPaddr(elfparser* theWrappedObject, int index)
6834 qint64 PythonQtWrapper_elfparser::getSectionPaddr(elfparser* theWrappedObject, int index)
6829 {
6835 {
6830 return ( theWrappedObject->getSectionPaddr(index));
6836 return ( theWrappedObject->getSectionPaddr(index));
6831 }
6837 }
6832
6838
6833 QString PythonQtWrapper_elfparser::getSectionType(elfparser* theWrappedObject, int index)
6839 QString PythonQtWrapper_elfparser::getSectionType(elfparser* theWrappedObject, int index)
6834 {
6840 {
6835 return ( theWrappedObject->getSectionType(index));
6841 return ( theWrappedObject->getSectionType(index));
6836 }
6842 }
6837
6843
6838 int PythonQtWrapper_elfparser::getSectioncount(elfparser* theWrappedObject)
6844 int PythonQtWrapper_elfparser::getSectioncount(elfparser* theWrappedObject)
6839 {
6845 {
6840 return ( theWrappedObject->getSectioncount());
6846 return ( theWrappedObject->getSectioncount());
6841 }
6847 }
6842
6848
6843 qint64 PythonQtWrapper_elfparser::getSegmentFilesz(elfparser* theWrappedObject, int index)
6849 qint64 PythonQtWrapper_elfparser::getSegmentFilesz(elfparser* theWrappedObject, int index)
6844 {
6850 {
6845 return ( theWrappedObject->getSegmentFilesz(index));
6851 return ( theWrappedObject->getSegmentFilesz(index));
6846 }
6852 }
6847
6853
6848 QString PythonQtWrapper_elfparser::getSegmentFlags(elfparser* theWrappedObject, int index)
6854 QString PythonQtWrapper_elfparser::getSegmentFlags(elfparser* theWrappedObject, int index)
6849 {
6855 {
6850 return ( theWrappedObject->getSegmentFlags(index));
6856 return ( theWrappedObject->getSegmentFlags(index));
6851 }
6857 }
6852
6858
6853 qint64 PythonQtWrapper_elfparser::getSegmentMemsz(elfparser* theWrappedObject, int index)
6859 qint64 PythonQtWrapper_elfparser::getSegmentMemsz(elfparser* theWrappedObject, int index)
6854 {
6860 {
6855 return ( theWrappedObject->getSegmentMemsz(index));
6861 return ( theWrappedObject->getSegmentMemsz(index));
6856 }
6862 }
6857
6863
6858 qint64 PythonQtWrapper_elfparser::getSegmentOffset(elfparser* theWrappedObject, int index)
6864 qint64 PythonQtWrapper_elfparser::getSegmentOffset(elfparser* theWrappedObject, int index)
6859 {
6865 {
6860 return ( theWrappedObject->getSegmentOffset(index));
6866 return ( theWrappedObject->getSegmentOffset(index));
6861 }
6867 }
6862
6868
6863 qint64 PythonQtWrapper_elfparser::getSegmentPaddr(elfparser* theWrappedObject, int index)
6869 qint64 PythonQtWrapper_elfparser::getSegmentPaddr(elfparser* theWrappedObject, int index)
6864 {
6870 {
6865 return ( theWrappedObject->getSegmentPaddr(index));
6871 return ( theWrappedObject->getSegmentPaddr(index));
6866 }
6872 }
6867
6873
6868 QString PythonQtWrapper_elfparser::getSegmentType(elfparser* theWrappedObject, int index)
6874 QString PythonQtWrapper_elfparser::getSegmentType(elfparser* theWrappedObject, int index)
6869 {
6875 {
6870 return ( theWrappedObject->getSegmentType(index));
6876 return ( theWrappedObject->getSegmentType(index));
6871 }
6877 }
6872
6878
6873 qint64 PythonQtWrapper_elfparser::getSegmentVaddr(elfparser* theWrappedObject, int index)
6879 qint64 PythonQtWrapper_elfparser::getSegmentVaddr(elfparser* theWrappedObject, int index)
6874 {
6880 {
6875 return ( theWrappedObject->getSegmentVaddr(index));
6881 return ( theWrappedObject->getSegmentVaddr(index));
6876 }
6882 }
6877
6883
6878 int PythonQtWrapper_elfparser::getSegmentcount(elfparser* theWrappedObject)
6884 int PythonQtWrapper_elfparser::getSegmentcount(elfparser* theWrappedObject)
6879 {
6885 {
6880 return ( theWrappedObject->getSegmentcount());
6886 return ( theWrappedObject->getSegmentcount());
6881 }
6887 }
6882
6888
6883 QString PythonQtWrapper_elfparser::getType(elfparser* theWrappedObject)
6889 QString PythonQtWrapper_elfparser::getType(elfparser* theWrappedObject)
6884 {
6890 {
6885 return ( theWrappedObject->getType());
6891 return ( theWrappedObject->getType());
6886 }
6892 }
6887
6893
6888 qint64 PythonQtWrapper_elfparser::getVersion(elfparser* theWrappedObject)
6894 qint64 PythonQtWrapper_elfparser::getVersion(elfparser* theWrappedObject)
6889 {
6895 {
6890 return ( theWrappedObject->getVersion());
6896 return ( theWrappedObject->getVersion());
6891 }
6897 }
6892
6898
6893 bool PythonQtWrapper_elfparser::static_elfparser_isElf(const QString& File)
6899 bool PythonQtWrapper_elfparser::static_elfparser_isElf(const QString& File)
6894 {
6900 {
6895 return (elfparser::isElf(File));
6901 return (elfparser::isElf(File));
6896 }
6902 }
6897
6903
6898 bool PythonQtWrapper_elfparser::iself(elfparser* theWrappedObject)
6904 bool PythonQtWrapper_elfparser::iself(elfparser* theWrappedObject)
6899 {
6905 {
6900 return ( theWrappedObject->iself());
6906 return ( theWrappedObject->iself());
6901 }
6907 }
6902
6908
6903 bool PythonQtWrapper_elfparser::isopened(elfparser* theWrappedObject)
6909 bool PythonQtWrapper_elfparser::isopened(elfparser* theWrappedObject)
6904 {
6910 {
6905 return ( theWrappedObject->isopened());
6911 return ( theWrappedObject->isopened());
6906 }
6912 }
6907
6913
6908 int PythonQtWrapper_elfparser::setFilename(elfparser* theWrappedObject, const QString& name)
6914 int PythonQtWrapper_elfparser::setFilename(elfparser* theWrappedObject, const QString& name)
6909 {
6915 {
6910 return ( theWrappedObject->setFilename(name));
6916 return ( theWrappedObject->setFilename(name));
6911 }
6917 }
6912
6918
6913
6919
6914
6920
6915 PythonQtShell_srecFile::~PythonQtShell_srecFile() {
6921 PythonQtShell_srecFile::~PythonQtShell_srecFile() {
6916 PythonQtPrivate* priv = PythonQt::priv();
6922 PythonQtPrivate* priv = PythonQt::priv();
6917 if (priv) { priv->shellClassDeleted(this); }
6923 if (priv) { priv->shellClassDeleted(this); }
6918 }
6924 }
6919 int PythonQtShell_srecFile::closeFile()
6925 int PythonQtShell_srecFile::closeFile()
6920 {
6926 {
6921 if (_wrapper) {
6927 if (_wrapper) {
6922 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
6928 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
6923 PyErr_Clear();
6929 PyErr_Clear();
6924 if (obj && !PythonQtSlotFunction_Check(obj)) {
6930 if (obj && !PythonQtSlotFunction_Check(obj)) {
6925 static const char* argumentList[] ={"int"};
6931 static const char* argumentList[] ={"int"};
6926 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6932 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6927 int returnValue;
6933 int returnValue;
6928 void* args[1] = {NULL};
6934 void* args[1] = {NULL};
6929 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6935 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6930 if (result) {
6936 if (result) {
6931 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6937 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6932 if (args[0]!=&returnValue) {
6938 if (args[0]!=&returnValue) {
6933 if (args[0]==NULL) {
6939 if (args[0]==NULL) {
6934 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
6940 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
6935 } else {
6941 } else {
6936 returnValue = *((int*)args[0]);
6942 returnValue = *((int*)args[0]);
6937 }
6943 }
6938 }
6944 }
6939 }
6945 }
6940 if (result) { Py_DECREF(result); }
6946 if (result) { Py_DECREF(result); }
6941 Py_DECREF(obj);
6947 Py_DECREF(obj);
6942 return returnValue;
6948 return returnValue;
6943 }
6949 }
6944 }
6950 }
6945 return srecFile::closeFile();
6951 return srecFile::closeFile();
6946 }
6952 }
6947 QList<codeFragment* > PythonQtShell_srecFile::getFragments()
6953 QList<codeFragment* > PythonQtShell_srecFile::getFragments()
6948 {
6954 {
6949 if (_wrapper) {
6955 if (_wrapper) {
6950 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
6956 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
6951 PyErr_Clear();
6957 PyErr_Clear();
6952 if (obj && !PythonQtSlotFunction_Check(obj)) {
6958 if (obj && !PythonQtSlotFunction_Check(obj)) {
6953 static const char* argumentList[] ={"QList<codeFragment* >"};
6959 static const char* argumentList[] ={"QList<codeFragment* >"};
6954 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6960 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6955 QList<codeFragment* > returnValue;
6961 QList<codeFragment* > returnValue;
6956 void* args[1] = {NULL};
6962 void* args[1] = {NULL};
6957 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6963 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6958 if (result) {
6964 if (result) {
6959 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6965 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6960 if (args[0]!=&returnValue) {
6966 if (args[0]!=&returnValue) {
6961 if (args[0]==NULL) {
6967 if (args[0]==NULL) {
6962 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
6968 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
6963 } else {
6969 } else {
6964 returnValue = *((QList<codeFragment* >*)args[0]);
6970 returnValue = *((QList<codeFragment* >*)args[0]);
6965 }
6971 }
6966 }
6972 }
6967 }
6973 }
6968 if (result) { Py_DECREF(result); }
6974 if (result) { Py_DECREF(result); }
6969 Py_DECREF(obj);
6975 Py_DECREF(obj);
6970 return returnValue;
6976 return returnValue;
6971 }
6977 }
6972 }
6978 }
6973 return srecFile::getFragments();
6979 return srecFile::getFragments();
6974 }
6980 }
6975 bool PythonQtShell_srecFile::isopened()
6981 bool PythonQtShell_srecFile::isopened()
6976 {
6982 {
6977 if (_wrapper) {
6983 if (_wrapper) {
6978 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
6984 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
6979 PyErr_Clear();
6985 PyErr_Clear();
6980 if (obj && !PythonQtSlotFunction_Check(obj)) {
6986 if (obj && !PythonQtSlotFunction_Check(obj)) {
6981 static const char* argumentList[] ={"bool"};
6987 static const char* argumentList[] ={"bool"};
6982 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6988 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6983 bool returnValue;
6989 bool returnValue;
6984 void* args[1] = {NULL};
6990 void* args[1] = {NULL};
6985 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6991 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6986 if (result) {
6992 if (result) {
6987 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6993 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6988 if (args[0]!=&returnValue) {
6994 if (args[0]!=&returnValue) {
6989 if (args[0]==NULL) {
6995 if (args[0]==NULL) {
6990 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
6996 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
6991 } else {
6997 } else {
6992 returnValue = *((bool*)args[0]);
6998 returnValue = *((bool*)args[0]);
6993 }
6999 }
6994 }
7000 }
6995 }
7001 }
6996 if (result) { Py_DECREF(result); }
7002 if (result) { Py_DECREF(result); }
6997 Py_DECREF(obj);
7003 Py_DECREF(obj);
6998 return returnValue;
7004 return returnValue;
6999 }
7005 }
7000 }
7006 }
7001 return srecFile::isopened();
7007 return srecFile::isopened();
7002 }
7008 }
7003 bool PythonQtShell_srecFile::openFile(const QString& File)
7009 bool PythonQtShell_srecFile::openFile(const QString& File)
7004 {
7010 {
7005 if (_wrapper) {
7011 if (_wrapper) {
7006 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
7012 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
7007 PyErr_Clear();
7013 PyErr_Clear();
7008 if (obj && !PythonQtSlotFunction_Check(obj)) {
7014 if (obj && !PythonQtSlotFunction_Check(obj)) {
7009 static const char* argumentList[] ={"bool" , "const QString&"};
7015 static const char* argumentList[] ={"bool" , "const QString&"};
7010 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7016 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7011 bool returnValue;
7017 bool returnValue;
7012 void* args[2] = {NULL, (void*)&File};
7018 void* args[2] = {NULL, (void*)&File};
7013 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7019 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7014 if (result) {
7020 if (result) {
7015 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7021 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7016 if (args[0]!=&returnValue) {
7022 if (args[0]!=&returnValue) {
7017 if (args[0]==NULL) {
7023 if (args[0]==NULL) {
7018 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
7024 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
7019 } else {
7025 } else {
7020 returnValue = *((bool*)args[0]);
7026 returnValue = *((bool*)args[0]);
7021 }
7027 }
7022 }
7028 }
7023 }
7029 }
7024 if (result) { Py_DECREF(result); }
7030 if (result) { Py_DECREF(result); }
7025 Py_DECREF(obj);
7031 Py_DECREF(obj);
7026 return returnValue;
7032 return returnValue;
7027 }
7033 }
7028 }
7034 }
7029 return srecFile::openFile(File);
7035 return srecFile::openFile(File);
7030 }
7036 }
7031 srecFile* PythonQtWrapper_srecFile::new_srecFile()
7037 srecFile* PythonQtWrapper_srecFile::new_srecFile()
7032 {
7038 {
7033 return new PythonQtShell_srecFile(); }
7039 return new PythonQtShell_srecFile(); }
7034
7040
7035 srecFile* PythonQtWrapper_srecFile::new_srecFile(const QString& File)
7041 srecFile* PythonQtWrapper_srecFile::new_srecFile(const QString& File)
7036 {
7042 {
7037 return new PythonQtShell_srecFile(File); }
7043 return new PythonQtShell_srecFile(File); }
7038
7044
7039 srecFile* PythonQtWrapper_srecFile::new_srecFile(const QStringList& Files)
7045 srecFile* PythonQtWrapper_srecFile::new_srecFile(const QStringList& Files)
7040 {
7046 {
7041 return new PythonQtShell_srecFile(Files); }
7047 return new PythonQtShell_srecFile(Files); }
7042
7048
7043 int PythonQtWrapper_srecFile::closeFile(srecFile* theWrappedObject)
7049 int PythonQtWrapper_srecFile::closeFile(srecFile* theWrappedObject)
7044 {
7050 {
7045 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_closeFile());
7051 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_closeFile());
7046 }
7052 }
7047
7053
7054 int PythonQtWrapper_srecFile::getFragmentAddress(srecFile* theWrappedObject, int index)
7055 {
7056 return ( theWrappedObject->getFragmentAddress(index));
7057 }
7058
7059 bool PythonQtWrapper_srecFile::getFragmentData(srecFile* theWrappedObject, int index, char** buffer)
7060 {
7061 return ( theWrappedObject->getFragmentData(index, buffer));
7062 }
7063
7064 QString PythonQtWrapper_srecFile::getFragmentHeader(srecFile* theWrappedObject, int index)
7065 {
7066 return ( theWrappedObject->getFragmentHeader(index));
7067 }
7068
7069 int PythonQtWrapper_srecFile::getFragmentSize(srecFile* theWrappedObject, int index)
7070 {
7071 return ( theWrappedObject->getFragmentSize(index));
7072 }
7073
7048 QList<codeFragment* > PythonQtWrapper_srecFile::getFragments(srecFile* theWrappedObject)
7074 QList<codeFragment* > PythonQtWrapper_srecFile::getFragments(srecFile* theWrappedObject)
7049 {
7075 {
7050 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_getFragments());
7076 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_getFragments());
7051 }
7077 }
7052
7078
7079 int PythonQtWrapper_srecFile::getFragmentsCount(srecFile* theWrappedObject)
7080 {
7081 return ( theWrappedObject->getFragmentsCount());
7082 }
7083
7084 bool PythonQtWrapper_srecFile::isSREC(srecFile* theWrappedObject)
7085 {
7086 return ( theWrappedObject->isSREC());
7087 }
7088
7089 bool PythonQtWrapper_srecFile::static_srecFile_isSREC(const QString& File)
7090 {
7091 return (srecFile::isSREC(File));
7092 }
7093
7053 bool PythonQtWrapper_srecFile::isopened(srecFile* theWrappedObject)
7094 bool PythonQtWrapper_srecFile::isopened(srecFile* theWrappedObject)
7054 {
7095 {
7055 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_isopened());
7096 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_isopened());
7056 }
7097 }
7057
7098
7099 int PythonQtWrapper_srecFile::lineCount(srecFile* theWrappedObject)
7100 {
7101 return ( theWrappedObject->lineCount());
7102 }
7103
7058 bool PythonQtWrapper_srecFile::openFile(srecFile* theWrappedObject, const QString& File)
7104 bool PythonQtWrapper_srecFile::openFile(srecFile* theWrappedObject, const QString& File)
7059 {
7105 {
7060 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_openFile(File));
7106 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_openFile(File));
7061 }
7107 }
7062
7108
7063 bool PythonQtWrapper_srecFile::openFiles(srecFile* theWrappedObject, const QStringList& Files)
7109 bool PythonQtWrapper_srecFile::openFiles(srecFile* theWrappedObject, const QStringList& Files)
7064 {
7110 {
7065 return ( theWrappedObject->openFiles(Files));
7111 return ( theWrappedObject->openFiles(Files));
7066 }
7112 }
7067
7113
7068
7114 bool PythonQtWrapper_srecFile::static_srecFile_toSrec(QList<codeFragment* > fragments, const QString& File)
7115 {
7116 return (srecFile::toSrec(fragments, File));
7117 }
7118
7119
7120
7121 PythonQtShell_srecFileWidget::~PythonQtShell_srecFileWidget() {
7122 PythonQtPrivate* priv = PythonQt::priv();
7123 if (priv) { priv->shellClassDeleted(this); }
7124 }
7125 void PythonQtShell_srecFileWidget::actionEvent(QActionEvent* arg__1)
7126 {
7127 if (_wrapper) {
7128 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
7129 PyErr_Clear();
7130 if (obj && !PythonQtSlotFunction_Check(obj)) {
7131 static const char* argumentList[] ={"" , "QActionEvent*"};
7132 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7133 void* args[2] = {NULL, (void*)&arg__1};
7134 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7135 if (result) { Py_DECREF(result); }
7136 Py_DECREF(obj);
7137 return;
7138 }
7139 }
7140 srecFileWidget::actionEvent(arg__1);
7141 }
7142 void PythonQtShell_srecFileWidget::changeEvent(QEvent* arg__1)
7143 {
7144 if (_wrapper) {
7145 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
7146 PyErr_Clear();
7147 if (obj && !PythonQtSlotFunction_Check(obj)) {
7148 static const char* argumentList[] ={"" , "QEvent*"};
7149 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7150 void* args[2] = {NULL, (void*)&arg__1};
7151 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7152 if (result) { Py_DECREF(result); }
7153 Py_DECREF(obj);
7154 return;
7155 }
7156 }
7157 srecFileWidget::changeEvent(arg__1);
7158 }
7159 void PythonQtShell_srecFileWidget::childEvent(QChildEvent* arg__1)
7160 {
7161 if (_wrapper) {
7162 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
7163 PyErr_Clear();
7164 if (obj && !PythonQtSlotFunction_Check(obj)) {
7165 static const char* argumentList[] ={"" , "QChildEvent*"};
7166 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7167 void* args[2] = {NULL, (void*)&arg__1};
7168 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7169 if (result) { Py_DECREF(result); }
7170 Py_DECREF(obj);
7171 return;
7172 }
7173 }
7174 srecFileWidget::childEvent(arg__1);
7175 }
7176 void PythonQtShell_srecFileWidget::closeEvent(QCloseEvent* arg__1)
7177 {
7178 if (_wrapper) {
7179 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
7180 PyErr_Clear();
7181 if (obj && !PythonQtSlotFunction_Check(obj)) {
7182 static const char* argumentList[] ={"" , "QCloseEvent*"};
7183 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7184 void* args[2] = {NULL, (void*)&arg__1};
7185 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7186 if (result) { Py_DECREF(result); }
7187 Py_DECREF(obj);
7188 return;
7189 }
7190 }
7191 srecFileWidget::closeEvent(arg__1);
7192 }
7193 void PythonQtShell_srecFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
7194 {
7195 if (_wrapper) {
7196 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
7197 PyErr_Clear();
7198 if (obj && !PythonQtSlotFunction_Check(obj)) {
7199 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
7200 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7201 void* args[2] = {NULL, (void*)&arg__1};
7202 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7203 if (result) { Py_DECREF(result); }
7204 Py_DECREF(obj);
7205 return;
7206 }
7207 }
7208 srecFileWidget::contextMenuEvent(arg__1);
7209 }
7210 void PythonQtShell_srecFileWidget::customEvent(QEvent* arg__1)
7211 {
7212 if (_wrapper) {
7213 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
7214 PyErr_Clear();
7215 if (obj && !PythonQtSlotFunction_Check(obj)) {
7216 static const char* argumentList[] ={"" , "QEvent*"};
7217 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7218 void* args[2] = {NULL, (void*)&arg__1};
7219 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7220 if (result) { Py_DECREF(result); }
7221 Py_DECREF(obj);
7222 return;
7223 }
7224 }
7225 srecFileWidget::customEvent(arg__1);
7226 }
7227 int PythonQtShell_srecFileWidget::devType() const
7228 {
7229 if (_wrapper) {
7230 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
7231 PyErr_Clear();
7232 if (obj && !PythonQtSlotFunction_Check(obj)) {
7233 static const char* argumentList[] ={"int"};
7234 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7235 int returnValue;
7236 void* args[1] = {NULL};
7237 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7238 if (result) {
7239 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7240 if (args[0]!=&returnValue) {
7241 if (args[0]==NULL) {
7242 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
7243 } else {
7244 returnValue = *((int*)args[0]);
7245 }
7246 }
7247 }
7248 if (result) { Py_DECREF(result); }
7249 Py_DECREF(obj);
7250 return returnValue;
7251 }
7252 }
7253 return srecFileWidget::devType();
7254 }
7255 void PythonQtShell_srecFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
7256 {
7257 if (_wrapper) {
7258 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
7259 PyErr_Clear();
7260 if (obj && !PythonQtSlotFunction_Check(obj)) {
7261 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
7262 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7263 void* args[2] = {NULL, (void*)&arg__1};
7264 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7265 if (result) { Py_DECREF(result); }
7266 Py_DECREF(obj);
7267 return;
7268 }
7269 }
7270 srecFileWidget::dragEnterEvent(arg__1);
7271 }
7272 void PythonQtShell_srecFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
7273 {
7274 if (_wrapper) {
7275 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
7276 PyErr_Clear();
7277 if (obj && !PythonQtSlotFunction_Check(obj)) {
7278 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
7279 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7280 void* args[2] = {NULL, (void*)&arg__1};
7281 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7282 if (result) { Py_DECREF(result); }
7283 Py_DECREF(obj);
7284 return;
7285 }
7286 }
7287 srecFileWidget::dragLeaveEvent(arg__1);
7288 }
7289 void PythonQtShell_srecFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
7290 {
7291 if (_wrapper) {
7292 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
7293 PyErr_Clear();
7294 if (obj && !PythonQtSlotFunction_Check(obj)) {
7295 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
7296 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7297 void* args[2] = {NULL, (void*)&arg__1};
7298 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7299 if (result) { Py_DECREF(result); }
7300 Py_DECREF(obj);
7301 return;
7302 }
7303 }
7304 srecFileWidget::dragMoveEvent(arg__1);
7305 }
7306 void PythonQtShell_srecFileWidget::dropEvent(QDropEvent* arg__1)
7307 {
7308 if (_wrapper) {
7309 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
7310 PyErr_Clear();
7311 if (obj && !PythonQtSlotFunction_Check(obj)) {
7312 static const char* argumentList[] ={"" , "QDropEvent*"};
7313 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7314 void* args[2] = {NULL, (void*)&arg__1};
7315 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7316 if (result) { Py_DECREF(result); }
7317 Py_DECREF(obj);
7318 return;
7319 }
7320 }
7321 srecFileWidget::dropEvent(arg__1);
7322 }
7323 void PythonQtShell_srecFileWidget::enterEvent(QEvent* arg__1)
7324 {
7325 if (_wrapper) {
7326 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
7327 PyErr_Clear();
7328 if (obj && !PythonQtSlotFunction_Check(obj)) {
7329 static const char* argumentList[] ={"" , "QEvent*"};
7330 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7331 void* args[2] = {NULL, (void*)&arg__1};
7332 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7333 if (result) { Py_DECREF(result); }
7334 Py_DECREF(obj);
7335 return;
7336 }
7337 }
7338 srecFileWidget::enterEvent(arg__1);
7339 }
7340 bool PythonQtShell_srecFileWidget::event(QEvent* arg__1)
7341 {
7342 if (_wrapper) {
7343 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
7344 PyErr_Clear();
7345 if (obj && !PythonQtSlotFunction_Check(obj)) {
7346 static const char* argumentList[] ={"bool" , "QEvent*"};
7347 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7348 bool returnValue;
7349 void* args[2] = {NULL, (void*)&arg__1};
7350 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7351 if (result) {
7352 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7353 if (args[0]!=&returnValue) {
7354 if (args[0]==NULL) {
7355 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
7356 } else {
7357 returnValue = *((bool*)args[0]);
7358 }
7359 }
7360 }
7361 if (result) { Py_DECREF(result); }
7362 Py_DECREF(obj);
7363 return returnValue;
7364 }
7365 }
7366 return srecFileWidget::event(arg__1);
7367 }
7368 bool PythonQtShell_srecFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
7369 {
7370 if (_wrapper) {
7371 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
7372 PyErr_Clear();
7373 if (obj && !PythonQtSlotFunction_Check(obj)) {
7374 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
7375 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
7376 bool returnValue;
7377 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
7378 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7379 if (result) {
7380 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7381 if (args[0]!=&returnValue) {
7382 if (args[0]==NULL) {
7383 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
7384 } else {
7385 returnValue = *((bool*)args[0]);
7386 }
7387 }
7388 }
7389 if (result) { Py_DECREF(result); }
7390 Py_DECREF(obj);
7391 return returnValue;
7392 }
7393 }
7394 return srecFileWidget::eventFilter(arg__1, arg__2);
7395 }
7396 void PythonQtShell_srecFileWidget::focusInEvent(QFocusEvent* arg__1)
7397 {
7398 if (_wrapper) {
7399 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
7400 PyErr_Clear();
7401 if (obj && !PythonQtSlotFunction_Check(obj)) {
7402 static const char* argumentList[] ={"" , "QFocusEvent*"};
7403 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7404 void* args[2] = {NULL, (void*)&arg__1};
7405 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7406 if (result) { Py_DECREF(result); }
7407 Py_DECREF(obj);
7408 return;
7409 }
7410 }
7411 srecFileWidget::focusInEvent(arg__1);
7412 }
7413 bool PythonQtShell_srecFileWidget::focusNextPrevChild(bool next)
7414 {
7415 if (_wrapper) {
7416 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
7417 PyErr_Clear();
7418 if (obj && !PythonQtSlotFunction_Check(obj)) {
7419 static const char* argumentList[] ={"bool" , "bool"};
7420 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7421 bool returnValue;
7422 void* args[2] = {NULL, (void*)&next};
7423 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7424 if (result) {
7425 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7426 if (args[0]!=&returnValue) {
7427 if (args[0]==NULL) {
7428 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
7429 } else {
7430 returnValue = *((bool*)args[0]);
7431 }
7432 }
7433 }
7434 if (result) { Py_DECREF(result); }
7435 Py_DECREF(obj);
7436 return returnValue;
7437 }
7438 }
7439 return srecFileWidget::focusNextPrevChild(next);
7440 }
7441 void PythonQtShell_srecFileWidget::focusOutEvent(QFocusEvent* arg__1)
7442 {
7443 if (_wrapper) {
7444 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
7445 PyErr_Clear();
7446 if (obj && !PythonQtSlotFunction_Check(obj)) {
7447 static const char* argumentList[] ={"" , "QFocusEvent*"};
7448 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7449 void* args[2] = {NULL, (void*)&arg__1};
7450 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7451 if (result) { Py_DECREF(result); }
7452 Py_DECREF(obj);
7453 return;
7454 }
7455 }
7456 srecFileWidget::focusOutEvent(arg__1);
7457 }
7458 bool PythonQtShell_srecFileWidget::hasHeightForWidth() const
7459 {
7460 if (_wrapper) {
7461 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
7462 PyErr_Clear();
7463 if (obj && !PythonQtSlotFunction_Check(obj)) {
7464 static const char* argumentList[] ={"bool"};
7465 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7466 bool returnValue;
7467 void* args[1] = {NULL};
7468 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7469 if (result) {
7470 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7471 if (args[0]!=&returnValue) {
7472 if (args[0]==NULL) {
7473 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
7474 } else {
7475 returnValue = *((bool*)args[0]);
7476 }
7477 }
7478 }
7479 if (result) { Py_DECREF(result); }
7480 Py_DECREF(obj);
7481 return returnValue;
7482 }
7483 }
7484 return srecFileWidget::hasHeightForWidth();
7485 }
7486 int PythonQtShell_srecFileWidget::heightForWidth(int arg__1) const
7487 {
7488 if (_wrapper) {
7489 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
7490 PyErr_Clear();
7491 if (obj && !PythonQtSlotFunction_Check(obj)) {
7492 static const char* argumentList[] ={"int" , "int"};
7493 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7494 int returnValue;
7495 void* args[2] = {NULL, (void*)&arg__1};
7496 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7497 if (result) {
7498 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7499 if (args[0]!=&returnValue) {
7500 if (args[0]==NULL) {
7501 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
7502 } else {
7503 returnValue = *((int*)args[0]);
7504 }
7505 }
7506 }
7507 if (result) { Py_DECREF(result); }
7508 Py_DECREF(obj);
7509 return returnValue;
7510 }
7511 }
7512 return srecFileWidget::heightForWidth(arg__1);
7513 }
7514 void PythonQtShell_srecFileWidget::hideEvent(QHideEvent* arg__1)
7515 {
7516 if (_wrapper) {
7517 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
7518 PyErr_Clear();
7519 if (obj && !PythonQtSlotFunction_Check(obj)) {
7520 static const char* argumentList[] ={"" , "QHideEvent*"};
7521 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7522 void* args[2] = {NULL, (void*)&arg__1};
7523 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7524 if (result) { Py_DECREF(result); }
7525 Py_DECREF(obj);
7526 return;
7527 }
7528 }
7529 srecFileWidget::hideEvent(arg__1);
7530 }
7531 void PythonQtShell_srecFileWidget::initPainter(QPainter* painter) const
7532 {
7533 if (_wrapper) {
7534 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
7535 PyErr_Clear();
7536 if (obj && !PythonQtSlotFunction_Check(obj)) {
7537 static const char* argumentList[] ={"" , "QPainter*"};
7538 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7539 void* args[2] = {NULL, (void*)&painter};
7540 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7541 if (result) { Py_DECREF(result); }
7542 Py_DECREF(obj);
7543 return;
7544 }
7545 }
7546 srecFileWidget::initPainter(painter);
7547 }
7548 void PythonQtShell_srecFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
7549 {
7550 if (_wrapper) {
7551 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
7552 PyErr_Clear();
7553 if (obj && !PythonQtSlotFunction_Check(obj)) {
7554 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
7555 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7556 void* args[2] = {NULL, (void*)&arg__1};
7557 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7558 if (result) { Py_DECREF(result); }
7559 Py_DECREF(obj);
7560 return;
7561 }
7562 }
7563 srecFileWidget::inputMethodEvent(arg__1);
7564 }
7565 QVariant PythonQtShell_srecFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
7566 {
7567 if (_wrapper) {
7568 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
7569 PyErr_Clear();
7570 if (obj && !PythonQtSlotFunction_Check(obj)) {
7571 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
7572 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7573 QVariant returnValue;
7574 void* args[2] = {NULL, (void*)&arg__1};
7575 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7576 if (result) {
7577 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7578 if (args[0]!=&returnValue) {
7579 if (args[0]==NULL) {
7580 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
7581 } else {
7582 returnValue = *((QVariant*)args[0]);
7583 }
7584 }
7585 }
7586 if (result) { Py_DECREF(result); }
7587 Py_DECREF(obj);
7588 return returnValue;
7589 }
7590 }
7591 return srecFileWidget::inputMethodQuery(arg__1);
7592 }
7593 void PythonQtShell_srecFileWidget::keyPressEvent(QKeyEvent* arg__1)
7594 {
7595 if (_wrapper) {
7596 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
7597 PyErr_Clear();
7598 if (obj && !PythonQtSlotFunction_Check(obj)) {
7599 static const char* argumentList[] ={"" , "QKeyEvent*"};
7600 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7601 void* args[2] = {NULL, (void*)&arg__1};
7602 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7603 if (result) { Py_DECREF(result); }
7604 Py_DECREF(obj);
7605 return;
7606 }
7607 }
7608 srecFileWidget::keyPressEvent(arg__1);
7609 }
7610 void PythonQtShell_srecFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
7611 {
7612 if (_wrapper) {
7613 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
7614 PyErr_Clear();
7615 if (obj && !PythonQtSlotFunction_Check(obj)) {
7616 static const char* argumentList[] ={"" , "QKeyEvent*"};
7617 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7618 void* args[2] = {NULL, (void*)&arg__1};
7619 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7620 if (result) { Py_DECREF(result); }
7621 Py_DECREF(obj);
7622 return;
7623 }
7624 }
7625 srecFileWidget::keyReleaseEvent(arg__1);
7626 }
7627 void PythonQtShell_srecFileWidget::leaveEvent(QEvent* arg__1)
7628 {
7629 if (_wrapper) {
7630 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
7631 PyErr_Clear();
7632 if (obj && !PythonQtSlotFunction_Check(obj)) {
7633 static const char* argumentList[] ={"" , "QEvent*"};
7634 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7635 void* args[2] = {NULL, (void*)&arg__1};
7636 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7637 if (result) { Py_DECREF(result); }
7638 Py_DECREF(obj);
7639 return;
7640 }
7641 }
7642 srecFileWidget::leaveEvent(arg__1);
7643 }
7644 int PythonQtShell_srecFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
7645 {
7646 if (_wrapper) {
7647 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
7648 PyErr_Clear();
7649 if (obj && !PythonQtSlotFunction_Check(obj)) {
7650 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
7651 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7652 int returnValue;
7653 void* args[2] = {NULL, (void*)&arg__1};
7654 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7655 if (result) {
7656 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7657 if (args[0]!=&returnValue) {
7658 if (args[0]==NULL) {
7659 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
7660 } else {
7661 returnValue = *((int*)args[0]);
7662 }
7663 }
7664 }
7665 if (result) { Py_DECREF(result); }
7666 Py_DECREF(obj);
7667 return returnValue;
7668 }
7669 }
7670 return srecFileWidget::metric(arg__1);
7671 }
7672 QSize PythonQtShell_srecFileWidget::minimumSizeHint() const
7673 {
7674 if (_wrapper) {
7675 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
7676 PyErr_Clear();
7677 if (obj && !PythonQtSlotFunction_Check(obj)) {
7678 static const char* argumentList[] ={"QSize"};
7679 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7680 QSize returnValue;
7681 void* args[1] = {NULL};
7682 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7683 if (result) {
7684 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7685 if (args[0]!=&returnValue) {
7686 if (args[0]==NULL) {
7687 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
7688 } else {
7689 returnValue = *((QSize*)args[0]);
7690 }
7691 }
7692 }
7693 if (result) { Py_DECREF(result); }
7694 Py_DECREF(obj);
7695 return returnValue;
7696 }
7697 }
7698 return srecFileWidget::minimumSizeHint();
7699 }
7700 void PythonQtShell_srecFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
7701 {
7702 if (_wrapper) {
7703 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
7704 PyErr_Clear();
7705 if (obj && !PythonQtSlotFunction_Check(obj)) {
7706 static const char* argumentList[] ={"" , "QMouseEvent*"};
7707 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7708 void* args[2] = {NULL, (void*)&arg__1};
7709 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7710 if (result) { Py_DECREF(result); }
7711 Py_DECREF(obj);
7712 return;
7713 }
7714 }
7715 srecFileWidget::mouseDoubleClickEvent(arg__1);
7716 }
7717 void PythonQtShell_srecFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
7718 {
7719 if (_wrapper) {
7720 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
7721 PyErr_Clear();
7722 if (obj && !PythonQtSlotFunction_Check(obj)) {
7723 static const char* argumentList[] ={"" , "QMouseEvent*"};
7724 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7725 void* args[2] = {NULL, (void*)&arg__1};
7726 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7727 if (result) { Py_DECREF(result); }
7728 Py_DECREF(obj);
7729 return;
7730 }
7731 }
7732 srecFileWidget::mouseMoveEvent(arg__1);
7733 }
7734 void PythonQtShell_srecFileWidget::mousePressEvent(QMouseEvent* arg__1)
7735 {
7736 if (_wrapper) {
7737 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
7738 PyErr_Clear();
7739 if (obj && !PythonQtSlotFunction_Check(obj)) {
7740 static const char* argumentList[] ={"" , "QMouseEvent*"};
7741 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7742 void* args[2] = {NULL, (void*)&arg__1};
7743 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7744 if (result) { Py_DECREF(result); }
7745 Py_DECREF(obj);
7746 return;
7747 }
7748 }
7749 srecFileWidget::mousePressEvent(arg__1);
7750 }
7751 void PythonQtShell_srecFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
7752 {
7753 if (_wrapper) {
7754 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
7755 PyErr_Clear();
7756 if (obj && !PythonQtSlotFunction_Check(obj)) {
7757 static const char* argumentList[] ={"" , "QMouseEvent*"};
7758 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7759 void* args[2] = {NULL, (void*)&arg__1};
7760 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7761 if (result) { Py_DECREF(result); }
7762 Py_DECREF(obj);
7763 return;
7764 }
7765 }
7766 srecFileWidget::mouseReleaseEvent(arg__1);
7767 }
7768 void PythonQtShell_srecFileWidget::moveEvent(QMoveEvent* arg__1)
7769 {
7770 if (_wrapper) {
7771 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
7772 PyErr_Clear();
7773 if (obj && !PythonQtSlotFunction_Check(obj)) {
7774 static const char* argumentList[] ={"" , "QMoveEvent*"};
7775 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7776 void* args[2] = {NULL, (void*)&arg__1};
7777 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7778 if (result) { Py_DECREF(result); }
7779 Py_DECREF(obj);
7780 return;
7781 }
7782 }
7783 srecFileWidget::moveEvent(arg__1);
7784 }
7785 bool PythonQtShell_srecFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result)
7786 {
7787 if (_wrapper) {
7788 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
7789 PyErr_Clear();
7790 if (obj && !PythonQtSlotFunction_Check(obj)) {
7791 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
7792 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
7793 bool returnValue;
7794 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
7795 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7796 if (result) {
7797 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7798 if (args[0]!=&returnValue) {
7799 if (args[0]==NULL) {
7800 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
7801 } else {
7802 returnValue = *((bool*)args[0]);
7803 }
7804 }
7805 }
7806 if (result) { Py_DECREF(result); }
7807 Py_DECREF(obj);
7808 return returnValue;
7809 }
7810 }
7811 return srecFileWidget::nativeEvent(eventType, message, result);
7812 }
7813 QPaintEngine* PythonQtShell_srecFileWidget::paintEngine() const
7814 {
7815 if (_wrapper) {
7816 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
7817 PyErr_Clear();
7818 if (obj && !PythonQtSlotFunction_Check(obj)) {
7819 static const char* argumentList[] ={"QPaintEngine*"};
7820 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7821 QPaintEngine* returnValue;
7822 void* args[1] = {NULL};
7823 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7824 if (result) {
7825 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7826 if (args[0]!=&returnValue) {
7827 if (args[0]==NULL) {
7828 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
7829 } else {
7830 returnValue = *((QPaintEngine**)args[0]);
7831 }
7832 }
7833 }
7834 if (result) { Py_DECREF(result); }
7835 Py_DECREF(obj);
7836 return returnValue;
7837 }
7838 }
7839 return srecFileWidget::paintEngine();
7840 }
7841 void PythonQtShell_srecFileWidget::paintEvent(QPaintEvent* arg__1)
7842 {
7843 if (_wrapper) {
7844 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
7845 PyErr_Clear();
7846 if (obj && !PythonQtSlotFunction_Check(obj)) {
7847 static const char* argumentList[] ={"" , "QPaintEvent*"};
7848 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7849 void* args[2] = {NULL, (void*)&arg__1};
7850 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7851 if (result) { Py_DECREF(result); }
7852 Py_DECREF(obj);
7853 return;
7854 }
7855 }
7856 srecFileWidget::paintEvent(arg__1);
7857 }
7858 QPaintDevice* PythonQtShell_srecFileWidget::redirected(QPoint* offset) const
7859 {
7860 if (_wrapper) {
7861 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
7862 PyErr_Clear();
7863 if (obj && !PythonQtSlotFunction_Check(obj)) {
7864 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
7865 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7866 QPaintDevice* returnValue;
7867 void* args[2] = {NULL, (void*)&offset};
7868 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7869 if (result) {
7870 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7871 if (args[0]!=&returnValue) {
7872 if (args[0]==NULL) {
7873 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
7874 } else {
7875 returnValue = *((QPaintDevice**)args[0]);
7876 }
7877 }
7878 }
7879 if (result) { Py_DECREF(result); }
7880 Py_DECREF(obj);
7881 return returnValue;
7882 }
7883 }
7884 return srecFileWidget::redirected(offset);
7885 }
7886 void PythonQtShell_srecFileWidget::resizeEvent(QResizeEvent* arg__1)
7887 {
7888 if (_wrapper) {
7889 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
7890 PyErr_Clear();
7891 if (obj && !PythonQtSlotFunction_Check(obj)) {
7892 static const char* argumentList[] ={"" , "QResizeEvent*"};
7893 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7894 void* args[2] = {NULL, (void*)&arg__1};
7895 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7896 if (result) { Py_DECREF(result); }
7897 Py_DECREF(obj);
7898 return;
7899 }
7900 }
7901 srecFileWidget::resizeEvent(arg__1);
7902 }
7903 QPainter* PythonQtShell_srecFileWidget::sharedPainter() const
7904 {
7905 if (_wrapper) {
7906 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
7907 PyErr_Clear();
7908 if (obj && !PythonQtSlotFunction_Check(obj)) {
7909 static const char* argumentList[] ={"QPainter*"};
7910 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7911 QPainter* returnValue;
7912 void* args[1] = {NULL};
7913 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7914 if (result) {
7915 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7916 if (args[0]!=&returnValue) {
7917 if (args[0]==NULL) {
7918 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
7919 } else {
7920 returnValue = *((QPainter**)args[0]);
7921 }
7922 }
7923 }
7924 if (result) { Py_DECREF(result); }
7925 Py_DECREF(obj);
7926 return returnValue;
7927 }
7928 }
7929 return srecFileWidget::sharedPainter();
7930 }
7931 void PythonQtShell_srecFileWidget::showEvent(QShowEvent* arg__1)
7932 {
7933 if (_wrapper) {
7934 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
7935 PyErr_Clear();
7936 if (obj && !PythonQtSlotFunction_Check(obj)) {
7937 static const char* argumentList[] ={"" , "QShowEvent*"};
7938 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7939 void* args[2] = {NULL, (void*)&arg__1};
7940 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7941 if (result) { Py_DECREF(result); }
7942 Py_DECREF(obj);
7943 return;
7944 }
7945 }
7946 srecFileWidget::showEvent(arg__1);
7947 }
7948 QSize PythonQtShell_srecFileWidget::sizeHint() const
7949 {
7950 if (_wrapper) {
7951 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
7952 PyErr_Clear();
7953 if (obj && !PythonQtSlotFunction_Check(obj)) {
7954 static const char* argumentList[] ={"QSize"};
7955 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7956 QSize returnValue;
7957 void* args[1] = {NULL};
7958 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7959 if (result) {
7960 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7961 if (args[0]!=&returnValue) {
7962 if (args[0]==NULL) {
7963 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
7964 } else {
7965 returnValue = *((QSize*)args[0]);
7966 }
7967 }
7968 }
7969 if (result) { Py_DECREF(result); }
7970 Py_DECREF(obj);
7971 return returnValue;
7972 }
7973 }
7974 return srecFileWidget::sizeHint();
7975 }
7976 void PythonQtShell_srecFileWidget::tabletEvent(QTabletEvent* arg__1)
7977 {
7978 if (_wrapper) {
7979 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
7980 PyErr_Clear();
7981 if (obj && !PythonQtSlotFunction_Check(obj)) {
7982 static const char* argumentList[] ={"" , "QTabletEvent*"};
7983 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7984 void* args[2] = {NULL, (void*)&arg__1};
7985 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7986 if (result) { Py_DECREF(result); }
7987 Py_DECREF(obj);
7988 return;
7989 }
7990 }
7991 srecFileWidget::tabletEvent(arg__1);
7992 }
7993 void PythonQtShell_srecFileWidget::timerEvent(QTimerEvent* arg__1)
7994 {
7995 if (_wrapper) {
7996 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
7997 PyErr_Clear();
7998 if (obj && !PythonQtSlotFunction_Check(obj)) {
7999 static const char* argumentList[] ={"" , "QTimerEvent*"};
8000 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8001 void* args[2] = {NULL, (void*)&arg__1};
8002 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8003 if (result) { Py_DECREF(result); }
8004 Py_DECREF(obj);
8005 return;
8006 }
8007 }
8008 srecFileWidget::timerEvent(arg__1);
8009 }
8010 void PythonQtShell_srecFileWidget::wheelEvent(QWheelEvent* arg__1)
8011 {
8012 if (_wrapper) {
8013 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
8014 PyErr_Clear();
8015 if (obj && !PythonQtSlotFunction_Check(obj)) {
8016 static const char* argumentList[] ={"" , "QWheelEvent*"};
8017 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8018 void* args[2] = {NULL, (void*)&arg__1};
8019 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8020 if (result) { Py_DECREF(result); }
8021 Py_DECREF(obj);
8022 return;
8023 }
8024 }
8025 srecFileWidget::wheelEvent(arg__1);
8026 }
8027 srecFileWidget* PythonQtWrapper_srecFileWidget::new_srecFileWidget(QWidget* parent)
8028 {
8029 return new PythonQtShell_srecFileWidget(parent); }
8030
8031
Show file before | Show file after | Hide comments
@@ -1,828 +1,908
1 #include <PythonQt.h>
1 #include <PythonQt.h>
2 #include <QIconEngine>
2 #include <QIconEngine>
3 #include <QObject>
3 #include <QObject>
4 #include <QSpinBox>
4 #include <QSpinBox>
5 #include <QVariant>
5 #include <QVariant>
6 #include <QWidget>
6 #include <QWidget>
7 #include <SocExplorerPlot.h>
7 #include <SocExplorerPlot.h>
8 #include <abstractexecfile.h>
8 #include <abstractbinfile.h>
9 #include <elffile.h>
9 #include <elffile.h>
10 #include <elffilewidget.h>
10 #include <elffilewidget.h>
11 #include <elfinfowdgt.h>
11 #include <elfinfowdgt.h>
12 #include <elfparser.h>
12 #include <elfparser.h>
13 #include <memsizewdgt.h>
13 #include <memsizewdgt.h>
14 #include <qaction.h>
14 #include <qaction.h>
15 #include <qbitmap.h>
15 #include <qbitmap.h>
16 #include <qbytearray.h>
16 #include <qbytearray.h>
17 #include <qcolor.h>
17 #include <qcolor.h>
18 #include <qcoreevent.h>
18 #include <qcoreevent.h>
19 #include <qcursor.h>
19 #include <qcursor.h>
20 #include <qevent.h>
20 #include <qevent.h>
21 #include <qfile.h>
21 #include <qfile.h>
22 #include <qfont.h>
22 #include <qfont.h>
23 #include <qgraphicseffect.h>
23 #include <qgraphicseffect.h>
24 #include <qgraphicsproxywidget.h>
24 #include <qgraphicsproxywidget.h>
25 #include <qhexedit.h>
25 #include <qhexedit.h>
26 #include <qhexspinbox.h>
26 #include <qhexspinbox.h>
27 #include <qkeysequence.h>
27 #include <qkeysequence.h>
28 #include <qlayout.h>
28 #include <qlayout.h>
29 #include <qlineedit.h>
29 #include <qlineedit.h>
30 #include <qlist.h>
30 #include <qlist.h>
31 #include <qlocale.h>
31 #include <qlocale.h>
32 #include <qmargins.h>
32 #include <qmargins.h>
33 #include <qobject.h>
33 #include <qobject.h>
34 #include <qpaintdevice.h>
34 #include <qpaintdevice.h>
35 #include <qpaintengine.h>
35 #include <qpaintengine.h>
36 #include <qpainter.h>
36 #include <qpainter.h>
37 #include <qpalette.h>
37 #include <qpalette.h>
38 #include <qpen.h>
38 #include <qpen.h>
39 #include <qpixmap.h>
39 #include <qpixmap.h>
40 #include <qpoint.h>
40 #include <qpoint.h>
41 #include <qrect.h>
41 #include <qrect.h>
42 #include <qregion.h>
42 #include <qregion.h>
43 #include <qscrollarea.h>
43 #include <qscrollarea.h>
44 #include <qscrollbar.h>
44 #include <qscrollbar.h>
45 #include <qsize.h>
45 #include <qsize.h>
46 #include <qsizepolicy.h>
46 #include <qsizepolicy.h>
47 #include <qspinbox.h>
47 #include <qspinbox.h>
48 #include <qstringlist.h>
48 #include <qstringlist.h>
49 #include <qstyle.h>
49 #include <qstyle.h>
50 #include <qstyleoption.h>
50 #include <qstyleoption.h>
51 #include <qwidget.h>
51 #include <qwidget.h>
52 #include <srecfile.h>
52 #include <srecfile.h>
53 #include <srecfilewidget.h>
53 #include <tcp_terminal_client.h>
54 #include <tcp_terminal_client.h>
54 #include <xbytearray.h>
55 #include <xbytearray.h>
55
56
56
57
57
58
58 class PythonQtShell_ElfFile : public ElfFile
59 class PythonQtShell_ElfFile : public ElfFile
59 {
60 {
60 public:
61 public:
61 PythonQtShell_ElfFile():ElfFile(),_wrapper(NULL) {};
62 PythonQtShell_ElfFile():ElfFile(),_wrapper(NULL) {};
62 PythonQtShell_ElfFile(const QString& File):ElfFile(File),_wrapper(NULL) {};
63 PythonQtShell_ElfFile(const QString& File):ElfFile(File),_wrapper(NULL) {};
63
64
64 ~PythonQtShell_ElfFile();
65 ~PythonQtShell_ElfFile();
65
66
66 virtual int closeFile();
67 virtual int closeFile();
67 virtual QList<codeFragment* > getFragments();
68 virtual QList<codeFragment* > getFragments();
68 virtual bool isopened();
69 virtual bool isopened();
69 virtual bool openFile(const QString& File);
70 virtual bool openFile(const QString& File);
70
71
71 PythonQtInstanceWrapper* _wrapper;
72 PythonQtInstanceWrapper* _wrapper;
72 };
73 };
73
74
74 class PythonQtPublicPromoter_ElfFile : public ElfFile
75 class PythonQtPublicPromoter_ElfFile : public ElfFile
75 { public:
76 { public:
76 inline int promoted_closeFile() { return ElfFile::closeFile(); }
77 inline int promoted_closeFile() { return ElfFile::closeFile(); }
77 inline QList<codeFragment* > promoted_getFragments() { return ElfFile::getFragments(); }
78 inline QList<codeFragment* > promoted_getFragments() { return ElfFile::getFragments(); }
78 inline bool promoted_isopened() { return ElfFile::isopened(); }
79 inline bool promoted_isopened() { return ElfFile::isopened(); }
79 inline bool promoted_openFile(const QString& File) { return ElfFile::openFile(File); }
80 inline bool promoted_openFile(const QString& File) { return ElfFile::openFile(File); }
80 };
81 };
81
82
82 class PythonQtWrapper_ElfFile : public QObject
83 class PythonQtWrapper_ElfFile : public QObject
83 { Q_OBJECT
84 { Q_OBJECT
84 public:
85 public:
85 public slots:
86 public slots:
86 ElfFile* new_ElfFile();
87 ElfFile* new_ElfFile();
87 ElfFile* new_ElfFile(const QString& File);
88 ElfFile* new_ElfFile(const QString& File);
88 void delete_ElfFile(ElfFile* obj) { delete obj; }
89 void delete_ElfFile(ElfFile* obj) { delete obj; }
89 int closeFile(ElfFile* theWrappedObject);
90 int closeFile(ElfFile* theWrappedObject);
90 QString getABI(ElfFile* theWrappedObject);
91 QString getABI(ElfFile* theWrappedObject);
91 QString getArchitecture(ElfFile* theWrappedObject);
92 QString getArchitecture(ElfFile* theWrappedObject);
92 QString getClass(ElfFile* theWrappedObject);
93 QString getClass(ElfFile* theWrappedObject);
93 QString getEndianness(ElfFile* theWrappedObject);
94 QString getEndianness(ElfFile* theWrappedObject);
94 qint64 getEntryPointAddress(ElfFile* theWrappedObject);
95 qint64 getEntryPointAddress(ElfFile* theWrappedObject);
95 QList<codeFragment* > getFragments(ElfFile* theWrappedObject);
96 QList<codeFragment* > getFragments(ElfFile* theWrappedObject);
96 QList<codeFragment* > getFragments(ElfFile* theWrappedObject, QStringList fragmentList);
97 QList<codeFragment* > getFragments(ElfFile* theWrappedObject, QStringList fragmentList);
97 int getSectionCount(ElfFile* theWrappedObject);
98 int getSectionCount(ElfFile* theWrappedObject);
98 bool getSectionData(ElfFile* theWrappedObject, int index, char** buffer);
99 bool getSectionData(ElfFile* theWrappedObject, int index, char** buffer);
99 qint64 getSectionDatasz(ElfFile* theWrappedObject, int index);
100 qint64 getSectionDatasz(ElfFile* theWrappedObject, int index);
100 int getSectionIndex(ElfFile* theWrappedObject, QString name);
101 int getSectionIndex(ElfFile* theWrappedObject, QString name);
101 qint64 getSectionMemsz(ElfFile* theWrappedObject, int index);
102 qint64 getSectionMemsz(ElfFile* theWrappedObject, int index);
102 QString getSectionName(ElfFile* theWrappedObject, int index);
103 QString getSectionName(ElfFile* theWrappedObject, int index);
103 qint64 getSectionPaddr(ElfFile* theWrappedObject, int index);
104 qint64 getSectionPaddr(ElfFile* theWrappedObject, int index);
104 QString getSectionType(ElfFile* theWrappedObject, int index);
105 QString getSectionType(ElfFile* theWrappedObject, int index);
105 int getSegmentCount(ElfFile* theWrappedObject);
106 int getSegmentCount(ElfFile* theWrappedObject);
106 qint64 getSegmentFilesz(ElfFile* theWrappedObject, int index);
107 qint64 getSegmentFilesz(ElfFile* theWrappedObject, int index);
107 QString getSegmentFlags(ElfFile* theWrappedObject, int index);
108 QString getSegmentFlags(ElfFile* theWrappedObject, int index);
108 qint64 getSegmentMemsz(ElfFile* theWrappedObject, int index);
109 qint64 getSegmentMemsz(ElfFile* theWrappedObject, int index);
109 qint64 getSegmentOffset(ElfFile* theWrappedObject, int index);
110 qint64 getSegmentOffset(ElfFile* theWrappedObject, int index);
110 qint64 getSegmentPaddr(ElfFile* theWrappedObject, int index);
111 qint64 getSegmentPaddr(ElfFile* theWrappedObject, int index);
111 QString getSegmentType(ElfFile* theWrappedObject, int index);
112 QString getSegmentType(ElfFile* theWrappedObject, int index);
112 qint64 getSegmentVaddr(ElfFile* theWrappedObject, int index);
113 qint64 getSegmentVaddr(ElfFile* theWrappedObject, int index);
113 quint64 getSymbolAddress(ElfFile* theWrappedObject, int index);
114 quint64 getSymbolAddress(ElfFile* theWrappedObject, int index);
114 int getSymbolCount(ElfFile* theWrappedObject);
115 int getSymbolCount(ElfFile* theWrappedObject);
115 QString getSymbolLinkType(ElfFile* theWrappedObject, int index);
116 QString getSymbolLinkType(ElfFile* theWrappedObject, int index);
116 QString getSymbolName(ElfFile* theWrappedObject, int index);
117 QString getSymbolName(ElfFile* theWrappedObject, int index);
117 int getSymbolSectionIndex(ElfFile* theWrappedObject, int index);
118 int getSymbolSectionIndex(ElfFile* theWrappedObject, int index);
118 QString getSymbolSectionName(ElfFile* theWrappedObject, int index);
119 QString getSymbolSectionName(ElfFile* theWrappedObject, int index);
119 quint64 getSymbolSize(ElfFile* theWrappedObject, int index);
120 quint64 getSymbolSize(ElfFile* theWrappedObject, int index);
120 QString getSymbolType(ElfFile* theWrappedObject, int index);
121 QString getSymbolType(ElfFile* theWrappedObject, int index);
121 QString getType(ElfFile* theWrappedObject);
122 QString getType(ElfFile* theWrappedObject);
122 qint64 getVersion(ElfFile* theWrappedObject);
123 qint64 getVersion(ElfFile* theWrappedObject);
123 bool static_ElfFile_isElf(const QString& File);
124 bool static_ElfFile_isElf(const QString& File);
124 bool iself(ElfFile* theWrappedObject);
125 bool iself(ElfFile* theWrappedObject);
125 bool isopened(ElfFile* theWrappedObject);
126 bool isopened(ElfFile* theWrappedObject);
126 bool openFile(ElfFile* theWrappedObject, const QString& File);
127 bool openFile(ElfFile* theWrappedObject, const QString& File);
128 bool toSrec(ElfFile* theWrappedObject, const QString& File);
127 };
129 };
128
130
129
131
130
132
131
133
132
134
133 class PythonQtShell_MemSizeWdgt : public MemSizeWdgt
135 class PythonQtShell_MemSizeWdgt : public MemSizeWdgt
134 {
136 {
135 public:
137 public:
136 PythonQtShell_MemSizeWdgt(QWidget* parent = 0):MemSizeWdgt(parent),_wrapper(NULL) {};
138 PythonQtShell_MemSizeWdgt(QWidget* parent = 0):MemSizeWdgt(parent),_wrapper(NULL) {};
137 PythonQtShell_MemSizeWdgt(int defaultSize, QWidget* parent = 0):MemSizeWdgt(defaultSize, parent),_wrapper(NULL) {};
139 PythonQtShell_MemSizeWdgt(int defaultSize, QWidget* parent = 0):MemSizeWdgt(defaultSize, parent),_wrapper(NULL) {};
138
140
139 ~PythonQtShell_MemSizeWdgt();
141 ~PythonQtShell_MemSizeWdgt();
140
142
141 virtual void actionEvent(QActionEvent* arg__1);
143 virtual void actionEvent(QActionEvent* arg__1);
142 virtual void changeEvent(QEvent* arg__1);
144 virtual void changeEvent(QEvent* arg__1);
143 virtual void childEvent(QChildEvent* arg__1);
145 virtual void childEvent(QChildEvent* arg__1);
144 virtual void closeEvent(QCloseEvent* arg__1);
146 virtual void closeEvent(QCloseEvent* arg__1);
145 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
147 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
146 virtual void customEvent(QEvent* arg__1);
148 virtual void customEvent(QEvent* arg__1);
147 virtual int devType() const;
149 virtual int devType() const;
148 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
150 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
149 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
151 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
150 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
152 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
151 virtual void dropEvent(QDropEvent* arg__1);
153 virtual void dropEvent(QDropEvent* arg__1);
152 virtual void enterEvent(QEvent* arg__1);
154 virtual void enterEvent(QEvent* arg__1);
153 virtual bool event(QEvent* arg__1);
155 virtual bool event(QEvent* arg__1);
154 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
156 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
155 virtual void focusInEvent(QFocusEvent* arg__1);
157 virtual void focusInEvent(QFocusEvent* arg__1);
156 virtual bool focusNextPrevChild(bool next);
158 virtual bool focusNextPrevChild(bool next);
157 virtual void focusOutEvent(QFocusEvent* arg__1);
159 virtual void focusOutEvent(QFocusEvent* arg__1);
158 virtual bool hasHeightForWidth() const;
160 virtual bool hasHeightForWidth() const;
159 virtual int heightForWidth(int arg__1) const;
161 virtual int heightForWidth(int arg__1) const;
160 virtual void hideEvent(QHideEvent* arg__1);
162 virtual void hideEvent(QHideEvent* arg__1);
161 virtual void initPainter(QPainter* painter) const;
163 virtual void initPainter(QPainter* painter) const;
162 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
164 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
163 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
165 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
164 virtual void keyPressEvent(QKeyEvent* arg__1);
166 virtual void keyPressEvent(QKeyEvent* arg__1);
165 virtual void keyReleaseEvent(QKeyEvent* arg__1);
167 virtual void keyReleaseEvent(QKeyEvent* arg__1);
166 virtual void leaveEvent(QEvent* arg__1);
168 virtual void leaveEvent(QEvent* arg__1);
167 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
169 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
168 virtual QSize minimumSizeHint() const;
170 virtual QSize minimumSizeHint() const;
169 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
171 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
170 virtual void mouseMoveEvent(QMouseEvent* arg__1);
172 virtual void mouseMoveEvent(QMouseEvent* arg__1);
171 virtual void mousePressEvent(QMouseEvent* arg__1);
173 virtual void mousePressEvent(QMouseEvent* arg__1);
172 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
174 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
173 virtual void moveEvent(QMoveEvent* arg__1);
175 virtual void moveEvent(QMoveEvent* arg__1);
174 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
176 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
175 virtual QPaintEngine* paintEngine() const;
177 virtual QPaintEngine* paintEngine() const;
176 virtual void paintEvent(QPaintEvent* arg__1);
178 virtual void paintEvent(QPaintEvent* arg__1);
177 virtual QPaintDevice* redirected(QPoint* offset) const;
179 virtual QPaintDevice* redirected(QPoint* offset) const;
178 virtual void resizeEvent(QResizeEvent* arg__1);
180 virtual void resizeEvent(QResizeEvent* arg__1);
179 virtual QPainter* sharedPainter() const;
181 virtual QPainter* sharedPainter() const;
180 virtual void showEvent(QShowEvent* arg__1);
182 virtual void showEvent(QShowEvent* arg__1);
181 virtual QSize sizeHint() const;
183 virtual QSize sizeHint() const;
182 virtual void tabletEvent(QTabletEvent* arg__1);
184 virtual void tabletEvent(QTabletEvent* arg__1);
183 virtual void timerEvent(QTimerEvent* arg__1);
185 virtual void timerEvent(QTimerEvent* arg__1);
184 virtual void wheelEvent(QWheelEvent* arg__1);
186 virtual void wheelEvent(QWheelEvent* arg__1);
185
187
186 PythonQtInstanceWrapper* _wrapper;
188 PythonQtInstanceWrapper* _wrapper;
187 };
189 };
188
190
189 class PythonQtWrapper_MemSizeWdgt : public QObject
191 class PythonQtWrapper_MemSizeWdgt : public QObject
190 { Q_OBJECT
192 { Q_OBJECT
191 public:
193 public:
192 public slots:
194 public slots:
193 MemSizeWdgt* new_MemSizeWdgt(QWidget* parent = 0);
195 MemSizeWdgt* new_MemSizeWdgt(QWidget* parent = 0);
194 MemSizeWdgt* new_MemSizeWdgt(int defaultSize, QWidget* parent = 0);
196 MemSizeWdgt* new_MemSizeWdgt(int defaultSize, QWidget* parent = 0);
195 void delete_MemSizeWdgt(MemSizeWdgt* obj) { delete obj; }
197 void delete_MemSizeWdgt(MemSizeWdgt* obj) { delete obj; }
196 int getsize(MemSizeWdgt* theWrappedObject);
198 int getsize(MemSizeWdgt* theWrappedObject);
197 void setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max);
199 void setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max);
198 void show(MemSizeWdgt* theWrappedObject);
200 void show(MemSizeWdgt* theWrappedObject);
199 void updateSizeValue(MemSizeWdgt* theWrappedObject);
201 void updateSizeValue(MemSizeWdgt* theWrappedObject);
200 };
202 };
201
203
202
204
203
205
204
206
205
207
206 class PythonQtShell_QHexEdit : public QHexEdit
208 class PythonQtShell_QHexEdit : public QHexEdit
207 {
209 {
208 public:
210 public:
209 PythonQtShell_QHexEdit(QWidget* parent = 0):QHexEdit(parent),_wrapper(NULL) {};
211 PythonQtShell_QHexEdit(QWidget* parent = 0):QHexEdit(parent),_wrapper(NULL) {};
210
212
211 ~PythonQtShell_QHexEdit();
213 ~PythonQtShell_QHexEdit();
212
214
213 virtual void actionEvent(QActionEvent* arg__1);
215 virtual void actionEvent(QActionEvent* arg__1);
214 virtual void changeEvent(QEvent* arg__1);
216 virtual void changeEvent(QEvent* arg__1);
215 virtual void childEvent(QChildEvent* arg__1);
217 virtual void childEvent(QChildEvent* arg__1);
216 virtual void closeEvent(QCloseEvent* arg__1);
218 virtual void closeEvent(QCloseEvent* arg__1);
217 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
219 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
218 virtual void customEvent(QEvent* arg__1);
220 virtual void customEvent(QEvent* arg__1);
219 virtual int devType() const;
221 virtual int devType() const;
220 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
222 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
221 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
223 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
222 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
224 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
223 virtual void dropEvent(QDropEvent* arg__1);
225 virtual void dropEvent(QDropEvent* arg__1);
224 virtual void enterEvent(QEvent* arg__1);
226 virtual void enterEvent(QEvent* arg__1);
225 virtual bool event(QEvent* arg__1);
227 virtual bool event(QEvent* arg__1);
226 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
228 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
227 virtual void focusInEvent(QFocusEvent* arg__1);
229 virtual void focusInEvent(QFocusEvent* arg__1);
228 virtual bool focusNextPrevChild(bool next);
230 virtual bool focusNextPrevChild(bool next);
229 virtual void focusOutEvent(QFocusEvent* arg__1);
231 virtual void focusOutEvent(QFocusEvent* arg__1);
230 virtual bool hasHeightForWidth() const;
232 virtual bool hasHeightForWidth() const;
231 virtual int heightForWidth(int arg__1) const;
233 virtual int heightForWidth(int arg__1) const;
232 virtual void hideEvent(QHideEvent* arg__1);
234 virtual void hideEvent(QHideEvent* arg__1);
233 virtual void initPainter(QPainter* painter) const;
235 virtual void initPainter(QPainter* painter) const;
234 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
236 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
235 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
237 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
236 virtual void keyPressEvent(QKeyEvent* arg__1);
238 virtual void keyPressEvent(QKeyEvent* arg__1);
237 virtual void keyReleaseEvent(QKeyEvent* arg__1);
239 virtual void keyReleaseEvent(QKeyEvent* arg__1);
238 virtual void leaveEvent(QEvent* arg__1);
240 virtual void leaveEvent(QEvent* arg__1);
239 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
241 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
240 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
242 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
241 virtual void mouseMoveEvent(QMouseEvent* arg__1);
243 virtual void mouseMoveEvent(QMouseEvent* arg__1);
242 virtual void mousePressEvent(QMouseEvent* arg__1);
244 virtual void mousePressEvent(QMouseEvent* arg__1);
243 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
245 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
244 virtual void moveEvent(QMoveEvent* arg__1);
246 virtual void moveEvent(QMoveEvent* arg__1);
245 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
247 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
246 virtual QPaintEngine* paintEngine() const;
248 virtual QPaintEngine* paintEngine() const;
247 virtual void paintEvent(QPaintEvent* arg__1);
249 virtual void paintEvent(QPaintEvent* arg__1);
248 virtual QPaintDevice* redirected(QPoint* offset) const;
250 virtual QPaintDevice* redirected(QPoint* offset) const;
249 virtual void resizeEvent(QResizeEvent* arg__1);
251 virtual void resizeEvent(QResizeEvent* arg__1);
250 virtual void scrollContentsBy(int dx, int dy);
252 virtual void scrollContentsBy(int dx, int dy);
251 virtual void setupViewport(QWidget* viewport);
253 virtual void setupViewport(QWidget* viewport);
252 virtual QPainter* sharedPainter() const;
254 virtual QPainter* sharedPainter() const;
253 virtual void showEvent(QShowEvent* arg__1);
255 virtual void showEvent(QShowEvent* arg__1);
254 virtual void tabletEvent(QTabletEvent* arg__1);
256 virtual void tabletEvent(QTabletEvent* arg__1);
255 virtual void timerEvent(QTimerEvent* arg__1);
257 virtual void timerEvent(QTimerEvent* arg__1);
256 virtual bool viewportEvent(QEvent* arg__1);
258 virtual bool viewportEvent(QEvent* arg__1);
257 virtual QSize viewportSizeHint() const;
259 virtual QSize viewportSizeHint() const;
258 virtual void wheelEvent(QWheelEvent* arg__1);
260 virtual void wheelEvent(QWheelEvent* arg__1);
259
261
260 PythonQtInstanceWrapper* _wrapper;
262 PythonQtInstanceWrapper* _wrapper;
261 };
263 };
262
264
263 class PythonQtWrapper_QHexEdit : public QObject
265 class PythonQtWrapper_QHexEdit : public QObject
264 { Q_OBJECT
266 { Q_OBJECT
265 public:
267 public:
266 public slots:
268 public slots:
267 QHexEdit* new_QHexEdit(QWidget* parent = 0);
269 QHexEdit* new_QHexEdit(QWidget* parent = 0);
268 void delete_QHexEdit(QHexEdit* obj) { delete obj; }
270 void delete_QHexEdit(QHexEdit* obj) { delete obj; }
269 QColor addressAreaColor(QHexEdit* theWrappedObject);
271 QColor addressAreaColor(QHexEdit* theWrappedObject);
270 int addressOffset(QHexEdit* theWrappedObject);
272 int addressOffset(QHexEdit* theWrappedObject);
271 int cursorPosition(QHexEdit* theWrappedObject);
273 int cursorPosition(QHexEdit* theWrappedObject);
272 QByteArray data(QHexEdit* theWrappedObject);
274 QByteArray data(QHexEdit* theWrappedObject);
273 const QFont* font(QHexEdit* theWrappedObject) const;
275 const QFont* font(QHexEdit* theWrappedObject) const;
274 QColor highlightingColor(QHexEdit* theWrappedObject);
276 QColor highlightingColor(QHexEdit* theWrappedObject);
275 int indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
277 int indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
276 void insert(QHexEdit* theWrappedObject, int i, char ch);
278 void insert(QHexEdit* theWrappedObject, int i, char ch);
277 void insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba);
279 void insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba);
278 bool isReadOnly(QHexEdit* theWrappedObject);
280 bool isReadOnly(QHexEdit* theWrappedObject);
279 int lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
281 int lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
280 bool overwriteMode(QHexEdit* theWrappedObject);
282 bool overwriteMode(QHexEdit* theWrappedObject);
281 void remove(QHexEdit* theWrappedObject, int pos, int len = 1);
283 void remove(QHexEdit* theWrappedObject, int pos, int len = 1);
282 void replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after);
284 void replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after);
283 QColor selectionColor(QHexEdit* theWrappedObject);
285 QColor selectionColor(QHexEdit* theWrappedObject);
284 QString selectionToReadableString(QHexEdit* theWrappedObject);
286 QString selectionToReadableString(QHexEdit* theWrappedObject);
285 void setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color);
287 void setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color);
286 void setAddressOffset(QHexEdit* theWrappedObject, int offset);
288 void setAddressOffset(QHexEdit* theWrappedObject, int offset);
287 void setCursorPosition(QHexEdit* theWrappedObject, int cusorPos);
289 void setCursorPosition(QHexEdit* theWrappedObject, int cusorPos);
288 void setData(QHexEdit* theWrappedObject, const QByteArray& data);
290 void setData(QHexEdit* theWrappedObject, const QByteArray& data);
289 void setFont(QHexEdit* theWrappedObject, const QFont& arg__1);
291 void setFont(QHexEdit* theWrappedObject, const QFont& arg__1);
290 void setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color);
292 void setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color);
291 void setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1);
293 void setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1);
292 void setReadOnly(QHexEdit* theWrappedObject, bool arg__1);
294 void setReadOnly(QHexEdit* theWrappedObject, bool arg__1);
293 void setSelectionColor(QHexEdit* theWrappedObject, const QColor& color);
295 void setSelectionColor(QHexEdit* theWrappedObject, const QColor& color);
294 QString toReadableString(QHexEdit* theWrappedObject);
296 QString toReadableString(QHexEdit* theWrappedObject);
295 };
297 };
296
298
297
299
298
300
299
301
300
302
301 class PythonQtShell_QHexSpinBox : public QHexSpinBox
303 class PythonQtShell_QHexSpinBox : public QHexSpinBox
302 {
304 {
303 public:
305 public:
304 PythonQtShell_QHexSpinBox(QWidget* parent = 0):QHexSpinBox(parent),_wrapper(NULL) {};
306 PythonQtShell_QHexSpinBox(QWidget* parent = 0):QHexSpinBox(parent),_wrapper(NULL) {};
305
307
306 ~PythonQtShell_QHexSpinBox();
308 ~PythonQtShell_QHexSpinBox();
307
309
308 virtual void actionEvent(QActionEvent* arg__1);
310 virtual void actionEvent(QActionEvent* arg__1);
309 virtual void changeEvent(QEvent* event);
311 virtual void changeEvent(QEvent* event);
310 virtual void childEvent(QChildEvent* arg__1);
312 virtual void childEvent(QChildEvent* arg__1);
311 virtual void clear();
313 virtual void clear();
312 virtual void closeEvent(QCloseEvent* event);
314 virtual void closeEvent(QCloseEvent* event);
313 virtual void contextMenuEvent(QContextMenuEvent* event);
315 virtual void contextMenuEvent(QContextMenuEvent* event);
314 virtual void customEvent(QEvent* arg__1);
316 virtual void customEvent(QEvent* arg__1);
315 virtual int devType() const;
317 virtual int devType() const;
316 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
318 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
317 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
319 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
318 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
320 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
319 virtual void dropEvent(QDropEvent* arg__1);
321 virtual void dropEvent(QDropEvent* arg__1);
320 virtual void enterEvent(QEvent* arg__1);
322 virtual void enterEvent(QEvent* arg__1);
321 virtual bool event(QEvent* event);
323 virtual bool event(QEvent* event);
322 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
324 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
323 virtual void fixup(QString& str) const;
325 virtual void fixup(QString& str) const;
324 virtual void focusInEvent(QFocusEvent* event);
326 virtual void focusInEvent(QFocusEvent* event);
325 virtual bool focusNextPrevChild(bool next);
327 virtual bool focusNextPrevChild(bool next);
326 virtual void focusOutEvent(QFocusEvent* event);
328 virtual void focusOutEvent(QFocusEvent* event);
327 virtual bool hasHeightForWidth() const;
329 virtual bool hasHeightForWidth() const;
328 virtual int heightForWidth(int arg__1) const;
330 virtual int heightForWidth(int arg__1) const;
329 virtual void hideEvent(QHideEvent* event);
331 virtual void hideEvent(QHideEvent* event);
330 virtual void initPainter(QPainter* painter) const;
332 virtual void initPainter(QPainter* painter) const;
331 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
333 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
332 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
334 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
333 virtual void keyPressEvent(QKeyEvent* event);
335 virtual void keyPressEvent(QKeyEvent* event);
334 virtual void keyReleaseEvent(QKeyEvent* event);
336 virtual void keyReleaseEvent(QKeyEvent* event);
335 virtual void leaveEvent(QEvent* arg__1);
337 virtual void leaveEvent(QEvent* arg__1);
336 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
338 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
337 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
339 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
338 virtual void mouseMoveEvent(QMouseEvent* event);
340 virtual void mouseMoveEvent(QMouseEvent* event);
339 virtual void mousePressEvent(QMouseEvent* event);
341 virtual void mousePressEvent(QMouseEvent* event);
340 virtual void mouseReleaseEvent(QMouseEvent* event);
342 virtual void mouseReleaseEvent(QMouseEvent* event);
341 virtual void moveEvent(QMoveEvent* arg__1);
343 virtual void moveEvent(QMoveEvent* arg__1);
342 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
344 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
343 virtual QPaintEngine* paintEngine() const;
345 virtual QPaintEngine* paintEngine() const;
344 virtual void paintEvent(QPaintEvent* event);
346 virtual void paintEvent(QPaintEvent* event);
345 virtual QPaintDevice* redirected(QPoint* offset) const;
347 virtual QPaintDevice* redirected(QPoint* offset) const;
346 virtual void resizeEvent(QResizeEvent* event);
348 virtual void resizeEvent(QResizeEvent* event);
347 virtual QPainter* sharedPainter() const;
349 virtual QPainter* sharedPainter() const;
348 virtual void showEvent(QShowEvent* event);
350 virtual void showEvent(QShowEvent* event);
349 virtual void stepBy(int steps);
351 virtual void stepBy(int steps);
350 virtual QAbstractSpinBox::StepEnabled stepEnabled() const;
352 virtual QAbstractSpinBox::StepEnabled stepEnabled() const;
351 virtual void tabletEvent(QTabletEvent* arg__1);
353 virtual void tabletEvent(QTabletEvent* arg__1);
352 virtual QString textFromValue(int value) const;
354 virtual QString textFromValue(int value) const;
353 virtual void timerEvent(QTimerEvent* event);
355 virtual void timerEvent(QTimerEvent* event);
354 virtual QValidator::State validate(QString& input, int& pos) const;
356 virtual QValidator::State validate(QString& input, int& pos) const;
355 virtual int valueFromText(const QString& text) const;
357 virtual int valueFromText(const QString& text) const;
356 virtual void wheelEvent(QWheelEvent* event);
358 virtual void wheelEvent(QWheelEvent* event);
357
359
358 PythonQtInstanceWrapper* _wrapper;
360 PythonQtInstanceWrapper* _wrapper;
359 };
361 };
360
362
361 class PythonQtPublicPromoter_QHexSpinBox : public QHexSpinBox
363 class PythonQtPublicPromoter_QHexSpinBox : public QHexSpinBox
362 { public:
364 { public:
363 inline QString promoted_textFromValue(int value) const { return QHexSpinBox::textFromValue(value); }
365 inline QString promoted_textFromValue(int value) const { return QHexSpinBox::textFromValue(value); }
364 inline QValidator::State promoted_validate(QString& input, int& pos) const { return QHexSpinBox::validate(input, pos); }
366 inline QValidator::State promoted_validate(QString& input, int& pos) const { return QHexSpinBox::validate(input, pos); }
365 inline int promoted_valueFromText(const QString& text) const { return QHexSpinBox::valueFromText(text); }
367 inline int promoted_valueFromText(const QString& text) const { return QHexSpinBox::valueFromText(text); }
366 };
368 };
367
369
368 class PythonQtWrapper_QHexSpinBox : public QObject
370 class PythonQtWrapper_QHexSpinBox : public QObject
369 { Q_OBJECT
371 { Q_OBJECT
370 public:
372 public:
371 public slots:
373 public slots:
372 QHexSpinBox* new_QHexSpinBox(QWidget* parent = 0);
374 QHexSpinBox* new_QHexSpinBox(QWidget* parent = 0);
373 void delete_QHexSpinBox(QHexSpinBox* obj) { delete obj; }
375 void delete_QHexSpinBox(QHexSpinBox* obj) { delete obj; }
374 void show(QHexSpinBox* theWrappedObject);
376 void show(QHexSpinBox* theWrappedObject);
375 QString textFromValue(QHexSpinBox* theWrappedObject, int value) const;
377 QString textFromValue(QHexSpinBox* theWrappedObject, int value) const;
376 QValidator::State validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const;
378 QValidator::State validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const;
377 int valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const;
379 int valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const;
378 };
380 };
379
381
380
382
381
383
382
384
383
385
384 class PythonQtShell_SocExplorerPlot : public SocExplorerPlot
386 class PythonQtShell_SocExplorerPlot : public SocExplorerPlot
385 {
387 {
386 public:
388 public:
387 PythonQtShell_SocExplorerPlot(QWidget* parent = 0):SocExplorerPlot(parent),_wrapper(NULL) {};
389 PythonQtShell_SocExplorerPlot(QWidget* parent = 0):SocExplorerPlot(parent),_wrapper(NULL) {};
388
390
389 ~PythonQtShell_SocExplorerPlot();
391 ~PythonQtShell_SocExplorerPlot();
390
392
391 virtual void actionEvent(QActionEvent* arg__1);
393 virtual void actionEvent(QActionEvent* arg__1);
392 virtual void changeEvent(QEvent* arg__1);
394 virtual void changeEvent(QEvent* arg__1);
393 virtual void childEvent(QChildEvent* arg__1);
395 virtual void childEvent(QChildEvent* arg__1);
394 virtual void closeEvent(QCloseEvent* arg__1);
396 virtual void closeEvent(QCloseEvent* arg__1);
395 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
397 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
396 virtual void customEvent(QEvent* arg__1);
398 virtual void customEvent(QEvent* arg__1);
397 virtual int devType() const;
399 virtual int devType() const;
398 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
400 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
399 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
401 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
400 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
402 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
401 virtual void dropEvent(QDropEvent* arg__1);
403 virtual void dropEvent(QDropEvent* arg__1);
402 virtual void enterEvent(QEvent* arg__1);
404 virtual void enterEvent(QEvent* arg__1);
403 virtual bool event(QEvent* arg__1);
405 virtual bool event(QEvent* arg__1);
404 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
406 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
405 virtual void focusInEvent(QFocusEvent* arg__1);
407 virtual void focusInEvent(QFocusEvent* arg__1);
406 virtual bool focusNextPrevChild(bool next);
408 virtual bool focusNextPrevChild(bool next);
407 virtual void focusOutEvent(QFocusEvent* arg__1);
409 virtual void focusOutEvent(QFocusEvent* arg__1);
408 virtual bool hasHeightForWidth() const;
410 virtual bool hasHeightForWidth() const;
409 virtual int heightForWidth(int arg__1) const;
411 virtual int heightForWidth(int arg__1) const;
410 virtual void hideEvent(QHideEvent* arg__1);
412 virtual void hideEvent(QHideEvent* arg__1);
411 virtual void initPainter(QPainter* painter) const;
413 virtual void initPainter(QPainter* painter) const;
412 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
414 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
413 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
415 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
414 virtual void keyPressEvent(QKeyEvent* arg__1);
416 virtual void keyPressEvent(QKeyEvent* arg__1);
415 virtual void keyReleaseEvent(QKeyEvent* arg__1);
417 virtual void keyReleaseEvent(QKeyEvent* arg__1);
416 virtual void leaveEvent(QEvent* arg__1);
418 virtual void leaveEvent(QEvent* arg__1);
417 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
419 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
418 virtual QSize minimumSizeHint() const;
420 virtual QSize minimumSizeHint() const;
419 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
421 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
420 virtual void mouseMoveEvent(QMouseEvent* arg__1);
422 virtual void mouseMoveEvent(QMouseEvent* arg__1);
421 virtual void mousePressEvent(QMouseEvent* arg__1);
423 virtual void mousePressEvent(QMouseEvent* arg__1);
422 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
424 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
423 virtual void moveEvent(QMoveEvent* arg__1);
425 virtual void moveEvent(QMoveEvent* arg__1);
424 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
426 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
425 virtual QPaintEngine* paintEngine() const;
427 virtual QPaintEngine* paintEngine() const;
426 virtual void paintEvent(QPaintEvent* arg__1);
428 virtual void paintEvent(QPaintEvent* arg__1);
427 virtual QPaintDevice* redirected(QPoint* offset) const;
429 virtual QPaintDevice* redirected(QPoint* offset) const;
428 virtual void resizeEvent(QResizeEvent* arg__1);
430 virtual void resizeEvent(QResizeEvent* arg__1);
429 virtual QPainter* sharedPainter() const;
431 virtual QPainter* sharedPainter() const;
430 virtual void showEvent(QShowEvent* arg__1);
432 virtual void showEvent(QShowEvent* arg__1);
431 virtual QSize sizeHint() const;
433 virtual QSize sizeHint() const;
432 virtual void tabletEvent(QTabletEvent* arg__1);
434 virtual void tabletEvent(QTabletEvent* arg__1);
433 virtual void timerEvent(QTimerEvent* arg__1);
435 virtual void timerEvent(QTimerEvent* arg__1);
434 virtual void wheelEvent(QWheelEvent* arg__1);
436 virtual void wheelEvent(QWheelEvent* arg__1);
435
437
436 PythonQtInstanceWrapper* _wrapper;
438 PythonQtInstanceWrapper* _wrapper;
437 };
439 };
438
440
439 class PythonQtPublicPromoter_SocExplorerPlot : public SocExplorerPlot
441 class PythonQtPublicPromoter_SocExplorerPlot : public SocExplorerPlot
440 { public:
442 { public:
441 inline void promoted_keyPressEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyPressEvent(arg__1); }
443 inline void promoted_keyPressEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyPressEvent(arg__1); }
442 inline void promoted_keyReleaseEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyReleaseEvent(arg__1); }
444 inline void promoted_keyReleaseEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyReleaseEvent(arg__1); }
443 inline void promoted_mouseMoveEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseMoveEvent(arg__1); }
445 inline void promoted_mouseMoveEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseMoveEvent(arg__1); }
444 inline void promoted_mousePressEvent(QMouseEvent* arg__1) { SocExplorerPlot::mousePressEvent(arg__1); }
446 inline void promoted_mousePressEvent(QMouseEvent* arg__1) { SocExplorerPlot::mousePressEvent(arg__1); }
445 inline void promoted_mouseReleaseEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseReleaseEvent(arg__1); }
447 inline void promoted_mouseReleaseEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseReleaseEvent(arg__1); }
446 inline void promoted_wheelEvent(QWheelEvent* arg__1) { SocExplorerPlot::wheelEvent(arg__1); }
448 inline void promoted_wheelEvent(QWheelEvent* arg__1) { SocExplorerPlot::wheelEvent(arg__1); }
447 };
449 };
448
450
449 class PythonQtWrapper_SocExplorerPlot : public QObject
451 class PythonQtWrapper_SocExplorerPlot : public QObject
450 { Q_OBJECT
452 { Q_OBJECT
451 public:
453 public:
452 public slots:
454 public slots:
453 SocExplorerPlot* new_SocExplorerPlot(QWidget* parent = 0);
455 SocExplorerPlot* new_SocExplorerPlot(QWidget* parent = 0);
454 void delete_SocExplorerPlot(SocExplorerPlot* obj) { delete obj; }
456 void delete_SocExplorerPlot(SocExplorerPlot* obj) { delete obj; }
455 int addGraph(SocExplorerPlot* theWrappedObject);
457 int addGraph(SocExplorerPlot* theWrappedObject);
456 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
458 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
457 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y);
459 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y);
458 QPen getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex);
460 QPen getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex);
459 void keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
461 void keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
460 void keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
462 void keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
461 void mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
463 void mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
462 void mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
464 void mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
463 void mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
465 void mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
464 void rescaleAxis(SocExplorerPlot* theWrappedObject);
466 void rescaleAxis(SocExplorerPlot* theWrappedObject);
465 void setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable);
467 void setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable);
466 void setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
468 void setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
467 void setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle);
469 void setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle);
468 void setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name);
470 void setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name);
469 void setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen);
471 void setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen);
470 void setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle);
472 void setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle);
471 void setLegendFont(SocExplorerPlot* theWrappedObject, QFont font);
473 void setLegendFont(SocExplorerPlot* theWrappedObject, QFont font);
472 void setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font);
474 void setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font);
473 void setTitle(SocExplorerPlot* theWrappedObject, QString title);
475 void setTitle(SocExplorerPlot* theWrappedObject, QString title);
474 void setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
476 void setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
475 void setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
477 void setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
476 void setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
478 void setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
477 void setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
479 void setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
478 void show(SocExplorerPlot* theWrappedObject);
480 void show(SocExplorerPlot* theWrappedObject);
479 void wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1);
481 void wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1);
480 };
482 };
481
483
482
484
483
485
484
486
485
487
486 class PythonQtShell_TCP_Terminal_Client : public TCP_Terminal_Client
488 class PythonQtShell_TCP_Terminal_Client : public TCP_Terminal_Client
487 {
489 {
488 public:
490 public:
489 PythonQtShell_TCP_Terminal_Client(QObject* parent = 0):TCP_Terminal_Client(parent),_wrapper(NULL) {};
491 PythonQtShell_TCP_Terminal_Client(QObject* parent = 0):TCP_Terminal_Client(parent),_wrapper(NULL) {};
490
492
491 ~PythonQtShell_TCP_Terminal_Client();
493 ~PythonQtShell_TCP_Terminal_Client();
492
494
493 virtual void childEvent(QChildEvent* arg__1);
495 virtual void childEvent(QChildEvent* arg__1);
494 virtual void customEvent(QEvent* arg__1);
496 virtual void customEvent(QEvent* arg__1);
495 virtual bool event(QEvent* arg__1);
497 virtual bool event(QEvent* arg__1);
496 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
498 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
497 virtual void timerEvent(QTimerEvent* arg__1);
499 virtual void timerEvent(QTimerEvent* arg__1);
498
500
499 PythonQtInstanceWrapper* _wrapper;
501 PythonQtInstanceWrapper* _wrapper;
500 };
502 };
501
503
502 class PythonQtWrapper_TCP_Terminal_Client : public QObject
504 class PythonQtWrapper_TCP_Terminal_Client : public QObject
503 { Q_OBJECT
505 { Q_OBJECT
504 public:
506 public:
505 public slots:
507 public slots:
506 TCP_Terminal_Client* new_TCP_Terminal_Client(QObject* parent = 0);
508 TCP_Terminal_Client* new_TCP_Terminal_Client(QObject* parent = 0);
507 void delete_TCP_Terminal_Client(TCP_Terminal_Client* obj) { delete obj; }
509 void delete_TCP_Terminal_Client(TCP_Terminal_Client* obj) { delete obj; }
508 void connectToServer(TCP_Terminal_Client* theWrappedObject);
510 void connectToServer(TCP_Terminal_Client* theWrappedObject);
509 void connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port);
511 void connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port);
510 bool isConnected(TCP_Terminal_Client* theWrappedObject);
512 bool isConnected(TCP_Terminal_Client* theWrappedObject);
511 void sendText(TCP_Terminal_Client* theWrappedObject, const QString& text);
513 void sendText(TCP_Terminal_Client* theWrappedObject, const QString& text);
512 void startServer(TCP_Terminal_Client* theWrappedObject);
514 void startServer(TCP_Terminal_Client* theWrappedObject);
513 void startServer(TCP_Terminal_Client* theWrappedObject, int port);
515 void startServer(TCP_Terminal_Client* theWrappedObject, int port);
514 };
516 };
515
517
516
518
517
519
518
520
519
521
520 class PythonQtWrapper_XByteArray : public QObject
522 class PythonQtWrapper_XByteArray : public QObject
521 { Q_OBJECT
523 { Q_OBJECT
522 public:
524 public:
523 public slots:
525 public slots:
524 XByteArray* new_XByteArray();
526 XByteArray* new_XByteArray();
525 void delete_XByteArray(XByteArray* obj) { delete obj; }
527 void delete_XByteArray(XByteArray* obj) { delete obj; }
526 int addressOffset(XByteArray* theWrappedObject);
528 int addressOffset(XByteArray* theWrappedObject);
527 int addressWidth(XByteArray* theWrappedObject);
529 int addressWidth(XByteArray* theWrappedObject);
528 QChar asciiChar(XByteArray* theWrappedObject, int index);
530 QChar asciiChar(XByteArray* theWrappedObject, int index);
529 QByteArray* data(XByteArray* theWrappedObject);
531 QByteArray* data(XByteArray* theWrappedObject);
530 bool dataChanged(XByteArray* theWrappedObject, int i);
532 bool dataChanged(XByteArray* theWrappedObject, int i);
531 QByteArray dataChanged(XByteArray* theWrappedObject, int i, int len);
533 QByteArray dataChanged(XByteArray* theWrappedObject, int i, int len);
532 QByteArray* insert(XByteArray* theWrappedObject, int i, char ch);
534 QByteArray* insert(XByteArray* theWrappedObject, int i, char ch);
533 QByteArray* insert(XByteArray* theWrappedObject, int i, const QByteArray& ba);
535 QByteArray* insert(XByteArray* theWrappedObject, int i, const QByteArray& ba);
534 int realAddressNumbers(XByteArray* theWrappedObject);
536 int realAddressNumbers(XByteArray* theWrappedObject);
535 QByteArray* remove(XByteArray* theWrappedObject, int pos, int len);
537 QByteArray* remove(XByteArray* theWrappedObject, int pos, int len);
536 QByteArray* replace(XByteArray* theWrappedObject, int index, char ch);
538 QByteArray* replace(XByteArray* theWrappedObject, int index, char ch);
537 QByteArray* replace(XByteArray* theWrappedObject, int index, const QByteArray& ba);
539 QByteArray* replace(XByteArray* theWrappedObject, int index, const QByteArray& ba);
538 QByteArray* replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba);
540 QByteArray* replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba);
539 void setAddressOffset(XByteArray* theWrappedObject, int offset);
541 void setAddressOffset(XByteArray* theWrappedObject, int offset);
540 void setAddressWidth(XByteArray* theWrappedObject, int width);
542 void setAddressWidth(XByteArray* theWrappedObject, int width);
541 void setData(XByteArray* theWrappedObject, QByteArray data);
543 void setData(XByteArray* theWrappedObject, QByteArray data);
542 void setDataChanged(XByteArray* theWrappedObject, int i, bool state);
544 void setDataChanged(XByteArray* theWrappedObject, int i, bool state);
543 void setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state);
545 void setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state);
544 int size(XByteArray* theWrappedObject);
546 int size(XByteArray* theWrappedObject);
545 QString toRedableString(XByteArray* theWrappedObject, int start = 0, int end = -1);
547 QString toRedableString(XByteArray* theWrappedObject, int start = 0, int end = -1);
546 };
548 };
547
549
548
550
549
551
550
552
551
553
552 class PythonQtShell_abstractExecFile : public abstractExecFile
554 class PythonQtShell_abstractBinFile : public abstractBinFile
553 {
555 {
554 public:
556 public:
555 PythonQtShell_abstractExecFile():abstractExecFile(),_wrapper(NULL) {};
557 PythonQtShell_abstractBinFile():abstractBinFile(),_wrapper(NULL) {};
556
558
557 ~PythonQtShell_abstractExecFile();
559 ~PythonQtShell_abstractBinFile();
558
560
559 virtual void childEvent(QChildEvent* arg__1);
561 virtual void childEvent(QChildEvent* arg__1);
560 virtual int closeFile();
562 virtual int closeFile();
561 virtual void customEvent(QEvent* arg__1);
563 virtual void customEvent(QEvent* arg__1);
562 virtual bool event(QEvent* arg__1);
564 virtual bool event(QEvent* arg__1);
563 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
565 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
564 virtual QList<codeFragment* > getFragments();
566 virtual QList<codeFragment* > getFragments();
565 virtual bool isopened();
567 virtual bool isopened();
566 virtual bool openFile(const QString& File);
568 virtual bool openFile(const QString& File);
567 virtual void timerEvent(QTimerEvent* arg__1);
569 virtual void timerEvent(QTimerEvent* arg__1);
568
570
569 PythonQtInstanceWrapper* _wrapper;
571 PythonQtInstanceWrapper* _wrapper;
570 };
572 };
571
573
572 class PythonQtWrapper_abstractExecFile : public QObject
574 class PythonQtWrapper_abstractBinFile : public QObject
573 { Q_OBJECT
575 { Q_OBJECT
574 public:
576 public:
575 public slots:
577 public slots:
576 abstractExecFile* new_abstractExecFile();
578 abstractBinFile* new_abstractBinFile();
577 void delete_abstractExecFile(abstractExecFile* obj) { delete obj; }
579 void delete_abstractBinFile(abstractBinFile* obj) { delete obj; }
578 };
580 };
579
581
580
582
581
583
582
584
583
585
584 class PythonQtShell_codeFragment : public codeFragment
586 class PythonQtShell_codeFragment : public codeFragment
585 {
587 {
586 public:
588 public:
587 PythonQtShell_codeFragment():codeFragment(),_wrapper(NULL) {};
589 PythonQtShell_codeFragment():codeFragment(),_wrapper(NULL) {};
588 PythonQtShell_codeFragment(char* data, unsigned int size, unsigned int address):codeFragment(data, size, address),_wrapper(NULL) {};
590 PythonQtShell_codeFragment(char* data, quint64 size, quint64 address):codeFragment(data, size, address),_wrapper(NULL) {};
589
591
590 ~PythonQtShell_codeFragment();
592 ~PythonQtShell_codeFragment();
591
593
592
594
593 PythonQtInstanceWrapper* _wrapper;
595 PythonQtInstanceWrapper* _wrapper;
594 };
596 };
595
597
596 class PythonQtWrapper_codeFragment : public QObject
598 class PythonQtWrapper_codeFragment : public QObject
597 { Q_OBJECT
599 { Q_OBJECT
598 public:
600 public:
599 public slots:
601 public slots:
600 codeFragment* new_codeFragment();
602 codeFragment* new_codeFragment();
601 codeFragment* new_codeFragment(char* data, unsigned int size, unsigned int address);
603 codeFragment* new_codeFragment(char* data, quint64 size, quint64 address);
602 void delete_codeFragment(codeFragment* obj) { delete obj; }
604 void delete_codeFragment(codeFragment* obj) { delete obj; }
603 void py_set_address(codeFragment* theWrappedObject, unsigned int address){ theWrappedObject->address = address; }
605 void py_set_size(codeFragment* theWrappedObject, quint64 size){ theWrappedObject->size = size; }
604 unsigned int py_get_address(codeFragment* theWrappedObject){ return theWrappedObject->address; }
606 quint64 py_get_size(codeFragment* theWrappedObject){ return theWrappedObject->size; }
607 void py_set_header(codeFragment* theWrappedObject, QString header){ theWrappedObject->header = header; }
608 QString py_get_header(codeFragment* theWrappedObject){ return theWrappedObject->header; }
609 void py_set_address(codeFragment* theWrappedObject, quint64 address){ theWrappedObject->address = address; }
610 quint64 py_get_address(codeFragment* theWrappedObject){ return theWrappedObject->address; }
605 void py_set_data(codeFragment* theWrappedObject, char* data){ theWrappedObject->data = data; }
611 void py_set_data(codeFragment* theWrappedObject, char* data){ theWrappedObject->data = data; }
606 char* py_get_data(codeFragment* theWrappedObject){ return theWrappedObject->data; }
612 char* py_get_data(codeFragment* theWrappedObject){ return theWrappedObject->data; }
607 void py_set_size(codeFragment* theWrappedObject, unsigned int size){ theWrappedObject->size = size; }
608 unsigned int py_get_size(codeFragment* theWrappedObject){ return theWrappedObject->size; }
609 };
613 };
610
614
611
615
612
616
613
617
614
618
615 class PythonQtShell_elfFileWidget : public elfFileWidget
619 class PythonQtShell_elfFileWidget : public elfFileWidget
616 {
620 {
617 public:
621 public:
618 PythonQtShell_elfFileWidget(QWidget* parent = 0):elfFileWidget(parent),_wrapper(NULL) {};
622 PythonQtShell_elfFileWidget(QWidget* parent = 0):elfFileWidget(parent),_wrapper(NULL) {};
619
623
620 ~PythonQtShell_elfFileWidget();
624 ~PythonQtShell_elfFileWidget();
621
625
622 virtual void actionEvent(QActionEvent* arg__1);
626 virtual void actionEvent(QActionEvent* arg__1);
623 virtual void changeEvent(QEvent* arg__1);
627 virtual void changeEvent(QEvent* arg__1);
624 virtual void childEvent(QChildEvent* arg__1);
628 virtual void childEvent(QChildEvent* arg__1);
625 virtual void closeEvent(QCloseEvent* arg__1);
629 virtual void closeEvent(QCloseEvent* arg__1);
626 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
630 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
627 virtual void customEvent(QEvent* arg__1);
631 virtual void customEvent(QEvent* arg__1);
628 virtual int devType() const;
632 virtual int devType() const;
629 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
633 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
630 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
634 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
631 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
635 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
632 virtual void dropEvent(QDropEvent* arg__1);
636 virtual void dropEvent(QDropEvent* arg__1);
633 virtual void enterEvent(QEvent* arg__1);
637 virtual void enterEvent(QEvent* arg__1);
634 virtual bool event(QEvent* arg__1);
638 virtual bool event(QEvent* arg__1);
635 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
639 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
636 virtual void focusInEvent(QFocusEvent* arg__1);
640 virtual void focusInEvent(QFocusEvent* arg__1);
637 virtual bool focusNextPrevChild(bool next);
641 virtual bool focusNextPrevChild(bool next);
638 virtual void focusOutEvent(QFocusEvent* arg__1);
642 virtual void focusOutEvent(QFocusEvent* arg__1);
639 virtual bool hasHeightForWidth() const;
643 virtual bool hasHeightForWidth() const;
640 virtual int heightForWidth(int arg__1) const;
644 virtual int heightForWidth(int arg__1) const;
641 virtual void hideEvent(QHideEvent* arg__1);
645 virtual void hideEvent(QHideEvent* arg__1);
642 virtual void initPainter(QPainter* painter) const;
646 virtual void initPainter(QPainter* painter) const;
643 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
647 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
644 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
648 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
645 virtual void keyPressEvent(QKeyEvent* arg__1);
649 virtual void keyPressEvent(QKeyEvent* arg__1);
646 virtual void keyReleaseEvent(QKeyEvent* arg__1);
650 virtual void keyReleaseEvent(QKeyEvent* arg__1);
647 virtual void leaveEvent(QEvent* arg__1);
651 virtual void leaveEvent(QEvent* arg__1);
648 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
652 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
649 virtual QSize minimumSizeHint() const;
653 virtual QSize minimumSizeHint() const;
650 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
654 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
651 virtual void mouseMoveEvent(QMouseEvent* arg__1);
655 virtual void mouseMoveEvent(QMouseEvent* arg__1);
652 virtual void mousePressEvent(QMouseEvent* arg__1);
656 virtual void mousePressEvent(QMouseEvent* arg__1);
653 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
657 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
654 virtual void moveEvent(QMoveEvent* arg__1);
658 virtual void moveEvent(QMoveEvent* arg__1);
655 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
659 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
656 virtual QPaintEngine* paintEngine() const;
660 virtual QPaintEngine* paintEngine() const;
657 virtual void paintEvent(QPaintEvent* arg__1);
661 virtual void paintEvent(QPaintEvent* arg__1);
658 virtual QPaintDevice* redirected(QPoint* offset) const;
662 virtual QPaintDevice* redirected(QPoint* offset) const;
659 virtual void resizeEvent(QResizeEvent* arg__1);
663 virtual void resizeEvent(QResizeEvent* arg__1);
660 virtual QPainter* sharedPainter() const;
664 virtual QPainter* sharedPainter() const;
661 virtual void showEvent(QShowEvent* arg__1);
665 virtual void showEvent(QShowEvent* arg__1);
662 virtual QSize sizeHint() const;
666 virtual QSize sizeHint() const;
663 virtual void tabletEvent(QTabletEvent* arg__1);
667 virtual void tabletEvent(QTabletEvent* arg__1);
664 virtual void timerEvent(QTimerEvent* arg__1);
668 virtual void timerEvent(QTimerEvent* arg__1);
665 virtual void wheelEvent(QWheelEvent* arg__1);
669 virtual void wheelEvent(QWheelEvent* arg__1);
666
670
667 PythonQtInstanceWrapper* _wrapper;
671 PythonQtInstanceWrapper* _wrapper;
668 };
672 };
669
673
670 class PythonQtWrapper_elfFileWidget : public QObject
674 class PythonQtWrapper_elfFileWidget : public QObject
671 { Q_OBJECT
675 { Q_OBJECT
672 public:
676 public:
673 public slots:
677 public slots:
674 elfFileWidget* new_elfFileWidget(QWidget* parent = 0);
678 elfFileWidget* new_elfFileWidget(QWidget* parent = 0);
675 void delete_elfFileWidget(elfFileWidget* obj) { delete obj; }
679 void delete_elfFileWidget(elfFileWidget* obj) { delete obj; }
676 };
680 };
677
681
678
682
679
683
680
684
681
685
682 class PythonQtShell_elfInfoWdgt : public elfInfoWdgt
686 class PythonQtShell_elfInfoWdgt : public elfInfoWdgt
683 {
687 {
684 public:
688 public:
685 PythonQtShell_elfInfoWdgt(QWidget* parent = 0):elfInfoWdgt(parent),_wrapper(NULL) {};
689 PythonQtShell_elfInfoWdgt(QWidget* parent = 0):elfInfoWdgt(parent),_wrapper(NULL) {};
686
690
687 ~PythonQtShell_elfInfoWdgt();
691 ~PythonQtShell_elfInfoWdgt();
688
692
689 virtual void actionEvent(QActionEvent* arg__1);
693 virtual void actionEvent(QActionEvent* arg__1);
690 virtual void changeEvent(QEvent* arg__1);
694 virtual void changeEvent(QEvent* arg__1);
691 virtual void childEvent(QChildEvent* arg__1);
695 virtual void childEvent(QChildEvent* arg__1);
692 virtual void closeEvent(QCloseEvent* arg__1);
696 virtual void closeEvent(QCloseEvent* arg__1);
693 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
697 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
694 virtual void customEvent(QEvent* arg__1);
698 virtual void customEvent(QEvent* arg__1);
695 virtual int devType() const;
699 virtual int devType() const;
696 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
700 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
697 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
701 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
698 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
702 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
699 virtual void dropEvent(QDropEvent* arg__1);
703 virtual void dropEvent(QDropEvent* arg__1);
700 virtual void enterEvent(QEvent* arg__1);
704 virtual void enterEvent(QEvent* arg__1);
701 virtual bool event(QEvent* arg__1);
705 virtual bool event(QEvent* arg__1);
702 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
706 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
703 virtual void focusInEvent(QFocusEvent* arg__1);
707 virtual void focusInEvent(QFocusEvent* arg__1);
704 virtual bool focusNextPrevChild(bool next);
708 virtual bool focusNextPrevChild(bool next);
705 virtual void focusOutEvent(QFocusEvent* arg__1);
709 virtual void focusOutEvent(QFocusEvent* arg__1);
706 virtual bool hasHeightForWidth() const;
710 virtual bool hasHeightForWidth() const;
707 virtual int heightForWidth(int arg__1) const;
711 virtual int heightForWidth(int arg__1) const;
708 virtual void hideEvent(QHideEvent* arg__1);
712 virtual void hideEvent(QHideEvent* arg__1);
709 virtual void initPainter(QPainter* painter) const;
713 virtual void initPainter(QPainter* painter) const;
710 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
714 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
711 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
715 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
712 virtual void keyPressEvent(QKeyEvent* arg__1);
716 virtual void keyPressEvent(QKeyEvent* arg__1);
713 virtual void keyReleaseEvent(QKeyEvent* arg__1);
717 virtual void keyReleaseEvent(QKeyEvent* arg__1);
714 virtual void leaveEvent(QEvent* arg__1);
718 virtual void leaveEvent(QEvent* arg__1);
715 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
719 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
716 virtual QSize minimumSizeHint() const;
720 virtual QSize minimumSizeHint() const;
717 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
721 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
718 virtual void mouseMoveEvent(QMouseEvent* arg__1);
722 virtual void mouseMoveEvent(QMouseEvent* arg__1);
719 virtual void mousePressEvent(QMouseEvent* arg__1);
723 virtual void mousePressEvent(QMouseEvent* arg__1);
720 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
724 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
721 virtual void moveEvent(QMoveEvent* arg__1);
725 virtual void moveEvent(QMoveEvent* arg__1);
722 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
726 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
723 virtual QPaintEngine* paintEngine() const;
727 virtual QPaintEngine* paintEngine() const;
724 virtual void paintEvent(QPaintEvent* arg__1);
728 virtual void paintEvent(QPaintEvent* arg__1);
725 virtual QPaintDevice* redirected(QPoint* offset) const;
729 virtual QPaintDevice* redirected(QPoint* offset) const;
726 virtual void resizeEvent(QResizeEvent* arg__1);
730 virtual void resizeEvent(QResizeEvent* arg__1);
727 virtual QPainter* sharedPainter() const;
731 virtual QPainter* sharedPainter() const;
728 virtual void showEvent(QShowEvent* arg__1);
732 virtual void showEvent(QShowEvent* arg__1);
729 virtual QSize sizeHint() const;
733 virtual QSize sizeHint() const;
730 virtual void tabletEvent(QTabletEvent* arg__1);
734 virtual void tabletEvent(QTabletEvent* arg__1);
731 virtual void timerEvent(QTimerEvent* arg__1);
735 virtual void timerEvent(QTimerEvent* arg__1);
732 virtual void wheelEvent(QWheelEvent* arg__1);
736 virtual void wheelEvent(QWheelEvent* arg__1);
733
737
734 PythonQtInstanceWrapper* _wrapper;
738 PythonQtInstanceWrapper* _wrapper;
735 };
739 };
736
740
737 class PythonQtWrapper_elfInfoWdgt : public QObject
741 class PythonQtWrapper_elfInfoWdgt : public QObject
738 { Q_OBJECT
742 { Q_OBJECT
739 public:
743 public:
740 public slots:
744 public slots:
741 elfInfoWdgt* new_elfInfoWdgt(QWidget* parent = 0);
745 elfInfoWdgt* new_elfInfoWdgt(QWidget* parent = 0);
742 void delete_elfInfoWdgt(elfInfoWdgt* obj) { delete obj; }
746 void delete_elfInfoWdgt(elfInfoWdgt* obj) { delete obj; }
743 };
747 };
744
748
745
749
746
750
747
751
748
752
749 class PythonQtWrapper_elfparser : public QObject
753 class PythonQtWrapper_elfparser : public QObject
750 { Q_OBJECT
754 { Q_OBJECT
751 public:
755 public:
752 public slots:
756 public slots:
753 elfparser* new_elfparser();
757 elfparser* new_elfparser();
754 void delete_elfparser(elfparser* obj) { delete obj; }
758 void delete_elfparser(elfparser* obj) { delete obj; }
755 int closeFile(elfparser* theWrappedObject);
759 int closeFile(elfparser* theWrappedObject);
756 QString getABI(elfparser* theWrappedObject);
760 QString getABI(elfparser* theWrappedObject);
757 QString getArchitecture(elfparser* theWrappedObject);
761 QString getArchitecture(elfparser* theWrappedObject);
758 QString getClass(elfparser* theWrappedObject);
762 QString getClass(elfparser* theWrappedObject);
759 QString getEndianness(elfparser* theWrappedObject);
763 QString getEndianness(elfparser* theWrappedObject);
760 qint64 getEntryPointAddress(elfparser* theWrappedObject);
764 qint64 getEntryPointAddress(elfparser* theWrappedObject);
761 bool getSectionData(elfparser* theWrappedObject, int index, char** buffer);
765 bool getSectionData(elfparser* theWrappedObject, int index, char** buffer);
762 qint64 getSectionDatasz(elfparser* theWrappedObject, int index);
766 qint64 getSectionDatasz(elfparser* theWrappedObject, int index);
763 qint64 getSectionMemsz(elfparser* theWrappedObject, int index);
767 qint64 getSectionMemsz(elfparser* theWrappedObject, int index);
764 QString getSectionName(elfparser* theWrappedObject, int index);
768 QString getSectionName(elfparser* theWrappedObject, int index);
765 qint64 getSectionPaddr(elfparser* theWrappedObject, int index);
769 qint64 getSectionPaddr(elfparser* theWrappedObject, int index);
766 QString getSectionType(elfparser* theWrappedObject, int index);
770 QString getSectionType(elfparser* theWrappedObject, int index);
767 int getSectioncount(elfparser* theWrappedObject);
771 int getSectioncount(elfparser* theWrappedObject);
768 qint64 getSegmentFilesz(elfparser* theWrappedObject, int index);
772 qint64 getSegmentFilesz(elfparser* theWrappedObject, int index);
769 QString getSegmentFlags(elfparser* theWrappedObject, int index);
773 QString getSegmentFlags(elfparser* theWrappedObject, int index);
770 qint64 getSegmentMemsz(elfparser* theWrappedObject, int index);
774 qint64 getSegmentMemsz(elfparser* theWrappedObject, int index);
771 qint64 getSegmentOffset(elfparser* theWrappedObject, int index);
775 qint64 getSegmentOffset(elfparser* theWrappedObject, int index);
772 qint64 getSegmentPaddr(elfparser* theWrappedObject, int index);
776 qint64 getSegmentPaddr(elfparser* theWrappedObject, int index);
773 QString getSegmentType(elfparser* theWrappedObject, int index);
777 QString getSegmentType(elfparser* theWrappedObject, int index);
774 qint64 getSegmentVaddr(elfparser* theWrappedObject, int index);
778 qint64 getSegmentVaddr(elfparser* theWrappedObject, int index);
775 int getSegmentcount(elfparser* theWrappedObject);
779 int getSegmentcount(elfparser* theWrappedObject);
776 QString getType(elfparser* theWrappedObject);
780 QString getType(elfparser* theWrappedObject);
777 qint64 getVersion(elfparser* theWrappedObject);
781 qint64 getVersion(elfparser* theWrappedObject);
778 bool static_elfparser_isElf(const QString& File);
782 bool static_elfparser_isElf(const QString& File);
779 bool iself(elfparser* theWrappedObject);
783 bool iself(elfparser* theWrappedObject);
780 bool isopened(elfparser* theWrappedObject);
784 bool isopened(elfparser* theWrappedObject);
781 int setFilename(elfparser* theWrappedObject, const QString& name);
785 int setFilename(elfparser* theWrappedObject, const QString& name);
782 };
786 };
783
787
784
788
785
789
786
790
787
791
788 class PythonQtShell_srecFile : public srecFile
792 class PythonQtShell_srecFile : public srecFile
789 {
793 {
790 public:
794 public:
791 PythonQtShell_srecFile():srecFile(),_wrapper(NULL) {};
795 PythonQtShell_srecFile():srecFile(),_wrapper(NULL) {};
792 PythonQtShell_srecFile(const QString& File):srecFile(File),_wrapper(NULL) {};
796 PythonQtShell_srecFile(const QString& File):srecFile(File),_wrapper(NULL) {};
793 PythonQtShell_srecFile(const QStringList& Files):srecFile(Files),_wrapper(NULL) {};
797 PythonQtShell_srecFile(const QStringList& Files):srecFile(Files),_wrapper(NULL) {};
794
798
795 ~PythonQtShell_srecFile();
799 ~PythonQtShell_srecFile();
796
800
797 virtual int closeFile();
801 virtual int closeFile();
798 virtual QList<codeFragment* > getFragments();
802 virtual QList<codeFragment* > getFragments();
799 virtual bool isopened();
803 virtual bool isopened();
800 virtual bool openFile(const QString& File);
804 virtual bool openFile(const QString& File);
801
805
802 PythonQtInstanceWrapper* _wrapper;
806 PythonQtInstanceWrapper* _wrapper;
803 };
807 };
804
808
805 class PythonQtPublicPromoter_srecFile : public srecFile
809 class PythonQtPublicPromoter_srecFile : public srecFile
806 { public:
810 { public:
807 inline int promoted_closeFile() { return srecFile::closeFile(); }
811 inline int promoted_closeFile() { return srecFile::closeFile(); }
808 inline QList<codeFragment* > promoted_getFragments() { return srecFile::getFragments(); }
812 inline QList<codeFragment* > promoted_getFragments() { return srecFile::getFragments(); }
809 inline bool promoted_isopened() { return srecFile::isopened(); }
813 inline bool promoted_isopened() { return srecFile::isopened(); }
810 inline bool promoted_openFile(const QString& File) { return srecFile::openFile(File); }
814 inline bool promoted_openFile(const QString& File) { return srecFile::openFile(File); }
811 };
815 };
812
816
813 class PythonQtWrapper_srecFile : public QObject
817 class PythonQtWrapper_srecFile : public QObject
814 { Q_OBJECT
818 { Q_OBJECT
815 public:
819 public:
816 public slots:
820 public slots:
817 srecFile* new_srecFile();
821 srecFile* new_srecFile();
818 srecFile* new_srecFile(const QString& File);
822 srecFile* new_srecFile(const QString& File);
819 srecFile* new_srecFile(const QStringList& Files);
823 srecFile* new_srecFile(const QStringList& Files);
820 void delete_srecFile(srecFile* obj) { delete obj; }
824 void delete_srecFile(srecFile* obj) { delete obj; }
821 int closeFile(srecFile* theWrappedObject);
825 int closeFile(srecFile* theWrappedObject);
826 int getFragmentAddress(srecFile* theWrappedObject, int index);
827 bool getFragmentData(srecFile* theWrappedObject, int index, char** buffer);
828 QString getFragmentHeader(srecFile* theWrappedObject, int index);
829 int getFragmentSize(srecFile* theWrappedObject, int index);
822 QList<codeFragment* > getFragments(srecFile* theWrappedObject);
830 QList<codeFragment* > getFragments(srecFile* theWrappedObject);
831 int getFragmentsCount(srecFile* theWrappedObject);
832 bool isSREC(srecFile* theWrappedObject);
833 bool static_srecFile_isSREC(const QString& File);
823 bool isopened(srecFile* theWrappedObject);
834 bool isopened(srecFile* theWrappedObject);
835 int lineCount(srecFile* theWrappedObject);
824 bool openFile(srecFile* theWrappedObject, const QString& File);
836 bool openFile(srecFile* theWrappedObject, const QString& File);
825 bool openFiles(srecFile* theWrappedObject, const QStringList& Files);
837 bool openFiles(srecFile* theWrappedObject, const QStringList& Files);
838 bool static_srecFile_toSrec(QList<codeFragment* > fragments, const QString& File);
826 };
839 };
827
840
828
841
842
843
844
845 class PythonQtShell_srecFileWidget : public srecFileWidget
846 {
847 public:
848 PythonQtShell_srecFileWidget(QWidget* parent = 0):srecFileWidget(parent),_wrapper(NULL) {};
849
850 ~PythonQtShell_srecFileWidget();
851
852 virtual void actionEvent(QActionEvent* arg__1);
853 virtual void changeEvent(QEvent* arg__1);
854 virtual void childEvent(QChildEvent* arg__1);
855 virtual void closeEvent(QCloseEvent* arg__1);
856 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
857 virtual void customEvent(QEvent* arg__1);
858 virtual int devType() const;
859 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
860 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
861 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
862 virtual void dropEvent(QDropEvent* arg__1);
863 virtual void enterEvent(QEvent* arg__1);
864 virtual bool event(QEvent* arg__1);
865 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
866 virtual void focusInEvent(QFocusEvent* arg__1);
867 virtual bool focusNextPrevChild(bool next);
868 virtual void focusOutEvent(QFocusEvent* arg__1);
869 virtual bool hasHeightForWidth() const;
870 virtual int heightForWidth(int arg__1) const;
871 virtual void hideEvent(QHideEvent* arg__1);
872 virtual void initPainter(QPainter* painter) const;
873 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
874 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
875 virtual void keyPressEvent(QKeyEvent* arg__1);
876 virtual void keyReleaseEvent(QKeyEvent* arg__1);
877 virtual void leaveEvent(QEvent* arg__1);
878 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
879 virtual QSize minimumSizeHint() const;
880 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
881 virtual void mouseMoveEvent(QMouseEvent* arg__1);
882 virtual void mousePressEvent(QMouseEvent* arg__1);
883 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
884 virtual void moveEvent(QMoveEvent* arg__1);
885 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
886 virtual QPaintEngine* paintEngine() const;
887 virtual void paintEvent(QPaintEvent* arg__1);
888 virtual QPaintDevice* redirected(QPoint* offset) const;
889 virtual void resizeEvent(QResizeEvent* arg__1);
890 virtual QPainter* sharedPainter() const;
891 virtual void showEvent(QShowEvent* arg__1);
892 virtual QSize sizeHint() const;
893 virtual void tabletEvent(QTabletEvent* arg__1);
894 virtual void timerEvent(QTimerEvent* arg__1);
895 virtual void wheelEvent(QWheelEvent* arg__1);
896
897 PythonQtInstanceWrapper* _wrapper;
898 };
899
900 class PythonQtWrapper_srecFileWidget : public QObject
901 { Q_OBJECT
902 public:
903 public slots:
904 srecFileWidget* new_srecFileWidget(QWidget* parent = 0);
905 void delete_srecFileWidget(srecFileWidget* obj) { delete obj; }
906 };
907
908
Show file before | Show file after | Hide comments
@@ -1,22 +1,23
1 #include <PythonQt.h>
1 #include <PythonQt.h>
2 #include "PySocExplorer0.h"
2 #include "PySocExplorer0.h"
3
3
4
4
5 void PythonQt_init_PySocExplorer(PyObject* module) {
5 void PythonQt_init_PySocExplorer(PyObject* module) {
6 PythonQt::priv()->registerClass(&ElfFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_ElfFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_ElfFile>, module, 0);
6 PythonQt::priv()->registerClass(&ElfFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_ElfFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_ElfFile>, module, 0);
7 PythonQt::self()->addParentClass("ElfFile", "abstractExecFile",PythonQtUpcastingOffset<ElfFile,abstractExecFile>());
7 PythonQt::self()->addParentClass("ElfFile", "abstractBinFile",PythonQtUpcastingOffset<ElfFile,abstractBinFile>());
8 PythonQt::priv()->registerClass(&MemSizeWdgt::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_MemSizeWdgt>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_MemSizeWdgt>, module, 0);
8 PythonQt::priv()->registerClass(&MemSizeWdgt::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_MemSizeWdgt>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_MemSizeWdgt>, module, 0);
9 PythonQt::priv()->registerClass(&QHexEdit::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_QHexEdit>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QHexEdit>, module, 0);
9 PythonQt::priv()->registerClass(&QHexEdit::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_QHexEdit>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QHexEdit>, module, 0);
10 PythonQt::priv()->registerClass(&QHexSpinBox::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_QHexSpinBox>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QHexSpinBox>, module, 0);
10 PythonQt::priv()->registerClass(&QHexSpinBox::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_QHexSpinBox>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QHexSpinBox>, module, 0);
11 PythonQt::priv()->registerClass(&SocExplorerPlot::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_SocExplorerPlot>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_SocExplorerPlot>, module, 0);
11 PythonQt::priv()->registerClass(&SocExplorerPlot::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_SocExplorerPlot>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_SocExplorerPlot>, module, 0);
12 PythonQt::priv()->registerClass(&TCP_Terminal_Client::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_TCP_Terminal_Client>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_TCP_Terminal_Client>, module, 0);
12 PythonQt::priv()->registerClass(&TCP_Terminal_Client::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_TCP_Terminal_Client>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_TCP_Terminal_Client>, module, 0);
13 PythonQt::priv()->registerCPPClass("XByteArray", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_XByteArray>, NULL, module, 0);
13 PythonQt::priv()->registerCPPClass("XByteArray", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_XByteArray>, NULL, module, 0);
14 PythonQt::priv()->registerClass(&abstractExecFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_abstractExecFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_abstractExecFile>, module, 0);
14 PythonQt::priv()->registerClass(&abstractBinFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_abstractBinFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_abstractBinFile>, module, 0);
15 PythonQt::priv()->registerCPPClass("codeFragment", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_codeFragment>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_codeFragment>, module, 0);
15 PythonQt::priv()->registerCPPClass("codeFragment", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_codeFragment>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_codeFragment>, module, 0);
16 PythonQt::priv()->registerClass(&elfFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_elfFileWidget>, module, 0);
16 PythonQt::priv()->registerClass(&elfFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_elfFileWidget>, module, 0);
17 PythonQt::priv()->registerClass(&elfInfoWdgt::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfInfoWdgt>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_elfInfoWdgt>, module, 0);
17 PythonQt::priv()->registerClass(&elfInfoWdgt::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfInfoWdgt>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_elfInfoWdgt>, module, 0);
18 PythonQt::priv()->registerCPPClass("elfparser", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfparser>, NULL, module, 0);
18 PythonQt::priv()->registerCPPClass("elfparser", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfparser>, NULL, module, 0);
19 PythonQt::priv()->registerClass(&srecFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_srecFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_srecFile>, module, 0);
19 PythonQt::priv()->registerClass(&srecFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_srecFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_srecFile>, module, 0);
20 PythonQt::self()->addParentClass("srecFile", "abstractExecFile",PythonQtUpcastingOffset<srecFile,abstractExecFile>());
20 PythonQt::self()->addParentClass("srecFile", "abstractBinFile",PythonQtUpcastingOffset<srecFile,abstractBinFile>());
21 PythonQt::priv()->registerClass(&srecFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_srecFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_srecFileWidget>, module, 0);
21
22
22 }
23 }
Show file before | Show file after | Hide comments
@@ -1,56 +1,62
1 <typesystem package="PySocExplorer" default-superclass="com.trolltech.qt.QtJambiObject">
1 <typesystem package="PySocExplorer" default-superclass="com.trolltech.qt.QtJambiObject">
2 <load-typesystem name=":/trolltech/generator/typesystem_core.txt" generate="no" />
2 <load-typesystem name=":/trolltech/generator/typesystem_core.txt" generate="no" />
3 <load-typesystem name=":/trolltech/generator/typesystem_gui.txt" generate="no" />
3 <load-typesystem name=":/trolltech/generator/typesystem_gui.txt" generate="no" />
4 <load-typesystem name=":/trolltech/generator/typesystem_network.txt" generate="no" />
4 <load-typesystem name=":/trolltech/generator/typesystem_network.txt" generate="no" />
5
5
6
6
7 <object-type name="QHexSpinBox">
7 <object-type name="QHexSpinBox">
8 <extra-includes>
8 <extra-includes>
9 <include file-name="QWidget" location="global"/>
9 <include file-name="QWidget" location="global"/>
10 <include file-name="QObject" location="global"/>
10 <include file-name="QObject" location="global"/>
11 <include file-name="QSpinBox" location="global"/>
11 <include file-name="QSpinBox" location="global"/>
12 </extra-includes>
12 </extra-includes>
13 </object-type>
13 </object-type>
14 <object-type name="MemSizeWdgt" />
14 <object-type name="MemSizeWdgt" />
15 <object-type name="QHexEdit" />
15 <object-type name="QHexEdit" />
16 <object-type name="XByteArray" />
16 <object-type name="XByteArray" />
17 <object-type name="SocExplorerPlot" />
17 <object-type name="SocExplorerPlot" />
18 <object-type name="TCP_Terminal_Client" />
18 <object-type name="TCP_Terminal_Client" />
19 <object-type name="codeFragment" />
19 <object-type name="codeFragment" />
20 <object-type name="srecFile" />
20 <object-type name="srecFile" />
21 <rejection class="Elf_Section"/>
21 <rejection class="Elf_Section"/>
22 <object-type name="elfparser" />
22 <object-type name="elfparser" />
23 <interface-type name="abstractExecFile">
23 <interface-type name="abstractBinFile">
24 <extra-includes>
24 <extra-includes>
25 <include file-name="QWidget" location="global"/>
25 <include file-name="QWidget" location="global"/>
26 <include file-name="QObject" location="global"/>
26 <include file-name="QObject" location="global"/>
27 </extra-includes>
27 </extra-includes>
28 </interface-type>
28 </interface-type>
29 <object-type name="ElfFile">
29 <object-type name="ElfFile">
30 <extra-includes>
30 <extra-includes>
31 <include file-name="QWidget" location="global"/>
31 <include file-name="QWidget" location="global"/>
32 <include file-name="QObject" location="global"/>
32 <include file-name="QObject" location="global"/>
33 </extra-includes>
33 </extra-includes>
34 </object-type>
34 </object-type>
35 <object-type name="elfFileWidget">
35 <object-type name="elfFileWidget">
36 <extra-includes>
36 <extra-includes>
37 <include file-name="QWidget" location="global"/>
37 <include file-name="QWidget" location="global"/>
38 <include file-name="QObject" location="global"/>
38 <include file-name="QObject" location="global"/>
39 </extra-includes>
39 </extra-includes>
40 </object-type>
40 </object-type>
41 <object-type name="srecFileWidget">
42 <extra-includes>
43 <include file-name="QWidget" location="global"/>
44 <include file-name="QObject" location="global"/>
45 </extra-includes>
46 </object-type>
41 <object-type name="elfInfoWdgt">
47 <object-type name="elfInfoWdgt">
42 <extra-includes>
48 <extra-includes>
43 <include file-name="QWidget" location="global"/>
49 <include file-name="QWidget" location="global"/>
44 <include file-name="QObject" location="global"/>
50 <include file-name="QObject" location="global"/>
45 </extra-includes>
51 </extra-includes>
46 </object-type>
52 </object-type>
47
53
48 </typesystem>
54 </typesystem>
49
55
50
56
51
57
52
58
53
59
54
60
55
61
56
62
Show file before | Show file after | Hide comments
@@ -1,154 +1,319
1 #include "srecfile.h"
1 #include "srecfile.h"
2 #include <QTextStream>
2
3
3 srecFile::srecFile()
4 srecFile::srecFile()
4 {
5 {
5 }
6 }
6
7
7 srecFile::srecFile(const QString &File)
8 srecFile::srecFile(const QString &File)
8 {
9 {
9 openFile(File);
10 openFile(File);
10 }
11 }
11
12
12 srecFile::srecFile(const QStringList &Files)
13 srecFile::srecFile(const QStringList &Files)
13 {
14 {
14 openFiles(Files);
15 openFiles(Files);
15 }
16 }
16
17
17 srecFile::~srecFile()
18 srecFile::~srecFile()
18 {
19 {
19
20
20 }
21 }
21
22
22 bool srecFile::openFile(const QString &File)
23 bool srecFile::openFile(const QString &File)
23 {
24 {
24 openFiles(QStringList()<<File);
25 return openFiles(QStringList()<<File);
25 }
26 }
26
27
27 bool srecFile::openFiles(const QStringList &Files)
28 bool srecFile::openFiles(const QStringList &Files)
28 {
29 {
29 this->p_fileNames.clear();
30 this->p_fileNames.clear();
30 this->p_fileNames.append(Files);
31 this->p_fileNames.append(Files);
31 for(int i=0;i<p_files.count();i++)
32 for(int i=0;i<p_files.count();i++)
32 {
33 {
33 delete p_files.at(i);
34 delete p_files.at(i);
34 }
35 }
35 this->p_files.clear();
36 this->p_files.clear();
36 for(int i=0;i<Files.count();i++)
37 for(int i=0;i<Files.count();i++)
37 {
38 {
39 this->p_isSrec=true;
40 this->p_isSrec &= isSREC(Files.at(i));
38 this->p_files.append(new QFile(Files.at(i)));
41 this->p_files.append(new QFile(Files.at(i)));
39 this->p_files.at(i)->open(QIODevice::ReadOnly);
42 this->p_files.at(i)->open(QIODevice::ReadOnly);
40 parseFile(this->p_files.at(i));
43 parseFile(this->p_files.at(i));
41 }
44 }
45 return true;
42 }
46 }
43
47
44 bool srecFile::isopened()
48 bool srecFile::isopened()
45 {
49 {
46 bool opened = true;
50 bool opened = true;
47 for(int i=0;i<this->p_files.count();i++)
51 for(int i=0;i<this->p_files.count();i++)
48 {
52 {
49 opened &= p_files.at(i)->isOpen();
53 opened &= p_files.at(i)->isOpen();
50 }
54 }
51 return opened;
55 return opened;
52 }
56 }
53
57
54 int srecFile::closeFile()
58 int srecFile::closeFile()
55 {
59 {
56
60 for(int i=0;i<p_files.count();i++)
61 {
62 delete p_files.at(i);
63 }
64 p_files.clear();
65 p_fileName.clear();
57 }
66 }
58
67
59 QList<codeFragment *> srecFile::getFragments()
68 QList<codeFragment *> srecFile::getFragments()
60 {
69 {
61 return p_fragments;
70 return p_fragments;
62 }
71 }
63
72
73 bool srecFile::toSrec(QList<codeFragment *> fragments, const QString &File)
74 {
75 QString line;
76 QFile file(File);
77 file.open(QIODevice::WriteOnly);
78 if(file.isOpen())
79 {
80 QTextStream stream( &file );
81 //First build header
82 line.append("S0");
83 line.append(QString("%1").arg(File.count()+3,2,16).replace(' ','0'));
84 line.append("0000");
85 for(int i=0;i<File.count();i++)
86 {
87 line.append(QString("%1").arg((uchar)File.at(i).toLatin1(),2,16).replace(' ','0'));
88 }
89 line.append(QString("%1").arg((uchar)srecFile::lineCheckSum(line),2,16).replace(' ','0'));
90 line.append('\n');
91 stream << line.toUpper();
92 for(int i=0;i<fragments.count();i++)
93 {
94 codeFragment *fragment = fragments.at(i);
95 for(int j=0;j<(int)(fragment->size);j+=16)
96 {
97 line.clear();
98 line.append("S315");
99 line.append(QString("%1").arg(fragment->address+j,8,16).replace(' ','0'));
100 for(int k=0;k<16;k++)
101 {
102 line.append(QString("%1").arg((uchar)fragment->data[j+k],2,16).replace(' ','0'));
103 }
104 line.append(QString("%1").arg((uchar)srecFile::lineCheckSum(line),2,16).replace(' ','0'));
105 line.append('\n');
106 stream << line.toUpper();
107 }
108 int rem = fragment->size%16;
109 if(rem)
110 {
111 line.clear();
112 line.append("S3");
113 line.append(QString("%1").arg(rem,2,16).replace(' ','0'));
114 line.append(QString("%1").arg(fragment->address+fragment->size-rem,8,16).replace(' ','0'));
115 for(int k=0;k<rem;k++)
116 {
117 line.append(QString("%1").arg((uchar)fragment->data[fragment->size-rem+k],2,16).replace(' ','0'));
118 }
119 line.append(QString("%1").arg((uchar)srecFile::lineCheckSum(line),2,16).replace(' ','0'));
120 line.append('\n');
121 stream << line.toUpper();
122 }
123 line.clear();
124 line.append("S705");
125 line.append(QString("%1").arg(fragment->address,8,16).replace(' ','0'));
126 line.append(QString("%1").arg((uchar)srecFile::lineCheckSum(line),2,16).replace(' ','0'));
127 line.append('\n');
128 stream << line.toUpper();
129 }
130 file.close();
131 return true;
132 }
133
134 return false;
135 }
136
137 int srecFile::lineCount()
138 {
139 return p_lineCount;
140 }
141
142 int srecFile::getFragmentsCount()
143 {
144 return p_fragments.count();
145 }
146
147 int srecFile::getFragmentAddress(int index)
148 {
149 if((index < p_fragments.count()) && (index>=0))
150 {
151 return p_fragments.at(index)->address;
152 }
153 return 0;
154 }
155
156 int srecFile::getFragmentSize(int index)
157 {
158 if((index < p_fragments.count()) && (index>=0))
159 {
160 return p_fragments.at(index)->size;
161 }
162 return 0;
163 }
164
165 QString srecFile::getFragmentHeader(int index)
166 {
167 if((index < p_fragments.count()) && (index>=0))
168 {
169 return p_fragments.at(index)->header;
170 }
171 return "";
172 }
173
174 bool srecFile::getFragmentData(int index, char **buffer)
175 {
176
177 if((index < p_fragments.count()) && (index>=0))
178 {
179 *buffer = (char *)this->p_fragments.at(index)->data;
180 return true;
181 }
182 return false;
183 }
184
185 bool srecFile::isSREC()
186 {
187 return p_isSrec & isopened();
188 }
189
190 bool srecFile::isSREC(const QString &File)
191 {
192 QFile file(File);
193 file.open(QIODevice::ReadOnly);
194 if(file.isOpen())
195 {
196 file.seek(0);
197 QString line=file.readLine();
198 file.close();
199 return ((line.at(0)=='S')&&(line.at(1)=='0'));
200 }
201 return false;
202 }
203
64 void srecFile::parseFile(QFile *file)
204 void srecFile::parseFile(QFile *file)
65 {
205 {
66 if(file->isOpen())
206 if(file->isOpen())
67 {
207 {
208 this->p_lineCount = 0;
68 file->seek(0);
209 file->seek(0);
69 codeFragment* fragment=NULL;
210 codeFragment* fragment=NULL;
70 QByteArray data;
211 QByteArray data;
71 quint32 size=0;
212 quint64 size=0;
72 quint32 address=0;
213 quint64 address=-1;
214 QString header;
73 while (!file->atEnd())
215 while (!file->atEnd())
74 {
216 {
75 QString line = file->readLine();
217 QString line = file->readLine();
218 p_lineCount++;
76 if(line.count()>4)
219 if(line.count()>4)
77 {
220 {
78 if(line.at(0)=='S')
221 if(line.at(0)=='S')
79 {
222 {
80 bool ok;
223 bool ok;
81 int count = line.mid(2,2).toInt(&ok,16);
224 int count = line.mid(2,2).toInt(&ok,16);
82 if(line.at(1)=='0')
225 if(line.at(1)=='0')
83 {
226 {
227 header.clear();
228 for(int i=0;i<(count-3);i++)
229 {
230 header.append((char)line.mid((2*i)+8,2).toInt(&ok,16));
231 }
84 }
232 }
85 if(line.at(1)=='1')
233 if(line.at(1)=='1')
86 {
234 {
87 }
235 }
88 if(line.at(1)=='2')
236 if(line.at(1)=='2')
89 {
237 {
90
238
91 }
239 }
92 if(line.at(1)=='3')
240 if(line.at(1)=='3')
93 {
241 {
94 int naddress =line.mid(4,8).toInt(&ok,16);
242 int naddress =line.mid(4,8).toInt(&ok,16);
95 if(address !=naddress)
243 if(address !=naddress)
96 {
244 {
97 if(fragment!=NULL)
245 if(fragment!=NULL)
98 {
246 {
99 fragment->size = data.size();
247 fragment->size = data.size();
100 fragment->data = (char*)malloc(data.size());
248 fragment->data = (char*)malloc(data.size());
101 for(int i =0;i<data.size();i++)
249 for(int i =0;i<data.size();i++)
102 {
250 {
103 fragment->data[i]=data.at(i);
251 fragment->data[i]=data.at(i);
104 }
252 }
105 data.clear();
253 data.clear();
106 p_fragments.append(fragment);
254 p_fragments.append(fragment);
107 }
255 }
108 fragment = new codeFragment();
256 fragment = new codeFragment();
109 fragment->address = naddress;
257 fragment->address = naddress;
258 fragment->header = header;
110 }
259 }
111 address = naddress+count-5;
260 address = naddress+count-5;
112 for(int i=0;i<(count-5);i++)
261 for(int i=0;i<(count-5);i++)
113 {
262 {
114 data.append((char)line.mid((2*i)+8,2).toInt(&ok,16));
263 data.append((char)line.mid((2*i)+12,2).toInt(&ok,16));
115 }
264 }
116 }
265 }
117 if(line.at(1)=='5')
266 if(line.at(1)=='5')
118 {
267 {
119
268
120 }
269 }
121 if(line.at(1)=='6')
270 if(line.at(1)=='6')
122 {
271 {
123
272
124 }
273 }
125 if(line.at(1)=='7')
274 if(line.at(1)=='7')
126 {
275 {
127
276
128 }
277 }
129 if(line.at(1)=='8')
278 if(line.at(1)=='8')
130 {
279 {
131
280
132 }
281 }
133 if(line.at(1)=='9')
282 if(line.at(1)=='9')
134 {
283 {
135
284
136 }
285 }
137 }
286 }
138 }
287 }
139 }
288 }
140 if(data.size()!=0)
289 if(data.size()!=0)
141 {
290 {
142 fragment->size = data.size();
291 fragment->size = data.size();
143 fragment->data = (char*)malloc(data.size());
292 fragment->data = (char*)malloc(data.size());
144 for(int i =0;i<data.size();i++)
293 for(int i =0;i<data.size();i++)
145 {
294 {
146 fragment->data[i]=data.at(i);
295 fragment->data[i]=data.at(i);
147 }
296 }
148 data.clear();
297 data.clear();
149 p_fragments.append(fragment);
298 p_fragments.append(fragment);
150 }
299 }
151
300
152 }
301 }
153 }
302 }
154
303
304 char srecFile::lineCheckSum(const QString &line)
305 {
306 char sum=0;
307 QString localLine = line;
308 bool ok;
309 if(localLine.at(0)=='S') // then should skip the first two digits
310 {
311 localLine.remove(0,2);
312 }
313 for(int i=0;i<localLine.count();i+=2)
314 {
315 sum+=(char)(localLine.mid(i,2).toInt(&ok,16));
316 }
317 return ~sum;
318 }
319
Show file before | Show file after | Hide comments
@@ -1,34 +1,46
1 #ifndef SRECFILE_H
1 #ifndef SRECFILE_H
2 #define SRECFILE_H
2 #define SRECFILE_H
3
3
4 #include <QObject>
4 #include <QObject>
5 #include <abstractexecfile.h>
5 #include <abstractbinfile.h>
6 #include <QFile>
6 #include <QFile>
7 #include <QStringList>
7 #include <QStringList>
8
8
9 class srecFile : public abstractExecFile
9 class srecFile : public abstractBinFile
10 {
10 {
11 Q_OBJECT
11 Q_OBJECT
12 public:
12 public:
13 explicit srecFile();
13 explicit srecFile();
14 srecFile(const QString& File);
14 srecFile(const QString& File);
15 srecFile(const QStringList& Files);
15 srecFile(const QStringList& Files);
16 ~srecFile();
16 ~srecFile();
17 bool openFile(const QString& File);
17 bool openFile(const QString& File);
18 bool openFiles(const QStringList& Files);
18 bool openFiles(const QStringList& Files);
19 bool isopened();
19 bool isopened();
20 int closeFile();
20 int closeFile();
21 QList<codeFragment*> getFragments();
21 QList<codeFragment*> getFragments();
22 static bool toSrec(QList<codeFragment*> fragments,const QString& File);
23 int lineCount();
24 int getFragmentsCount();
25 int getFragmentAddress(int index);
26 int getFragmentSize(int index);
27 QString getFragmentHeader(int index);
28 bool getFragmentData(int index, char **buffer);
22
29
30 bool isSREC();
31 static bool isSREC(const QString& File);
23 signals:
32 signals:
24
33
25 public slots:
34 public slots:
26 private:
35 private:
27 void parseFile(QFile* file);
36 void parseFile(QFile* file);
37 static char lineCheckSum(const QString& line);
28 QStringList p_fileNames;
38 QStringList p_fileNames;
29 QList<QFile*>p_files;
39 QList<QFile*>p_files;
30 QList<codeFragment*> p_fragments;
40 QList<codeFragment*> p_fragments;
41 int p_lineCount;
42 bool p_isSrec;
31
43
32 };
44 };
33
45
34 #endif // SRECFILE_H
46 #endif // SRECFILE_H
General Comments 0
You need to be logged in to leave comments. Login now