##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » SocExplorer
RSS
Added bool loadfile(abstractBinFile* file)...
jeandet -
r71:c4b98d42ee59 default
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,4 +1,4
1 2c82d72694590cbc2aebb946667f11f60ea89afe src/SocExplorerEngine/PeripheralWidget
1 2c82d72694590cbc2aebb946667f11f60ea89afe src/SocExplorerEngine/PeripheralWidget
2 e0f25227d6283e833fbb70c5fc1bdc6c3ca8060e src/common/genericBinaryFiles
2 cc958c79ba0939809a70e63b8bac798930160243 src/common/genericBinaryFiles
3 2dce25b198558be573f56c1cf337aa95ddd666d6 src/common/lppserial
3 2dce25b198558be573f56c1cf337aa95ddd666d6 src/common/lppserial
4 923afde9cc96bb419cf898560d080ec96991aeca src/common/qhexedit
4 923afde9cc96bb419cf898560d080ec96991aeca src/common/qhexedit
Show file before | Show file after | Hide comments
@@ -1,22 +1,23
1
1
2 QT += core gui xml svg network
2 QT += core gui xml svg network
3 contains(QT_MAJOR_VERSION, 5) {
3 contains(QT_MAJOR_VERSION, 5) {
4 QT += widgets
4 QT += widgets
5 QT += printsupport
5 QT += printsupport
6 QT += multimedia multimediawidgets
6 }
7 }
7
8
8 SOCEXPLORER_SDK_BUILD="SOCEXPLORER_SDK_BUILD"
9 SOCEXPLORER_SDK_BUILD="SOCEXPLORER_SDK_BUILD"
9 DEFINES += SOCEXPLORER_SDK_BUILD
10 DEFINES += SOCEXPLORER_SDK_BUILD
10
11
11 MOC_DIR = moc
12 MOC_DIR = moc
12 RCC_DIR = resources
13 RCC_DIR = resources
13 OBJECTS_DIR = obj
14 OBJECTS_DIR = obj
14
15
15 win32:DESTDIR = $${SOCEXPLORER_ROOT}/bin/win32/
16 win32:DESTDIR = $${SOCEXPLORER_ROOT}/bin/win32/
16 unix:DESTDIR = $${SOCEXPLORER_ROOT}/bin/linux/
17 unix:DESTDIR = $${SOCEXPLORER_ROOT}/bin/linux/
17
18
18
19
19 metrics_cccc.target = metrics_cccc
20 metrics_cccc.target = metrics_cccc
20 metrics_cccc.commands = cccc $(SOURCES) $(HEADERS)
21 metrics_cccc.commands = cccc $(SOURCES) $(HEADERS)
21
22
22 QMAKE_EXTRA_TARGETS += metrics_cccc
23 QMAKE_EXTRA_TARGETS += metrics_cccc
Show file before | Show file after | Hide comments
@@ -1,112 +1,118
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) 2013, Plasma Physics Laboratory - CNRS
3 -- Copyright (C) 2013, 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@lpp.polytechnique.fr
20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
21 ----------------------------------------------------------------------------*/
21 ----------------------------------------------------------------------------*/
22 #include "socmodel.h"
22 #include "socmodel.h"
23 #include <socexplorerenumdevice.h>
23 #include <socexplorerenumdevice.h>
24
24
25
25
26 SOCModel::SOCModel(socexplorerplugin *rootDev, QObject *parent):
26 SOCModel::SOCModel(socexplorerplugin *rootDev, QObject *parent):
27 QObject(parent)
27 QObject(parent)
28 {
28 {
29 p_rootDev = rootDev;
29 p_rootDev = rootDev;
30 p_litleEndian = false;
30 }
31 }
31
32
32 qint32 SOCModel::getEnumDeviceBaseAddress(int VID, int PID, int count)
33 qint32 SOCModel::getEnumDeviceBaseAddress(int VID, int PID, int count)
33 {
34 {
34 for(int i=0;i<p_enumeratedDevices.count();i++)
35 for(int i=0;i<p_enumeratedDevices.count();i++)
35 {
36 {
36 if((p_enumeratedDevices.at(i)->VID()==VID) && (p_enumeratedDevices.at(i)->PID()==PID))
37 if((p_enumeratedDevices.at(i)->VID()==VID) && (p_enumeratedDevices.at(i)->PID()==PID))
37 {
38 {
38 if(count==0)
39 if(count==0)
39 {
40 {
40 return p_enumeratedDevices.at(i)->baseAddress();
41 return p_enumeratedDevices.at(i)->baseAddress();
41 }
42 }
42 count--;
43 count--;
43 }
44 }
44 }
45 }
45 return -1;
46 return -1;
46 }
47 }
47
48
48 qint32 SOCModel::getEnumDeviceCount(int VID, int PID)
49 qint32 SOCModel::getEnumDeviceCount(int VID, int PID)
49 {
50 {
50 qint32 count =0;
51 qint32 count =0;
51 for(int i=0;i<p_enumeratedDevices.count();i++)
52 for(int i=0;i<p_enumeratedDevices.count();i++)
52 {
53 {
53 if((p_enumeratedDevices.at(i)->VID()==VID) && (p_enumeratedDevices.at(i)->PID()==PID))
54 if((p_enumeratedDevices.at(i)->VID()==VID) && (p_enumeratedDevices.at(i)->PID()==PID))
54 {
55 {
55 count++;
56 count++;
56 }
57 }
57 }
58 }
58 return count;
59 return count;
59 }
60 }
60
61
61 socExplorerEnumDevice *SOCModel::addEnumDevice( int VID, int PID, qint32 baseAddress, const QString &name)
62 socExplorerEnumDevice *SOCModel::addEnumDevice( int VID, int PID, qint32 baseAddress, const QString &name)
62 {
63 {
63 if(enumDeviceExists(baseAddress))
64 if(enumDeviceExists(baseAddress))
64 return getEnumDevice(baseAddress);
65 return getEnumDevice(baseAddress);
65 socExplorerEnumDevice* device= new socExplorerEnumDevice(this,VID,PID,baseAddress,name);
66 socExplorerEnumDevice* device= new socExplorerEnumDevice(this,VID,PID,baseAddress,name);
66 p_enumeratedDevices.append(device);
67 p_enumeratedDevices.append(device);
67 return device;
68 return device;
68 }
69 }
69
70
70 int SOCModel::addEnumDevice(socExplorerEnumDevice *device)
71 int SOCModel::addEnumDevice(socExplorerEnumDevice *device)
71 {
72 {
72 if(enumDeviceExists(device->baseAddress()))
73 if(enumDeviceExists(device->baseAddress()))
73 return 0;
74 return 0;
74 p_enumeratedDevices.append(device);
75 p_enumeratedDevices.append(device);
75 return 1;
76 return 1;
76 }
77 }
77
78
78
79
79
80
80 bool SOCModel::enumDeviceExists(qint32 baseAddress)
81 bool SOCModel::enumDeviceExists(qint32 baseAddress)
81 {
82 {
82 for(int i=0;i<p_enumeratedDevices.count();i++)
83 for(int i=0;i<p_enumeratedDevices.count();i++)
83 {
84 {
84 if(p_enumeratedDevices.at(i)->baseAddress()==baseAddress)
85 if(p_enumeratedDevices.at(i)->baseAddress()==baseAddress)
85 return true;
86 return true;
86 }
87 }
87 return false;
88 return false;
88 }
89 }
89
90
90 socExplorerEnumDevice *SOCModel::getEnumDevice(qint32 baseAddress)
91 socExplorerEnumDevice *SOCModel::getEnumDevice(qint32 baseAddress)
91 {
92 {
92 for(int i=0;i<p_enumeratedDevices.count();i++)
93 for(int i=0;i<p_enumeratedDevices.count();i++)
93 {
94 {
94 if(p_enumeratedDevices.at(i)->baseAddress()==baseAddress)
95 if(p_enumeratedDevices.at(i)->baseAddress()==baseAddress)
95 return p_enumeratedDevices.at(i);
96 return p_enumeratedDevices.at(i);
96 }
97 }
97 return NULL;
98 return NULL;
98 }
99 }
99
100
100
101
101 void SOCModel::writeReg(qint32 address, qint32 value)
102 void SOCModel::writeReg(qint32 address, qint32 value)
102 {
103 {
103 uint valueInt=value,addressInt=address;
104 uint valueInt=value,addressInt=address;
104 p_rootDev->Write(&valueInt,1,addressInt);
105 p_rootDev->Write(&valueInt,1,addressInt);
105 }
106 }
106
107
107 qint32 SOCModel::readReg(qint32 address)
108 qint32 SOCModel::readReg(qint32 address)
108 {
109 {
109 uint valueInt=0,addressInt=address;
110 uint valueInt=0,addressInt=address;
110 p_rootDev->Read(&valueInt,1,addressInt);
111 p_rootDev->Read(&valueInt,1,addressInt);
111 return (qint32)valueInt;
112 return (qint32)valueInt;
112 }
113 }
114
115 bool SOCModel::isLitleEndian()
116 {
117 return p_litleEndian;
118 }
Show file before | Show file after | Hide comments
@@ -1,113 +1,115
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) 2013, Plasma Physics Laboratory - CNRS
3 -- Copyright (C) 2013, 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@lpp.polytechnique.fr
20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
21 ----------------------------------------------------------------------------*/
21 ----------------------------------------------------------------------------*/
22
22
23 #ifndef REGISTERSMODEL_H
23 #ifndef REGISTERSMODEL_H
24 #define REGISTERSMODEL_H
24 #define REGISTERSMODEL_H
25 #include <QString>
25 #include <QString>
26 #include <QList>
26 #include <QList>
27 #include <QObject>
27 #include <QObject>
28 #include <QDomDocument>
28 #include <QDomDocument>
29 #include <QDomElement>
29 #include <QDomElement>
30 #include "registerdata.h"
30 #include "registerdata.h"
31 #include <socclk.h>
31 #include <socclk.h>
32 #include <socexplorerplugin.h>
32 #include <socexplorerplugin.h>
33 class socExplorerEnumDevice;
33 class socExplorerEnumDevice;
34
34
35 class registerBitFieldModel
35 class registerBitFieldModel
36 {
36 {
37 public:
37 public:
38 registerBitFieldModel(const QString& name,const QString& description,
38 registerBitFieldModel(const QString& name,const QString& description,
39 int size, int offset, bool rw)
39 int size, int offset, bool rw)
40 {
40 {
41 this->name = name;
41 this->name = name;
42 this->description = description;
42 this->description = description;
43 this->size = size;
43 this->size = size;
44 this->offset = offset;
44 this->offset = offset;
45 this->rw = rw;
45 this->rw = rw;
46 }
46 }
47 QString name;
47 QString name;
48 QString description;
48 QString description;
49 int size;
49 int size;
50 int offset;
50 int offset;
51 bool rw;
51 bool rw;
52 };
52 };
53
53
54 class registerModel
54 class registerModel
55 {
55 {
56 public:
56 public:
57 registerModel(const QString& name,qint32 offset)
57 registerModel(const QString& name,qint32 offset)
58 {
58 {
59 this->name = name;
59 this->name = name;
60 this->offset = offset;
60 this->offset = offset;
61 }
61 }
62 QString name;
62 QString name;
63 qint32 offset;
63 qint32 offset;
64 QList<registerBitFieldModel> bitfields;
64 QList<registerBitFieldModel> bitfields;
65 };
65 };
66
66
67 class peripheralModel
67 class peripheralModel
68 {
68 {
69 public:
69 public:
70 peripheralModel(const QString& name)
70 peripheralModel(const QString& name)
71 {
71 {
72 this->name = name;
72 this->name = name;
73 }
73 }
74 QString name;
74 QString name;
75 QList<registerModel> registers;
75 QList<registerModel> registers;
76 };
76 };
77
77
78
78
79 class SOCEXPLORER_EXPORT SOCModel :public QObject
79 class SOCEXPLORER_EXPORT SOCModel :public QObject
80 {
80 {
81 Q_OBJECT
81 Q_OBJECT
82 public:
82 public:
83 SOCModel(socexplorerplugin* rootDev,QObject* parent=0);
83 SOCModel(socexplorerplugin* rootDev,QObject* parent=0);
84 bool isRootDev(socexplorerplugin* rootDev)
84 bool isRootDev(socexplorerplugin* rootDev)
85 {
85 {
86 return rootDev==p_rootDev;
86 return rootDev==p_rootDev;
87 }
87 }
88 bool enumDeviceExists(qint32 baseAddress);
88 bool enumDeviceExists(qint32 baseAddress);
89 socExplorerEnumDevice *getEnumDevice(qint32 baseAddress);
89 socExplorerEnumDevice *getEnumDevice(qint32 baseAddress);
90 public slots:
90 public slots:
91 qint32 getEnumDeviceBaseAddress(int VID,int PID,int count=0);
91 qint32 getEnumDeviceBaseAddress(int VID,int PID,int count=0);
92 qint32 getEnumDeviceCount(int VID,int PID);
92 qint32 getEnumDeviceCount(int VID,int PID);
93 socExplorerEnumDevice* addEnumDevice(int VID, int PID, qint32 baseAddress, const QString& name);
93 socExplorerEnumDevice* addEnumDevice(int VID, int PID, qint32 baseAddress, const QString& name);
94 int addEnumDevice(socExplorerEnumDevice* device);
94 int addEnumDevice(socExplorerEnumDevice* device);
95 void writeReg(qint32 address,qint32 value);
95 void writeReg(qint32 address,qint32 value);
96 qint32 readReg(qint32 address);
96 qint32 readReg(qint32 address);
97 bool isLitleEndian();
97 private:
98 private:
98 socexplorerplugin* p_rootDev;
99 socexplorerplugin* p_rootDev;
99 QList<socExplorerEnumDevice*> p_enumeratedDevices;
100 QList<socExplorerEnumDevice*> p_enumeratedDevices;
100 QList<SOCclk*> clktree;
101 QList<SOCclk*> clktree;
102 bool p_litleEndian;
101 };
103 };
102
104
103
105
104
106
105
107
106 #endif // REGISTERSMODEL_H
108 #endif // REGISTERSMODEL_H
107
109
108
110
109
111
110
112
111
113
112
114
113
115
Show file before | Show file after | Hide comments
@@ -1,161 +1,162
1 SOCEXPLORER_ROOT = \"$${PWD}/../..\"
1 SOCEXPLORER_ROOT = \"$${PWD}/../..\"
2
2
3 include($${PWD}/../../build_cfg/socexplorer.pri)
3 include($${PWD}/../../build_cfg/socexplorer.pri)
4
4
5 TARGET = socexplorerengine$${DEBUG_EXT}
5 TARGET = socexplorerengine$${DEBUG_EXT}
6 TEMPLATE = lib
6 TEMPLATE = lib
7
7
8 #more verbose plugin loader to debug plugin loading issues such as dependencies issues
8 #more verbose plugin loader to debug plugin loading issues such as dependencies issues
9 SOCEXPLORER_PLUGIN_LOADER="custom"
9 SOCEXPLORER_PLUGIN_LOADER="custom"
10
10
11 SOCEXPLORER_CHAGESETNUM=$$system(hg id)
11 SOCEXPLORER_CHAGESETNUM=$$system(hg id)
12 isEmpty(SOCEXPLORER_CHAGESETNUM){
12 isEmpty(SOCEXPLORER_CHAGESETNUM){
13 SOCEXPLORER_CHAGESETNUM=6e5eaa13fad9
13 SOCEXPLORER_CHAGESETNUM=6e5eaa13fad9
14 }
14 }
15 SOCEXPLORER_CHAGESETNUMSTR = '\\"$${SOCEXPLORER_CHAGESETNUM}\\"'
15 SOCEXPLORER_CHAGESETNUMSTR = '\\"$${SOCEXPLORER_CHAGESETNUM}\\"'
16 SOCEXPLORER_BRANCH=$$system(hg branch)
16 SOCEXPLORER_BRANCH=$$system(hg branch)
17 isEmpty(SOCEXPLORER_BRANCH){
17 isEmpty(SOCEXPLORER_BRANCH){
18 SOCEXPLORER_BRANCH=default
18 SOCEXPLORER_BRANCH=default
19 }
19 }
20 SOCEXPLORER_BRANCHSTR = '\\"$${SOCEXPLORER_BRANCH}\\"'
20 SOCEXPLORER_BRANCHSTR = '\\"$${SOCEXPLORER_BRANCH}\\"'
21
21
22 DEFINES += SOCEXPLORER_VERSION="\"\\\"0.4.4"\\\"\"
22 DEFINES += SOCEXPLORER_VERSION="\"\\\"0.4.4"\\\"\"
23 DEFINES += SOCEXPLORER_CHAGESET=\"$${SOCEXPLORER_CHAGESETNUMSTR}\"
23 DEFINES += SOCEXPLORER_CHAGESET=\"$${SOCEXPLORER_CHAGESETNUMSTR}\"
24 DEFINES += SOCEXPLORER_BRANCH=\"$${SOCEXPLORER_BRANCHSTR}\"
24 DEFINES += SOCEXPLORER_BRANCH=\"$${SOCEXPLORER_BRANCHSTR}\"
25
25
26
26
27 message("Building SOCEXPLORER changeset $${SOCEXPLORER_CHAGESETNUM}")
27 message("Building SOCEXPLORER changeset $${SOCEXPLORER_CHAGESETNUM}")
28
28
29 DEFINES += SOCEXPLORER_EXPORTS
29 DEFINES += SOCEXPLORER_EXPORTS
30
30
31 include ( plugins/socexplorerplugin.prf )
31 include ( plugins/socexplorerplugin.prf )
32 include ( PeripheralWidget/PeripheralWidget.pri)
32 include ( PeripheralWidget/PeripheralWidget.pri)
33
33
34 win32:CONFIG += dll
34 win32:CONFIG += dll
35 win32:CONFIG -= static
35 win32:CONFIG -= static
36 win32:LIBS+=-L$${SOCEXPLORER_ROOT}/bin/win32 -lsocexplorercommon$${DEBUG_EXT}
36 win32:LIBS+=-L$${SOCEXPLORER_ROOT}/bin/win32 -lsocexplorercommon$${DEBUG_EXT}
37
37
38 contains(SOCEXPLORER_PLUGIN_LOADER,"custom")
38 contains(SOCEXPLORER_PLUGIN_LOADER,"custom")
39 {
39 {
40 unix:LIBS+= -ldl
40 unix:LIBS+= -ldl
41 unix:DEFINES += SOCEXPLORER_CUSTOM_PLUGIN_LOADER
41 unix:DEFINES += SOCEXPLORER_CUSTOM_PLUGIN_LOADER
42 unix:HEADERS += \
42 unix:HEADERS += \
43 pluginloader/unix/unixpluginloader.h
43 pluginloader/unix/unixpluginloader.h
44 unix:SOURCES += \
44 unix:SOURCES += \
45 pluginloader/unix/unixpluginloader.cpp
45 pluginloader/unix/unixpluginloader.cpp
46 }
46 }
47
47
48 target.path = $$[QT_INSTALL_LIBS]
48 target.path = $$[QT_INSTALL_LIBS]
49 isEmpty(target.path) {
49 isEmpty(target.path) {
50 error(can\'t get QT_INSTALL_LIBS)
50 error(can\'t get QT_INSTALL_LIBS)
51 }
51 }
52
52
53 header.path = $$[QT_INSTALL_HEADERS]/SocExplorer
53 header.path = $$[QT_INSTALL_HEADERS]/SocExplorer
54 header.files = engine/socexplorerengine.h \
54 header.files = engine/socexplorerengine.h \
55 pluginloader/pluginscache.h \
55 pluginloader/pluginscache.h \
56 plugins/socexplorerplugin.h \
56 plugins/socexplorerplugin.h \
57 proxy/socexplorerproxy.h \
57 proxy/socexplorerproxy.h \
58 engine/socexplorerxmlfile.h \
58 engine/socexplorerxmlfile.h \
59 SOC/socexplorerenumdevice.h \
59 SOC/socexplorerenumdevice.h \
60 plugins/genericPySysdriver.h \
60 plugins/genericPySysdriver.h \
61 XmlEngine/XMLmodel.h \
61 XmlEngine/XMLmodel.h \
62 XmlEngine/XMLdata.h \
62 XmlEngine/XMLdata.h \
63 XmlEngine/xmldriver.h \
63 XmlEngine/xmldriver.h \
64 SOC/socmodel.h \
64 SOC/socmodel.h \
65 SOC/registerdata.h \
65 SOC/registerdata.h \
66 SOC/socclk.h \
66 SOC/socclk.h \
67 PeripheralWidget/src/peripheralwidget.h \
67 PeripheralWidget/src/peripheralwidget.h \
68 PeripheralWidget/src/registerwidget.h \
68 PeripheralWidget/src/registerwidget.h \
69 PeripheralWidget/src/socregsviewer.h
69 PeripheralWidget/src/socregsviewer.h
70
70
71
71
72
72
73 isEmpty(header.path) {
73 isEmpty(header.path) {
74 error(can\'t get QT_INSTALL_HEADERS)
74 error(can\'t get QT_INSTALL_HEADERS)
75 }
75 }
76
76
77 pluginif.files = pluginsInterface/*.h \
77 pluginif.files = pluginsInterface/*.h \
78 pluginsInterface/*.cpp
78 pluginsInterface/*.cpp
79
79
80 pluginif.path = $$[QT_INSTALL_HEADERS]/SocExplorer/pluginsInterface
80 pluginif.path = $$[QT_INSTALL_HEADERS]/SocExplorer/pluginsInterface
81
81
82
82
83 INSTALLS += target header pluginif
83 INSTALLS += target header pluginif
84
84
85 INCLUDEPATH += engine \
85 INCLUDEPATH += engine \
86 pluginloader \
86 pluginloader \
87 pluginsInterface \
87 pluginsInterface \
88 proxy \
88 proxy \
89 plugins \
89 plugins \
90 pluginManagerWdgt \
90 pluginManagerWdgt \
91 ../common \
91 ../common \
92 ../common/genericBinaryFiles \
92 ../ \
93 ../ \
93 RegisterMVS \
94 RegisterMVS \
94 XmlEngine \
95 XmlEngine \
95 SOC \
96 SOC \
96 PeripheralWidget/src
97 PeripheralWidget/src
97
98
98
99
99 HEADERS += \
100 HEADERS += \
100 pluginloader/pluginscache.h \
101 pluginloader/pluginscache.h \
101 pluginloader/pluginloader.h \
102 pluginloader/pluginloader.h \
102 plugins/genericPySysdriver.h \
103 plugins/genericPySysdriver.h \
103 pluginManagerWdgt/plugintree.h \
104 pluginManagerWdgt/plugintree.h \
104 pluginManagerWdgt/pluginmanagerWDGT.h \
105 pluginManagerWdgt/pluginmanagerWDGT.h \
105 pluginManagerWdgt/pluginlist.h \
106 pluginManagerWdgt/pluginlist.h \
106 pluginManagerWdgt/plugininfoswdgt.h \
107 pluginManagerWdgt/plugininfoswdgt.h \
107 XmlEngine/XMLmodel.h \
108 XmlEngine/XMLmodel.h \
108 XmlEngine/XMLdata.h \
109 XmlEngine/XMLdata.h \
109 SOC/socmodel.h \
110 SOC/socmodel.h \
110 SOC/registerdata.h \
111 SOC/registerdata.h \
111 XmlEngine/xmldriver.h \
112 XmlEngine/xmldriver.h \
112 PeripheralWidget/src/peripheralwidget.h \
113 PeripheralWidget/src/peripheralwidget.h \
113 PeripheralWidget/src/registerwidget.h \
114 PeripheralWidget/src/registerwidget.h \
114 PeripheralWidget/src/socregsviewer.h \
115 PeripheralWidget/src/socregsviewer.h \
115 SOC/socclk.h \
116 SOC/socclk.h \
116 engine/socexplorerengine.h \
117 engine/socexplorerengine.h \
117 engine/socexplorerxmlfile.h \
118 engine/socexplorerxmlfile.h \
118 plugins/socexplorerplugin.h \
119 plugins/socexplorerplugin.h \
119 pluginsInterface/socexplorerplugininterface.h \
120 pluginsInterface/socexplorerplugininterface.h \
120 pluginsInterface/socexplorerplugininterface_global.h \
121 pluginsInterface/socexplorerplugininterface_global.h \
121 proxy/socexplorerproxy.h \
122 proxy/socexplorerproxy.h \
122 SOC/socexplorerenumdevice.h \
123 SOC/socexplorerenumdevice.h \
123 PySocExplorerEngine.h
124 PySocExplorerEngine.h
124
125
125
126
126
127
127
128
128
129
129
130
130 SOURCES += \
131 SOURCES += \
131 pluginloader/pluginscache.cpp \
132 pluginloader/pluginscache.cpp \
132 pluginloader/pluginloader.cpp \
133 pluginloader/pluginloader.cpp \
133 pluginManagerWdgt/plugintree.cpp \
134 pluginManagerWdgt/plugintree.cpp \
134 pluginManagerWdgt/pluginmanagerWDGT.cpp \
135 pluginManagerWdgt/pluginmanagerWDGT.cpp \
135 pluginManagerWdgt/pluginlist.cpp \
136 pluginManagerWdgt/pluginlist.cpp \
136 pluginManagerWdgt/plugininfoswdgt.cpp \
137 pluginManagerWdgt/plugininfoswdgt.cpp \
137 XmlEngine/XMLmodel.cpp \
138 XmlEngine/XMLmodel.cpp \
138 XmlEngine/XMLdata.cpp \
139 XmlEngine/XMLdata.cpp \
139 SOC/socmodel.cpp \
140 SOC/socmodel.cpp \
140 SOC/registerdata.cpp \
141 SOC/registerdata.cpp \
141 XmlEngine/xmldriver.cpp \
142 XmlEngine/xmldriver.cpp \
142 PeripheralWidget/src/peripheralwidget.cpp \
143 PeripheralWidget/src/peripheralwidget.cpp \
143 PeripheralWidget/src/registerwidget.cpp \
144 PeripheralWidget/src/registerwidget.cpp \
144 PeripheralWidget/src/socregsviewer.cpp \
145 PeripheralWidget/src/socregsviewer.cpp \
145 SOC/socclk.cpp \
146 SOC/socclk.cpp \
146 plugins/genericPySysdriver.cpp \
147 plugins/genericPySysdriver.cpp \
147 engine/socexplorerengine.cpp \
148 engine/socexplorerengine.cpp \
148 engine/socexplorerxmlfile.cpp \
149 engine/socexplorerxmlfile.cpp \
149 proxy/socexplorerproxy.cpp \
150 proxy/socexplorerproxy.cpp \
150 SOC/socexplorerenumdevice.cpp \
151 SOC/socexplorerenumdevice.cpp \
151 plugins/socexplorerplugin.cpp
152 plugins/socexplorerplugin.cpp
152
153
153
154
154 OTHER_FILES += \
155 OTHER_FILES += \
155 plugins/socexplorerplugin.cpp \
156 plugins/socexplorerplugin.cpp \
156 pluginsInterface/socexplorerplugininterface.cpp \
157 pluginsInterface/socexplorerplugininterface.cpp \
157 plugins/socexplorerplugin.prf \
158 plugins/socexplorerplugin.prf \
158 pythongenerator.sh \
159 pythongenerator.sh \
159 pythonQtgeneratorCfg.txt
160 pythonQtgeneratorCfg.txt
160
161
161
162
Show file before | Show file after | Hide comments
@@ -1,285 +1,290
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) 2012, Plasma Physics Laboratory - CNRS
3 -- Copyright (C) 2012, 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@lpp.polytechnique.fr
20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
21 ----------------------------------------------------------------------------*/
21 ----------------------------------------------------------------------------*/
22 #include "socexplorerengine.h"
22 #include "socexplorerengine.h"
23 #include <proxy/socexplorerproxy.h>
23 #include <proxy/socexplorerproxy.h>
24
24
25 SocExplorerEngine* SocExplorerEngine::_self = NULL;
25 SocExplorerEngine* SocExplorerEngine::_self = NULL;
26 socExplorerXmlModel* SocExplorerEngine::p_xmlmodel=NULL;
26 socExplorerXmlModel* SocExplorerEngine::p_xmlmodel=NULL;
27 QMainWindow* SocExplorerEngine::mainWindow=NULL;
27 QMainWindow* SocExplorerEngine::mainWindow=NULL;
28 QList<SOCModel*>* SocExplorerEngine::SOCs=NULL;
28 QList<SOCModel*>* SocExplorerEngine::SOCs=NULL;
29 int SocExplorerEngine::loglvl=1;
29 int SocExplorerEngine::loglvl=1;
30
30
31 SocExplorerEngine::SocExplorerEngine(QObject *parent) :
31 SocExplorerEngine::SocExplorerEngine(QObject *parent) :
32 QObject(parent)
32 QObject(parent)
33 {
33 {
34 if(SOCs==NULL)
34 if(SOCs==NULL)
35 {
35 {
36 SOCs = new QList<SOCModel*>;
36 SOCs = new QList<SOCModel*>;
37 }
37 }
38
38
39 }
39 }
40
40
41
41
42 void SocExplorerEngine::init()
42 void SocExplorerEngine::init()
43 {
43 {
44 QDir dir;
44 QDir dir;
45 if(!_self)
45 if(!_self)
46 {
46 {
47 _self= new SocExplorerEngine;
47 _self= new SocExplorerEngine;
48 }
48 }
49 if(!dir.exists(configFolder()))
49 if(!dir.exists(configFolder()))
50 dir.mkdir(configFolder());
50 dir.mkdir(configFolder());
51 p_xmlmodel = new socExplorerXmlModel(_self);
51 p_xmlmodel = new socExplorerXmlModel(_self);
52 p_xmlmodel->updateSOClist();
52 p_xmlmodel->updateSOClist();
53 }
53 }
54
54
55 QString SocExplorerEngine::configFolder()
55 QString SocExplorerEngine::configFolder()
56 {
56 {
57 return QString(SOCEXPLORER_CONFIG_PATH);
57 return QString(SOCEXPLORER_CONFIG_PATH);
58 }
58 }
59
59
60 QStringList SocExplorerEngine::pluginFolders()
60 QStringList SocExplorerEngine::pluginFolders()
61 {
61 {
62 if(!_self)
62 if(!_self)
63 init();
63 init();
64 QStringList folders;
64 QStringList folders;
65 QDir pluginFolders(QString(SOCEXPLORER_CONFIG_PATH)+"/plugin.conf.d");
65 QDir pluginFolders(QString(SOCEXPLORER_CONFIG_PATH)+"/plugin.conf.d");
66 if(pluginFolders.exists())
66 if(pluginFolders.exists())
67 {
67 {
68 pluginFolders.setFilter(QDir::Files | QDir::NoSymLinks);
68 pluginFolders.setFilter(QDir::Files | QDir::NoSymLinks);
69 QFileInfoList list = pluginFolders.entryInfoList();
69 QFileInfoList list = pluginFolders.entryInfoList();
70 for (int i = 0; i < list.size(); ++i)
70 for (int i = 0; i < list.size(); ++i)
71 {
71 {
72 QFileInfo fileInfo = list.at(i);
72 QFileInfo fileInfo = list.at(i);
73 if(fileInfo.suffix()=="conf")
73 if(fileInfo.suffix()=="conf")
74 {
74 {
75 QFile confFile(fileInfo.absoluteFilePath());
75 QFile confFile(fileInfo.absoluteFilePath());
76 if(confFile.open(QIODevice::ReadOnly))
76 if(confFile.open(QIODevice::ReadOnly))
77 {
77 {
78 while (!confFile.atEnd())
78 while (!confFile.atEnd())
79 {
79 {
80 QString line = confFile.readLine();
80 QString line = confFile.readLine();
81 QDir plugDir(line.remove("\n"));
81 QDir plugDir(line.remove("\n"));
82 if(plugDir.exists() && !folders.contains(plugDir.absolutePath()))
82 if(plugDir.exists() && !folders.contains(plugDir.absolutePath()))
83 {
83 {
84 folders.append(plugDir.absolutePath());
84 folders.append(plugDir.absolutePath());
85 }
85 }
86 }
86 }
87 }
87 }
88 }
88 }
89 }
89 }
90 }
90 }
91 return folders;
91 return folders;
92 }
92 }
93
93
94 SOCModel *SocExplorerEngine::plugin2Soc(socexplorerplugin *plugin)
94 SOCModel *SocExplorerEngine::plugin2Soc(socexplorerplugin *plugin)
95 {
95 {
96 if(!_self)
96 if(!_self)
97 init();
97 init();
98 if(plugin)
98 if(plugin)
99 {
99 {
100 while (plugin->parent!=NULL) {
100 while (plugin->parent!=NULL) {
101 plugin = plugin->parent;
101 plugin = plugin->parent;
102 }
102 }
103 for(int i=0;i<SOCs->count();i++)
103 for(int i=0;i<SOCs->count();i++)
104 {
104 {
105 if(SOCs->at(i)->isRootDev(plugin))
105 if(SOCs->at(i)->isRootDev(plugin))
106 return SOCs->at(i);
106 return SOCs->at(i);
107 }
107 }
108 //no soc found so create a new one
108 //no soc found so create a new one
109 SOCModel* soc=new SOCModel(plugin);
109 SOCModel* soc=new SOCModel(plugin);
110 SOCs->append(soc);
110 SOCs->append(soc);
111 return soc;
111 return soc;
112 }
112 }
113 return NULL;
113 return NULL;
114 }
114 }
115
115
116
116
117 int SocExplorerEngine::addEnumDevice(socexplorerplugin* rootPlugin,int VID, int PID, qint32 baseAddress, const QString &name)
117 int SocExplorerEngine::addEnumDevice(socexplorerplugin* rootPlugin,int VID, int PID, qint32 baseAddress, const QString &name)
118 {
118 {
119 if(!_self)
119 if(!_self)
120 init();
120 init();
121 SOCModel* soc = plugin2Soc(rootPlugin);
121 SOCModel* soc = plugin2Soc(rootPlugin);
122 if(soc && !soc->enumDeviceExists(baseAddress))
122 if(soc && !soc->enumDeviceExists(baseAddress))
123 {
123 {
124 emit _self->enumDeviceAdded(soc->addEnumDevice(VID,PID,baseAddress,name));
124 emit _self->enumDeviceAdded(soc->addEnumDevice(VID,PID,baseAddress,name));
125 return 1;
125 return 1;
126 }
126 }
127 return 0;
127 return 0;
128 }
128 }
129
129
130 QList<SOCModel *> *SocExplorerEngine::getSOCs()
130 QList<SOCModel *> *SocExplorerEngine::getSOCs()
131 {
131 {
132 if(!_self)
132 if(!_self)
133 init();
133 init();
134 return SOCs;
134 return SOCs;
135 }
135 }
136
136
137 qint32 SocExplorerEngine::getEnumDeviceBaseAddress(const QString& rootPlugin,int VID, int PID, int count)
137 qint32 SocExplorerEngine::getEnumDeviceBaseAddress(const QString& rootPlugin,int VID, int PID, int count)
138 {
138 {
139 socexplorerplugin* plugin = socexplorerproxy::findPlugin(rootPlugin);
139 socexplorerplugin* plugin = socexplorerproxy::findPlugin(rootPlugin);
140 if(plugin==NULL)return -1;
140 if(plugin==NULL)return -1;
141 SOCModel* soc = plugin2Soc(plugin);
141 SOCModel* soc = plugin2Soc(plugin);
142 if(soc==NULL)
142 if(soc==NULL)
143 return -1;
143 return -1;
144 return soc->getEnumDeviceBaseAddress(VID,PID,count);
144 return soc->getEnumDeviceBaseAddress(VID,PID,count);
145 }
145 }
146
146
147 qint32 SocExplorerEngine::getEnumDeviceBaseAddress(socexplorerplugin *plugin, int VID, int PID, int count)
147 qint32 SocExplorerEngine::getEnumDeviceBaseAddress(socexplorerplugin *plugin, int VID, int PID, int count)
148 {
148 {
149 if(plugin==NULL)return -1;
149 if(plugin==NULL)return -1;
150 SOCModel* soc = plugin2Soc(plugin);
150 SOCModel* soc = plugin2Soc(plugin);
151 if(soc==NULL)
151 if(soc==NULL)
152 return -1;
152 return -1;
153 return soc->getEnumDeviceBaseAddress(VID,PID,count);
153 return soc->getEnumDeviceBaseAddress(VID,PID,count);
154 }
154 }
155
155
156 qint32 SocExplorerEngine::getEnumDeviceCount(socexplorerplugin *plugin, int VID, int PID)
156 qint32 SocExplorerEngine::getEnumDeviceCount(socexplorerplugin *plugin, int VID, int PID)
157 {
157 {
158 if(plugin==NULL)return 0;
158 if(plugin==NULL)return 0;
159 SOCModel* soc = plugin2Soc(plugin);
159 SOCModel* soc = plugin2Soc(plugin);
160 if(soc==NULL)
160 if(soc==NULL)
161 return 0;
161 return 0;
162 return soc->getEnumDeviceCount(VID,PID);
162 return soc->getEnumDeviceCount(VID,PID);
163 }
163 }
164
164
165 qint32 SocExplorerEngine::getEnumDeviceCount(const QString &rootPlugin, int VID, int PID)
165 qint32 SocExplorerEngine::getEnumDeviceCount(const QString &rootPlugin, int VID, int PID)
166 {
166 {
167 socexplorerplugin* plugin = socexplorerproxy::findPlugin(rootPlugin);
167 socexplorerplugin* plugin = socexplorerproxy::findPlugin(rootPlugin);
168 if(plugin==NULL)return 0;
168 if(plugin==NULL)return 0;
169 SOCModel* soc = plugin2Soc(plugin);
169 SOCModel* soc = plugin2Soc(plugin);
170 if(soc==NULL)
170 if(soc==NULL)
171 return 0;
171 return 0;
172 return soc->getEnumDeviceCount(VID,PID);
172 return soc->getEnumDeviceCount(VID,PID);
173 }
173 }
174
174
175 int SocExplorerEngine::addEnumDevice(const QString &rootPlugin, int VID, int PID, qint32 baseAddress, const QString &name)
175 int SocExplorerEngine::addEnumDevice(const QString &rootPlugin, int VID, int PID, qint32 baseAddress, const QString &name)
176 {
176 {
177 socexplorerplugin* plugin = socexplorerproxy::findPlugin(rootPlugin);
177 socexplorerplugin* plugin = socexplorerproxy::findPlugin(rootPlugin);
178 if(plugin==NULL)return -1;
178 if(plugin==NULL)return -1;
179 SOCModel* soc = plugin2Soc(plugin);
179 SOCModel* soc = plugin2Soc(plugin);
180 if(soc==NULL)
180 if(soc==NULL)
181 return -1;
181 return -1;
182 soc->addEnumDevice(VID,PID,baseAddress,name);
182 soc->addEnumDevice(VID,PID,baseAddress,name);
183 return 1;
183 return 1;
184 }
184 }
185
185
186
186
187 QString SocExplorerEngine::getDevName(int VID, int PID)
187 QString SocExplorerEngine::getDevName(int VID, int PID)
188 {
188 {
189 QList<QDomNodeList> list=p_xmlmodel->getAllNodes("peripheral");
189 QList<QDomNodeList> list=p_xmlmodel->getAllNodes("peripheral");
190 for(int i=0;i<list.count();i++)
190 for(int i=0;i<list.count();i++)
191 {
191 {
192 QDomNodeList nodes=list.at(i);
192 QDomNodeList nodes=list.at(i);
193 for(int l=0;l<nodes.count();l++)
193 for(int l=0;l<nodes.count();l++)
194 {
194 {
195 QDomElement node=nodes.at(l).toElement();
195 QDomElement node=nodes.at(l).toElement();
196 int nodeVID=node.attribute("vid","0").toInt();
196 int nodeVID=node.attribute("vid","0").toInt();
197 int nodePID=node.attribute("pid","0").toInt();
197 int nodePID=node.attribute("pid","0").toInt();
198 if((nodeVID==VID)&&(nodePID==PID))
198 if((nodeVID==VID)&&(nodePID==PID))
199 {
199 {
200 return node.attribute("name","Unknow device");
200 return node.attribute("name","Unknow device");
201 }
201 }
202 }
202 }
203 }
203 }
204 return QString("Unknow device");
204 return QString("Unknow device");
205 }
205 }
206
206
207 QString SocExplorerEngine::SocExplorerVersion(){return QString(SOCEXPLORER_VERSION);}
207 QString SocExplorerEngine::SocExplorerVersion(){return QString(SOCEXPLORER_VERSION);}
208
208
209 QString SocExplorerEngine::SocExplorerChangeset(){return QString(SOCEXPLORER_CHAGESET).split(" ").at(0);}
209 QString SocExplorerEngine::SocExplorerChangeset(){return QString(SOCEXPLORER_CHAGESET).split(" ").at(0);}
210
210
211 QString SocExplorerEngine::SocExplorerBranch(){return QString(SOCEXPLORER_BRANCH);}
211 QString SocExplorerEngine::SocExplorerBranch(){return QString(SOCEXPLORER_BRANCH);}
212
212
213 socExplorerXmlModel *SocExplorerEngine::xmlModel()
213 socExplorerXmlModel *SocExplorerEngine::xmlModel()
214 {
214 {
215 if(!_self)
215 if(!_self)
216 init();
216 init();
217 return p_xmlmodel;
217 return p_xmlmodel;
218 }
218 }
219
219
220 void SocExplorerEngine::setMainWindow(QMainWindow *Mainwindow)
220 void SocExplorerEngine::setMainWindow(QMainWindow *Mainwindow)
221 {
221 {
222 if(!_self)
222 if(!_self)
223 init();
223 init();
224 mainWindow=Mainwindow;
224 mainWindow=Mainwindow;
225 }
225 }
226
226
227 QProgressBar *SocExplorerEngine::getProgressBar(const QString& format, int max)
227 QProgressBar *SocExplorerEngine::getProgressBar(const QString& format, int max)
228 {
228 {
229 if(!_self)
229 if(!_self)
230 init();
230 init();
231 QProgressBar* progressBar;
231 QProgressBar* progressBar;
232 if(mainWindow!=NULL)
232 if(mainWindow!=NULL)
233 {
233 {
234 progressBar = new QProgressBar(mainWindow);
234 progressBar = new QProgressBar(mainWindow);
235 mainWindow->statusBar()->addWidget(progressBar);
235 mainWindow->statusBar()->addWidget(progressBar);
236 }
236 }
237 else
237 else
238 {
238 {
239 progressBar = new QProgressBar();
239 progressBar = new QProgressBar();
240 }
240 }
241 progressBar->setMaximum(max);
241 progressBar->setMaximum(max);
242 progressBar->setFormat(format);
242 progressBar->setFormat(format);
243 return progressBar;
243 return progressBar;
244 }
244 }
245
245
246 void SocExplorerEngine::deleteProgressBar(QProgressBar *progressBar)
246 void SocExplorerEngine::deleteProgressBar(QProgressBar *progressBar)
247 {
247 {
248 if(mainWindow!=NULL)
248 if(mainWindow!=NULL)
249 {
249 {
250 mainWindow->statusBar()->removeWidget(progressBar);
250 mainWindow->statusBar()->removeWidget(progressBar);
251 }
251 }
252 delete progressBar;
252 delete progressBar;
253 }
253 }
254
254
255 void SocExplorerEngine::addSOC(socexplorerplugin *rootPlugin)
255 void SocExplorerEngine::addSOC(socexplorerplugin *rootPlugin)
256 {
256 {
257 plugin2Soc(rootPlugin);
257 plugin2Soc(rootPlugin);
258 }
258 }
259
259
260 void SocExplorerEngine::removeSOC(socexplorerplugin *rootPlugin)
260 void SocExplorerEngine::removeSOC(socexplorerplugin *rootPlugin)
261 {
261 {
262 SOCModel* soc=plugin2Soc(rootPlugin);
262 SOCModel* soc=plugin2Soc(rootPlugin);
263 SOCs->removeAll(soc);
263 SOCs->removeAll(soc);
264 delete soc;
264 delete soc;
265 }
265 }
266
266
267 void SocExplorerEngine::message(socexplorerplugin *sender, const QString &message, int debugLevel)
267 void SocExplorerEngine::message(socexplorerplugin *sender, const QString &message, int debugLevel)
268 {
268 {
269 // TODO add multi output message manager IE also log in files
269 // TODO add multi output message manager IE also log in files
270 if(!_self)
270 if(!_self)
271 init();
271 init();
272 if(loglvl>=debugLevel)
272 if(loglvl>=debugLevel)
273 qDebug()<< QTime::currentTime().toString()+" " + sender->instanceName()+":"+message;
273 qDebug()<< QTime::currentTime().toString()+" " + sender->instanceName()+":"+message;
274 }
274 }
275
275
276 void SocExplorerEngine::setLogLevel(int level)
276 void SocExplorerEngine::setLogLevel(int level)
277 {
277 {
278 if(!_self)
278 if(!_self)
279 init();
279 init();
280 printf("Set log level to %d\n",level);
280 printf("Set log level to %d\n",level);
281 loglvl = level;
281 loglvl = level;
282 }
282 }
283
283
284 bool SocExplorerEngine::isSocLitleEndian(socexplorerplugin *plugin)
285 {
286 return plugin2Soc(plugin)->isLitleEndian();
287 }
284
288
285
289
290
Show file before | Show file after | Hide comments
@@ -1,137 +1,138
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) 2012, Plasma Physics Laboratory - CNRS
3 -- Copyright (C) 2012, 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@lpp.polytechnique.fr
20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
21 ----------------------------------------------------------------------------*/
21 ----------------------------------------------------------------------------*/
22 #ifndef SOCEXPLORERENGINE_H
22 #ifndef SOCEXPLORERENGINE_H
23 #define SOCEXPLORERENGINE_H
23 #define SOCEXPLORERENGINE_H
24
24
25 #include <stdint.h>
25 #include <stdint.h>
26 #include <QObject>
26 #include <QObject>
27 #include <QtWidgets>
27 #include <QtWidgets>
28 #include <QStringList>
28 #include <QStringList>
29 #include <QDomDocument>
29 #include <QDomDocument>
30 #include <QDomElement>
30 #include <QDomElement>
31 #include <QDomNodeList>
31 #include <QDomNodeList>
32 #include <QFile>
32 #include <QFile>
33 #include <QTextStream>
33 #include <QTextStream>
34 #include <QDir>
34 #include <QDir>
35 #include <QApplication>
35 #include <QApplication>
36 #include <QtCore/qglobal.h>
36 #include <QtCore/qglobal.h>
37 #include <QFileDialog>
37 #include <QFileDialog>
38 #include <socexplorerxmlfile.h>
38 #include <socexplorerxmlfile.h>
39 #include <socexplorerenumdevice.h>
39 #include <socexplorerenumdevice.h>
40 #include <XMLmodel.h>
40 #include <XMLmodel.h>
41 #include <peripheralwidget.h>
41 #include <peripheralwidget.h>
42 #include <registerwidget.h>
42 #include <registerwidget.h>
43 #include <socmodel.h>
43 #include <socmodel.h>
44
44
45 #if defined(SOCEXPLORER_SDK_BUILD)
45 #if defined(SOCEXPLORER_SDK_BUILD)
46 # define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
46 # define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
47 #else
47 #else
48 # define SOCEXPLORER_SDK_EXPORT Q_DECL_IMPORT
48 # define SOCEXPLORER_SDK_EXPORT Q_DECL_IMPORT
49 #endif
49 #endif
50
50
51
51
52 class SOCEXPLORER_SDK_EXPORT SocExplorerAutoProgressBar
52 class SOCEXPLORER_SDK_EXPORT SocExplorerAutoProgressBar
53 {
53 {
54 public:
54 public:
55 SocExplorerAutoProgressBar(QProgressBar* progressBar=NULL)
55 SocExplorerAutoProgressBar(QProgressBar* progressBar=NULL)
56 {
56 {
57 this->p_progressbar=progressBar;
57 this->p_progressbar=progressBar;
58 }
58 }
59 ~SocExplorerAutoProgressBar()
59 ~SocExplorerAutoProgressBar()
60 {
60 {
61 if(p_progressbar)
61 if(p_progressbar)
62 {
62 {
63 delete p_progressbar;
63 delete p_progressbar;
64 }
64 }
65 }
65 }
66 void setProgressBar(QProgressBar* progressBar)
66 void setProgressBar(QProgressBar* progressBar)
67 {
67 {
68 this->p_progressbar=progressBar;
68 this->p_progressbar=progressBar;
69 }
69 }
70 void setValue(int value)
70 void setValue(int value)
71 {
71 {
72 p_progressbar->setValue(value);
72 p_progressbar->setValue(value);
73 }
73 }
74 private:
74 private:
75 QProgressBar* p_progressbar;
75 QProgressBar* p_progressbar;
76 };
76 };
77
77
78 //! SocExplorerEngine is a pure static class which aims to provide services for both SocExplorer software and plugins.
78 //! SocExplorerEngine is a pure static class which aims to provide services for both SocExplorer software and plugins.
79
79
80 class SOCEXPLORER_SDK_EXPORT SocExplorerEngine : public QObject
80 class SOCEXPLORER_SDK_EXPORT SocExplorerEngine : public QObject
81 {
81 {
82 Q_OBJECT
82 Q_OBJECT
83 private:
83 private:
84 static SocExplorerEngine* _self;
84 static SocExplorerEngine* _self;
85 SocExplorerEngine(QObject *parent = 0);
85 SocExplorerEngine(QObject *parent = 0);
86 static void init();
86 static void init();
87
87
88 public:
88 public:
89 static SocExplorerEngine* self(){ if(!_self){_self= new SocExplorerEngine;}return _self;}
89 static SocExplorerEngine* self(){ if(!_self){_self= new SocExplorerEngine;}return _self;}
90 //! Return the configuration folder path, OS dependant.
90 //! Return the configuration folder path, OS dependant.
91 SOCEXPLORER_SDK_EXPORT static QString configFolder();
91 SOCEXPLORER_SDK_EXPORT static QString configFolder();
92 //! Return the default plugin folder path, OS dependant.
92 //! Return the default plugin folder path, OS dependant.
93 static QStringList pluginFolders();
93 static QStringList pluginFolders();
94 static QString configPath(){return QString(SOCEXPLORER_CONFIG_PATH);}
94 static QString configPath(){return QString(SOCEXPLORER_CONFIG_PATH);}
95 static QString sharePath(){return QString(SOCEXPLORER_SHARE_PATH);}
95 static QString sharePath(){return QString(SOCEXPLORER_SHARE_PATH);}
96 static int addEnumDevice(socexplorerplugin* rootPlugin,int VID,int PID,qint32 baseAddress,const QString& name);
96 static int addEnumDevice(socexplorerplugin* rootPlugin,int VID,int PID,qint32 baseAddress,const QString& name);
97 static QList<SOCModel*>* getSOCs();
97 static QList<SOCModel*>* getSOCs();
98 static QString getDevName(int VID, int PID);
98 static QString getDevName(int VID, int PID);
99 static QString SocExplorerVersion();
99 static QString SocExplorerVersion();
100 static QString SocExplorerChangeset();
100 static QString SocExplorerChangeset();
101 static QString SocExplorerBranch();
101 static QString SocExplorerBranch();
102 static socExplorerXmlModel* xmlModel();
102 static socExplorerXmlModel* xmlModel();
103 static void setMainWindow(QMainWindow* Mainwindow);
103 static void setMainWindow(QMainWindow* Mainwindow);
104 static QProgressBar* getProgressBar(const QString &format, int max);
104 static QProgressBar* getProgressBar(const QString &format, int max);
105 static void deleteProgressBar(QProgressBar* progressBar);
105 static void deleteProgressBar(QProgressBar* progressBar);
106 static void addSOC(socexplorerplugin* rootPlugin);
106 static void addSOC(socexplorerplugin* rootPlugin);
107 static void removeSOC(socexplorerplugin* rootPlugin);
107 static void removeSOC(socexplorerplugin* rootPlugin);
108 static void message(socexplorerplugin* sender,const QString& message,int debugLevel=0);
108 static void message(socexplorerplugin* sender,const QString& message,int debugLevel=0);
109 static void setLogLevel(int level);
109 static void setLogLevel(int level);
110 static bool isSocLitleEndian(socexplorerplugin* plugin);
110 signals:
111 signals:
111 void enumDeviceAdded(socExplorerEnumDevice* device);
112 void enumDeviceAdded(socExplorerEnumDevice* device);
112 public slots:
113 public slots:
113 QString getSocExplorerVersion(){return SocExplorerEngine::SocExplorerVersion();}
114 QString getSocExplorerVersion(){return SocExplorerEngine::SocExplorerVersion();}
114 QString getSocExplorerChangeset(){return SocExplorerEngine::SocExplorerChangeset();}
115 QString getSocExplorerChangeset(){return SocExplorerEngine::SocExplorerChangeset();}
115 QString getSocExplorerBranch(){return SocExplorerEngine::SocExplorerBranch();}
116 QString getSocExplorerBranch(){return SocExplorerEngine::SocExplorerBranch();}
116 qint32 getEnumDeviceBaseAddress(const QString& rootPlugin,int VID,int PID,int count=0);
117 qint32 getEnumDeviceBaseAddress(const QString& rootPlugin,int VID,int PID,int count=0);
117 qint32 getEnumDeviceBaseAddress(socexplorerplugin* plugin,int VID,int PID,int count=0);
118 qint32 getEnumDeviceBaseAddress(socexplorerplugin* plugin,int VID,int PID,int count=0);
118 qint32 getEnumDeviceCount(socexplorerplugin* plugin,int VID,int PID);
119 qint32 getEnumDeviceCount(socexplorerplugin* plugin,int VID,int PID);
119 qint32 getEnumDeviceCount(const QString& rootPlugin,int VID,int PID);
120 qint32 getEnumDeviceCount(const QString& rootPlugin,int VID,int PID);
120 int addEnumDevice(const QString& rootPlugin,int VID,int PID,qint32 baseAddress,const QString& name);
121 int addEnumDevice(const QString& rootPlugin,int VID,int PID,qint32 baseAddress,const QString& name);
121
122
122 private:
123 private:
123 static SOCModel* plugin2Soc(socexplorerplugin* plugin);
124 static SOCModel* plugin2Soc(socexplorerplugin* plugin);
124 static socExplorerXmlModel* p_xmlmodel;
125 static socExplorerXmlModel* p_xmlmodel;
125 static QMainWindow* mainWindow;
126 static QMainWindow* mainWindow;
126 static QList<SOCModel*>* SOCs;
127 static QList<SOCModel*>* SOCs;
127 static int loglvl;
128 static int loglvl;
128 };
129 };
129
130
130 #endif // SOCEXPLORERENGINE_H
131 #endif // SOCEXPLORERENGINE_H
131
132
132
133
133
134
134
135
135
136
136
137
137
138
Show file before | Show file after | Hide comments
@@ -1,103 +1,75
1
1
2 #include <genericPySysdriver.h>
2 #include <genericPySysdriver.h>
3 #include <socexplorerplugin.h>
3 #include <socexplorerplugin.h>
4 #ifdef WIN32
4 #ifdef WIN32
5 #include <stdlib.h>
5 #include <stdlib.h>
6 #define socexplorerBswap32(X) _byteswap_ulong(X)
6 #define socexplorerBswap32(X) _byteswap_ulong(X)
7 #else
7 #else
8 #ifdef UNIX
8 #ifdef UNIX
9 #include <byteswap.h>
9 #include <byteswap.h>
10 #define socexplorerBswap32(X) bswap_32(X)
10 #define socexplorerBswap32(X) bswap_32(X)
11 #endif
11 #endif
12 #endif
12 #endif
13
13
14
14 #include <socexplorerengine.h>
15
15
16
16
17 genericPySysdriver::genericPySysdriver(socexplorerplugin* plugin,QObject* parent):
17 genericPySysdriver::genericPySysdriver(socexplorerplugin* plugin,QObject* parent):
18 QObject(parent)
18 QObject(parent)
19 {
19 {
20 Q_UNUSED(parent)
20 Q_UNUSED(parent)
21 this->plugin = plugin;
21 this->plugin = plugin;
22 }
22 }
23
23
24 QVariantList genericPySysdriver::Read(unsigned int address,unsigned int count)
24 QVariantList genericPySysdriver::Read(unsigned int address,unsigned int count)
25 {
25 {
26 unsigned int data[count];
26 unsigned int data[count];
27 QVariantList result;
27 QVariantList result;
28 this->plugin->Read(data,count,address);
28 this->plugin->Read(data,count,address);
29 for(unsigned int i = 0;i<count;i++)
29 for(unsigned int i = 0;i<count;i++)
30 {
30 {
31 result.append(QVariant((int)data[i]));
31 result.append(QVariant((int)data[i]));
32 }
32 }
33 return result;
33 return result;
34 }
34 }
35 void genericPySysdriver::Write(unsigned int address,QList<QVariant> dataList)
35 void genericPySysdriver::Write(unsigned int address,QList<QVariant> dataList)
36 {
36 {
37 unsigned int data[dataList.count()];
37 unsigned int data[dataList.count()];
38 for(int i = 0;i<dataList.count();i++)
38 for(int i = 0;i<dataList.count();i++)
39 {
39 {
40 data[i] = (unsigned int)dataList.at(i).toUInt();
40 data[i] = (unsigned int)dataList.at(i).toUInt();
41 }
41 }
42 this->plugin->Write(data,dataList.count(),address);
42 this->plugin->Write(data,dataList.count(),address);
43 }
43 }
44
44
45 bool genericPySysdriver::dumpMemory(unsigned int address,unsigned int count,QString file)
45 bool genericPySysdriver::dumpMemory(unsigned int address,unsigned int count,QString file)
46 {
46 {
47 unsigned int* buffer = (unsigned int*)malloc(count*sizeof(unsigned int));
47 return this->plugin->dumpMemory(address,count,file);
48 if(buffer!=NULL)
49 {
50 this->plugin->Read(buffer,count,address);
51 QFile outfile(file);
52 if (!outfile.open(QIODevice::ReadWrite | QIODevice::Text))
53 return false;
54 QTextStream out(&outfile);
55 for(int i=0;(unsigned int)i<count;i++)
56 out << "0x"+QString::number(address+(i*4),16) + ": 0x" + QString::number(buffer[i],16) + "\n";
57 free(buffer);
58 out.flush();
59 outfile.close();
60 return true;
61 }
62 return false;
63 }
48 }
64
49
65 bool genericPySysdriver::memSet(unsigned int address,int value, unsigned int count)
50 bool genericPySysdriver::memSet(unsigned int address,int value, unsigned int count)
66 {
51 {
67 unsigned int* buffer = (unsigned int*)malloc(count*sizeof(unsigned int));
52 return this->plugin->memSet(address,value,count);
68 if(buffer!=NULL)
69 {
70 memset((void*)buffer,value,count*sizeof(unsigned int));
71 this->plugin->Write(buffer,count,address);
72 free(buffer );
73 return true;
74 }
75 return false;
76 }
53 }
77
54
78 bool genericPySysdriver::loadbin(unsigned int address,QString file)
55 bool genericPySysdriver::loadbin(unsigned int address,QString file)
79 {
56 {
80 QFile infile(file);
57 return this->plugin->loadbin(address,file);
81 if (!infile.open(QIODevice::ReadOnly))
58
82 return false;
59 }
83 uint32_t* buffer = (uint32_t*)malloc(infile.size());
84 if(buffer!=NULL)
85 {
86 infile.read((char*)buffer,infile.size());
87 for(int i=0;i<(infile.size()/4);i++)
88 {
89 buffer[i] = socexplorerBswap32(buffer[i]);
90 }
91 this->plugin->Write(buffer,infile.size()/4,address);
92 free(buffer);
93 return true;
94 }
95 return false;
96
60
61 bool genericPySysdriver::loadfile(abstractBinFile *file)
62 {
63 return this->plugin->loadfile(file);
64 }
65
66 bool genericPySysdriver::dumpMemory(unsigned int address, unsigned int count, QString file, const QString &format)
67 {
68 return this->plugin->dumpMemory(address,count,file,format);
97 }
69 }
98
70
99 QString genericPySysdriver::instance()
71 QString genericPySysdriver::instance()
100 {
72 {
101 return plugin->instanceName();
73 return plugin->instanceName();
102 }
74 }
103
75
Show file before | Show file after | Hide comments
@@ -1,58 +1,61
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) 2011, Plasma Physics Laboratory - CNRS
3 -- Copyright (C) 2011, 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@lpp.polytechnique.fr
20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
21 ----------------------------------------------------------------------------*/
21 ----------------------------------------------------------------------------*/
22 #ifndef GENERICPYSYSDRIVER_H
22 #ifndef GENERICPYSYSDRIVER_H
23 #define GENERICPYSYSDRIVER_H
23 #define GENERICPYSYSDRIVER_H
24 #include <QObject>
24 #include <QObject>
25 #include <QVariant>
25 #include <QVariant>
26 #include <QVariantList>
26 #include <QVariantList>
27 #include <malloc.h>
27 #include <malloc.h>
28 #include <QFile>
28 #include <QFile>
29 #include <stdint.h>
29 #include <stdint.h>
30 #include <QTextStream>
30 #include <QTextStream>
31 #include <abstractbinfile.h>
31 #if defined(SOCEXPLORER_SDK_BUILD)
32 #if defined(SOCEXPLORER_SDK_BUILD)
32 # define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
33 # define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
33 #else
34 #else
34 # define SOCEXPLORER_SDK_EXPORT Q_DECL_IMPORT
35 # define SOCEXPLORER_SDK_EXPORT Q_DECL_IMPORT
35 #endif
36 #endif
36 class socexplorerplugin;
37 class socexplorerplugin;
37
38
38 class SOCEXPLORER_SDK_EXPORT genericPySysdriver : public QObject
39 class SOCEXPLORER_SDK_EXPORT genericPySysdriver : public QObject
39 {
40 {
40 Q_OBJECT
41 Q_OBJECT
41
42
42 public:
43 public:
43
44
44 explicit genericPySysdriver(socexplorerplugin* plugin,QObject* parent=0);
45 explicit genericPySysdriver(socexplorerplugin* plugin,QObject* parent=0);
45 signals:
46 signals:
46 public slots:
47 public slots:
47 QVariantList Read(unsigned int address,unsigned int count);
48 QVariantList Read(unsigned int address,unsigned int count);
48 void Write(unsigned int address,QList<QVariant> dataList);
49 void Write(unsigned int address,QList<QVariant> dataList);
49 bool dumpMemory(unsigned int address,unsigned int count,QString file);
50 bool dumpMemory(unsigned int address,unsigned int count,QString file);
50 bool memSet(unsigned int address,int value, unsigned int count);
51 bool memSet(unsigned int address,int value, unsigned int count);
51 bool loadbin(unsigned int address,QString file);
52 bool loadbin(unsigned int address,QString file);
53 bool loadfile(abstractBinFile* file);
54 bool dumpMemory(unsigned int address, unsigned int count, QString file, const QString &format);
52 QString instance();
55 QString instance();
53 private:
56 private:
54 socexplorerplugin* plugin;
57 socexplorerplugin* plugin;
55
58
56 };
59 };
57
60
58 #endif // GENERICPYSYSDRIVER_H
61 #endif // GENERICPYSYSDRIVER_H
Show file before | Show file after | Hide comments
@@ -1,91 +1,244
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@lpp.polytechnique.fr
20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
21 ----------------------------------------------------------------------------*/
21 ----------------------------------------------------------------------------*/
22
22
23 #include <socexplorerplugin.h>
23 #include <socexplorerplugin.h>
24
24 #include <abstractbinfile.h>
25 #include <srec/srecfile.h>
26 #include <BinFile/binaryfile.h>
25
27
26 int socexplorerplugin::isConnected(){return this->Connected;}
28 int socexplorerplugin::isConnected(){return this->Connected;}
27
29
28 QString socexplorerplugin::baseName(){return *_Name;}
30 QString socexplorerplugin::baseName(){return *_Name;}
29
31
30 int socexplorerplugin::baseAddress(){return this->BaseAddress;}
32 int socexplorerplugin::baseAddress(){return this->BaseAddress;}
31
33
32 void socexplorerplugin::setBaseAddress(unsigned int baseAddress){this->BaseAddress = baseAddress;}
34 void socexplorerplugin::setBaseAddress(unsigned int baseAddress){this->BaseAddress = baseAddress;}
33
35
34 QString socexplorerplugin::instanceName()
36 QString socexplorerplugin::instanceName()
35 {
37 {
36 return this->_instanceName;
38 return this->_instanceName;
37 }
39 }
38
40
39 int socexplorerplugin::registermenu(QMenu *menu)
41 int socexplorerplugin::registermenu(QMenu *menu)
40 {
42 {
41 this->menu = menu->addMenu(this->_instanceName);
43 this->menu = menu->addMenu(this->_instanceName);
42 this->closeAction = this->menu->addAction(tr("Close plugin"));
44 this->closeAction = this->menu->addAction(tr("Close plugin"));
43 QObject::connect(this->closeAction,SIGNAL(triggered()),this,SLOT(closeMe()));
45 QObject::connect(this->closeAction,SIGNAL(triggered()),this,SLOT(closeMe()));
44 this->ChildsMenu = this->menu->addMenu(QString("Childs"));
46 this->ChildsMenu = this->menu->addMenu(QString("Childs"));
45 for(int i=0;i<this->childs.count();i++)
47 for(int i=0;i<this->childs.count();i++)
46 {
48 {
47 this->childs.at(i)->registermenu(this->ChildsMenu);
49 this->childs.at(i)->registermenu(this->ChildsMenu);
48 }
50 }
49 if(this->pyObject!=NULL)emit this->registerObject((QObject*)this->pyObject,this->instanceName());
51 if(this->pyObject!=NULL)emit this->registerObject((QObject*)this->pyObject,this->instanceName());
50 return 0;
52 return 0;
51 }
53 }
52
54
53 void socexplorerplugin::postInstantiationTrigger()
55 void socexplorerplugin::postInstantiationTrigger()
54 {
56 {
55 return;
57 return;
56 }
58 }
57
59
58 unsigned int socexplorerplugin::Write(unsigned int *Value, unsigned int count, unsigned int address)
60 unsigned int socexplorerplugin::Write(unsigned int *Value, unsigned int count, unsigned int address)
59 {
61 {
60 if(parent!=NULL)
62 if(parent!=NULL)
61 {
63 {
62 return parent->Write(Value,count,address);
64 return parent->Write(Value,count,address);
63 }
65 }
64 return 0;
66 return 0;
65 }
67 }
66
68
67 unsigned int socexplorerplugin::Read(unsigned int *Value, unsigned int count, unsigned int address)
69 unsigned int socexplorerplugin::Read(unsigned int *Value, unsigned int count, unsigned int address)
68 {
70 {
69 if(parent!=NULL)
71 if(parent!=NULL)
70 {
72 {
71 return parent->Read(Value,count,address);
73 return parent->Read(Value,count,address);
72 }
74 }
73 return 0;
75 return 0;
74 }
76 }
75
77
76 void socexplorerplugin::closeMe(){emit this->closePlugin(this);}
78 void socexplorerplugin::closeMe(){emit this->closePlugin(this);}
77
79
78 void socexplorerplugin::activate(bool flag){this->setEnabled(flag);emit this->activateSig(flag);}
80 void socexplorerplugin::activate(bool flag){this->setEnabled(flag);emit this->activateSig(flag);}
79
81
80 void socexplorerplugin::setInstanceName(const QString &newName)
82 void socexplorerplugin::setInstanceName(const QString &newName)
81 {
83 {
82 this->_instanceName = newName;
84 this->_instanceName = newName;
83 if(this->menu)
85 if(this->menu)
84 this->menu->setTitle(this->_instanceName);
86 this->menu->setTitle(this->_instanceName);
85 this->setWindowTitle(newName);
87 this->setWindowTitle(newName);
88 }
89
90 bool socexplorerplugin::dumpMemory(unsigned int address, unsigned int count, QString file)
91 {
92 unsigned int* buffer = (unsigned int*)malloc(count*sizeof(unsigned int));
93 if(buffer!=NULL)
94 {
95 this->Read(buffer,count,address);
96 QFile outfile(file);
97 if (!outfile.open(QIODevice::ReadWrite | QIODevice::Text))
98 return false;
99 QTextStream out(&outfile);
100 for(int i=0;(unsigned int)i<count;i++)
101 out << "0x"+QString::number(address+(i*4),16) + ": 0x" + QString::number(buffer[i],16) + "\n";
102 free(buffer);
103 out.flush();
104 outfile.close();
105 return true;
106 }
107 return false;
108 }
109
110 bool socexplorerplugin::memSet(unsigned int address, int value, unsigned int count)
111 {
112 unsigned int* buffer = (unsigned int*)malloc(count*sizeof(unsigned int));
113 if(buffer!=NULL)
114 {
115 memset((void*)buffer,value,count*sizeof(unsigned int));
116 this->Write(buffer,count,address);
117 free(buffer );
118 return true;
119 }
120 return false;
121 }
122
123 bool socexplorerplugin::loadbin(unsigned int address, QString file)
124 {
125 QFile infile(file);
126 if (!infile.open(QIODevice::ReadOnly))
127 return false;
128 uint32_t* buffer = (uint32_t*)malloc(infile.size());
129 if(buffer!=NULL)
130 {
131 infile.read((char*)buffer,infile.size());
132 for(int i=0;i<(infile.size()/4);i++)
133 {
134 buffer[i] = socexplorerBswap32(buffer[i]);
135 }
136 this->Write(buffer,infile.size()/4,address);
137 free(buffer);
138 return true;
139 }
140 return false;
141
142 }
143
144 bool socexplorerplugin::loadfile(abstractBinFile *file)
145 {
146 if(file->isopened())
147 {
148 QList<codeFragment*> fragments= file->getFragments();
149 for(int i=0;i<fragments.count();i++)
150 {
151 int size = fragments.at(i)->size/4;
152 // TODO fixme, should be the oposite
153 #if __BYTE_ORDER == __LITTLE_ENDIAN
154 if(!file->litleendian)
155 {
156 uint32_t* buffer = (uint32_t*)malloc(fragments.at(i)->size);
157 memcpy(buffer,fragments.at(i)->data,fragments.at(i)->size);
158 if(buffer!=NULL)
159 {
160 for(int l=0;l<(size);l++)
161 {
162 buffer[l] = socexplorerBswap32(buffer[l]);
163 }
164 this->Write(buffer,size,fragments.at(i)->address);
165 free(buffer);
166 }
167 }
168 else
169 {
170 this->Write((uint32_t*) fragments.at(i)->data,size,fragments.at(i)->address);
171 }
172 #elif __BYTE_ORDER == __BIG_ENDIAN
173 if(file->litleendian)
174 {
175 uint32_t* buffer = (uint32_t*)malloc(fragments.at(i)->size);
176 memcpy(buffer,fragments.at(i)->data,fragments.at(i)->size);
177 if(buffer!=NULL)
178 {
179 for(int l=0;l<(size);l++)
180 {
181 buffer[l] = socexplorerBswap32(buffer[l]);
182 }
183 this->Write(buffer,size,fragments.at(i)->address);
184 free(buffer);
185 }
186 }
187 else
188 {
189 this->Write((uint32_t*) fragments.at(i)->data,size,fragments.at(i)->address);
190 }
191 #endif
192 }
193 }
194 return true;
195 }
196
197 bool socexplorerplugin::dumpMemory(unsigned int address, unsigned int count, QString file, const QString &format)
198 {
199 unsigned int* buffer = (unsigned int*)malloc(count*sizeof(unsigned int));
200 if(buffer!=NULL)
201 {
202 this->Read(buffer,count,address);
203 if(!format.compare("srec",Qt::CaseInsensitive))
204 {
205 //need to convert from in memory endianness to file endianness
206 //SREC is always big endian
207 #if __BYTE_ORDER == __LITTLE_ENDIAN
208 for(int l=0;l<(count);l++)
209 {
210 buffer[l] = socexplorerBswap32(buffer[l]);
211 }
212 #elif __BYTE_ORDER == __BIG_ENDIAN
213
214 #endif
215 codeFragment fragment((char*)buffer,count*4,address);
216 srecFile::toSrec(QList<codeFragment*>()<<&fragment,file);
217 }
218 if(!format.compare("bin",Qt::CaseInsensitive))
219 {
220 //beware this format is not portable from a big endian host to a litle endian one
221 codeFragment fragment((char*)buffer,count*4,address);
222 binaryFile::toBinary(QList<codeFragment*>()<<&fragment,file);
223 }
224 if(!format.compare("hexa",Qt::CaseInsensitive))
225 {
226 QFile outfile(file);
227 if (!outfile.open(QIODevice::ReadWrite | QIODevice::Text))
228 return false;
229 QTextStream out(&outfile);
230 for(int i=0;(unsigned int)i<count;i++)
231 out << "0x"+QString::number(address+(i*4),16) + ": 0x" + QString::number(buffer[i],16) + "\n";
232 free(buffer);
233 out.flush();
234 outfile.close();
235 }
236 return true;
237 }
238 return false;
86 }
239 }
87
240
88 void socexplorerplugin::makeGenericPyWrapper()
241 void socexplorerplugin::makeGenericPyWrapper()
89 {
242 {
90 this->pyObject = new genericPySysdriver(this);
243 this->pyObject = new genericPySysdriver(this);
91 }
244 }
Show file before | Show file after | Hide comments
@@ -1,180 +1,187
1 /*------------------------------------------------------------------------------
1 /*------------------------------------------------------------------------------
2 β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•— β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•— β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•— β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•—β–ˆβ–ˆβ•— β–ˆβ–ˆβ•—β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•— β–ˆβ–ˆβ•— β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•— β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•— β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•—β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•—
2 β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•— β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•— β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•— β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•—β–ˆβ–ˆβ•— β–ˆβ–ˆβ•—β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•— β–ˆβ–ˆβ•— β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•— β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•— β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•—β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•—
3 β–ˆβ–ˆβ•”β•β•β•β•β•β–ˆβ–ˆβ•”β•β•β•β–ˆβ–ˆβ•—β–ˆβ–ˆβ•”β•β•β•β•β• β–ˆβ–ˆβ•”β•β•β•β•β•β•šβ–ˆβ–ˆβ•—β–ˆβ–ˆβ•”β•β–ˆβ–ˆβ•”β•β•β–ˆβ–ˆβ•—β–ˆβ–ˆβ•‘ β–ˆβ–ˆβ•”β•β•β•β–ˆβ–ˆβ•—β–ˆβ–ˆβ•”β•β•β–ˆβ–ˆβ•—β–ˆβ–ˆβ•”β•β•β•β•β•β–ˆβ–ˆβ•”β•β•β–ˆβ–ˆβ•—
3 β–ˆβ–ˆβ•”β•β•β•β•β•β–ˆβ–ˆβ•”β•β•β•β–ˆβ–ˆβ•—β–ˆβ–ˆβ•”β•β•β•β•β• β–ˆβ–ˆβ•”β•β•β•β•β•β•šβ–ˆβ–ˆβ•—β–ˆβ–ˆβ•”β•β–ˆβ–ˆβ•”β•β•β–ˆβ–ˆβ•—β–ˆβ–ˆβ•‘ β–ˆβ–ˆβ•”β•β•β•β–ˆβ–ˆβ•—β–ˆβ–ˆβ•”β•β•β–ˆβ–ˆβ•—β–ˆβ–ˆβ•”β•β•β•β•β•β–ˆβ–ˆβ•”β•β•β–ˆβ–ˆβ•—
4 β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•—β–ˆβ–ˆβ•‘ β–ˆβ–ˆβ•‘β–ˆβ–ˆβ•‘ β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•— β•šβ–ˆβ–ˆβ–ˆβ•”β• β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•”β•β–ˆβ–ˆβ•‘ β–ˆβ–ˆβ•‘ β–ˆβ–ˆβ•‘β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•”β•β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•— β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•”β•
4 β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•—β–ˆβ–ˆβ•‘ β–ˆβ–ˆβ•‘β–ˆβ–ˆβ•‘ β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•— β•šβ–ˆβ–ˆβ–ˆβ•”β• β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•”β•β–ˆβ–ˆβ•‘ β–ˆβ–ˆβ•‘ β–ˆβ–ˆβ•‘β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•”β•β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•— β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•”β•
5 β•šβ•β•β•β•β–ˆβ–ˆβ•‘β–ˆβ–ˆβ•‘ β–ˆβ–ˆβ•‘β–ˆβ–ˆβ•‘ β–ˆβ–ˆβ•”β•β•β• β–ˆβ–ˆβ•”β–ˆβ–ˆβ•— β–ˆβ–ˆβ•”β•β•β•β• β–ˆβ–ˆβ•‘ β–ˆβ–ˆβ•‘ β–ˆβ–ˆβ•‘β–ˆβ–ˆβ•”β•β•β–ˆβ–ˆβ•—β–ˆβ–ˆβ•”β•β•β• β–ˆβ–ˆβ•”β•β•β–ˆβ–ˆβ•—
5 β•šβ•β•β•β•β–ˆβ–ˆβ•‘β–ˆβ–ˆβ•‘ β–ˆβ–ˆβ•‘β–ˆβ–ˆβ•‘ β–ˆβ–ˆβ•”β•β•β• β–ˆβ–ˆβ•”β–ˆβ–ˆβ•— β–ˆβ–ˆβ•”β•β•β•β• β–ˆβ–ˆβ•‘ β–ˆβ–ˆβ•‘ β–ˆβ–ˆβ•‘β–ˆβ–ˆβ•”β•β•β–ˆβ–ˆβ•—β–ˆβ–ˆβ•”β•β•β• β–ˆβ–ˆβ•”β•β•β–ˆβ–ˆβ•—
6 β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•‘β•šβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•”β•β•šβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•— β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•—β–ˆβ–ˆβ•”β• β–ˆβ–ˆβ•—β–ˆβ–ˆβ•‘ β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•—β•šβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•”β•β–ˆβ–ˆβ•‘ β–ˆβ–ˆβ•‘β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•—β–ˆβ–ˆβ•‘ β–ˆβ–ˆβ•‘
6 β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•‘β•šβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•”β•β•šβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•— β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•—β–ˆβ–ˆβ•”β• β–ˆβ–ˆβ•—β–ˆβ–ˆβ•‘ β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•—β•šβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•”β•β–ˆβ–ˆβ•‘ β–ˆβ–ˆβ•‘β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ•—β–ˆβ–ˆβ•‘ β–ˆβ–ˆβ•‘
7 β•šβ•β•β•β•β•β•β• β•šβ•β•β•β•β•β• β•šβ•β•β•β•β•β• β•šβ•β•β•β•β•β•β•β•šβ•β• β•šβ•β•β•šβ•β• β•šβ•β•β•β•β•β•β• β•šβ•β•β•β•β•β• β•šβ•β• β•šβ•β•β•šβ•β•β•β•β•β•β•β•šβ•β• β•šβ•β•
7 β•šβ•β•β•β•β•β•β• β•šβ•β•β•β•β•β• β•šβ•β•β•β•β•β• β•šβ•β•β•β•β•β•β•β•šβ•β• β•šβ•β•β•šβ•β• β•šβ•β•β•β•β•β•β• β•šβ•β•β•β•β•β• β•šβ•β• β•šβ•β•β•šβ•β•β•β•β•β•β•β•šβ•β• β•šβ•β•
8
8
9 -- This file is a part of the SOC Explorer Software
9 -- This file is a part of the SOC Explorer Software
10 -- Copyright (C) 2011, Plasma Physics Laboratory - CNRS
10 -- Copyright (C) 2011, Plasma Physics Laboratory - CNRS
11 --
11 --
12 -- This program is free software; you can redistribute it and/or modify
12 -- This program is free software; you can redistribute it and/or modify
13 -- it under the terms of the GNU General Public License as published by
13 -- it under the terms of the GNU General Public License as published by
14 -- the Free Software Foundation; either version 2 of the License, or
14 -- the Free Software Foundation; either version 2 of the License, or
15 -- (at your option) any later version.
15 -- (at your option) any later version.
16 --
16 --
17 -- This program is distributed in the hope that it will be useful,
17 -- This program is distributed in the hope that it will be useful,
18 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
18 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
19 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 -- GNU General Public License for more details.
20 -- GNU General Public License for more details.
21 --
21 --
22 -- You should have received a copy of the GNU General Public License
22 -- You should have received a copy of the GNU General Public License
23 -- along with this program; if not, write to the Free Software
23 -- along with this program; if not, write to the Free Software
24 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 -------------------------------------------------------------------------------*/
25 -------------------------------------------------------------------------------*/
26 /*-- Author : Alexis Jeandet
26 /*-- Author : Alexis Jeandet
27 -- Mail : alexis.jeandet@lpp.polytechnique.fr
27 -- Mail : alexis.jeandet@lpp.polytechnique.fr
28 ----------------------------------------------------------------------------*/
28 ----------------------------------------------------------------------------*/
29 #ifndef SOCEXPLORERPLUGIN_H
29 #ifndef SOCEXPLORERPLUGIN_H
30 #define SOCEXPLORERPLUGIN_H
30 #define SOCEXPLORERPLUGIN_H
31 #include <QWidget>
31 #include <QWidget>
32 #include <QAction>
32 #include <QAction>
33 #include <QDockWidget>
33 #include <QDockWidget>
34 #include <QMainWindow>
34 #include <QMainWindow>
35 #include <QList>
35 #include <QList>
36 #include <QMenu>
36 #include <QMenu>
37 #include <socexplorer.h>
37 #include <socexplorer.h>
38 #include <QObject>
38 #include <QObject>
39 #include <QVariant>
39 #include <QVariant>
40 #include <QVariantList>
40 #include <QVariantList>
41 #include <malloc.h>
41 #include <malloc.h>
42 #include <QFile>
42 #include <QFile>
43 #include <stdint.h>
43 #include <stdint.h>
44 #include <QTextStream>
44 #include <QTextStream>
45 #include <genericPySysdriver.h>
45 #include <genericPySysdriver.h>
46 #include <abstractbinfile.h>
46 #ifndef driver_Name
47 #ifndef driver_Name
47 #define driver_Name "Plugin"
48 #define driver_Name "Plugin"
48 #endif
49 #endif
49 #ifndef driver_Author
50 #ifndef driver_Author
50 #define driver_Author "No Author"
51 #define driver_Author "No Author"
51 #endif
52 #endif
52 #ifndef driver_Version
53 #ifndef driver_Version
53 #define driver_Version "0.0.0"
54 #define driver_Version "0.0.0"
54 #endif
55 #endif
55 #ifndef driver_Description
56 #ifndef driver_Description
56 #define driver_Description "No description."
57 #define driver_Description "No description."
57 #endif
58 #endif
58 #ifndef driver_can_be_root
59 #ifndef driver_can_be_root
59 #define driver_can_be_root 0
60 #define driver_can_be_root 0
60 #endif
61 #endif
61 #ifndef driver_can_be_child
62 #ifndef driver_can_be_child
62 #define driver_can_be_child 0
63 #define driver_can_be_child 0
63 #endif
64 #endif
64 #ifndef driver_VID
65 #ifndef driver_VID
65 #define driver_VID 0
66 #define driver_VID 0
66 #endif
67 #endif
67 #ifndef driver_PID
68 #ifndef driver_PID
68 #define driver_PID 0
69 #define driver_PID 0
69 #endif
70 #endif
70
71
71 #if defined(SOCEXPLORER_SDK_BUILD)
72 #if defined(SOCEXPLORER_SDK_BUILD)
72 # define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
73 # define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
73 #else
74 #else
74 # define SOCEXPLORER_SDK_EXPORT Q_DECL_IMPORT
75 # define SOCEXPLORER_SDK_EXPORT Q_DECL_IMPORT
75 #endif
76 #endif
76
77
77 class genericPySysdriver;
78 class genericPySysdriver;
78
79
79 //! socexplorerplugin is the base class for any SocExplorer plugin, it gives a standard interface to communicate
80 //! socexplorerplugin is the base class for any SocExplorer plugin, it gives a standard interface to communicate
80 //! between each plugins and to interact with SocExplorer software.
81 //! between each plugins and to interact with SocExplorer software.
81
82
82 class SOCEXPLORER_SDK_EXPORT socexplorerplugin : public QDockWidget
83 class SOCEXPLORER_SDK_EXPORT socexplorerplugin : public QDockWidget
83 {
84 {
84 Q_OBJECT
85 Q_OBJECT
85 public:
86 public:
86 //! Default plugin constructor, any plugin should call this constructor. This constructor creates a
87 //! Default plugin constructor, any plugin should call this constructor. This constructor creates a
87 //! default python wrapper instance. If you want to connect your own python wrapper, you have to clear
88 //! default python wrapper instance. If you want to connect your own python wrapper, you have to clear
88 //! createPyObject option and instanciate your own genericPySysdriver derivated object.
89 //! createPyObject option and instanciate your own genericPySysdriver derivated object.
89 socexplorerplugin(QWidget *parent = 0,bool createPyObject=true):QDockWidget(parent)
90 socexplorerplugin(QWidget *parent = 0,bool createPyObject=true):QDockWidget(parent)
90 {
91 {
91 closeAction=NULL;
92 closeAction=NULL;
92 menu=NULL;
93 menu=NULL;
93 ChildsMenu=NULL;
94 ChildsMenu=NULL;
94 this->Connected = false;
95 this->Connected = false;
95 this->setFeatures(QDockWidget::DockWidgetMovable|QDockWidget::DockWidgetFloatable|QDockWidget::DockWidgetVerticalTitleBar);
96 this->setFeatures(QDockWidget::DockWidgetMovable|QDockWidget::DockWidgetFloatable|QDockWidget::DockWidgetVerticalTitleBar);
96 _Name = new QString(driver_Name);
97 _Name = new QString(driver_Name);
97 _Author = new QString(driver_Author);
98 _Author = new QString(driver_Author);
98 _Version = new QString(driver_Version);
99 _Version = new QString(driver_Version);
99 _Description = new QString(driver_Description);
100 _Description = new QString(driver_Description);
100 _canBeChild = driver_can_be_child;
101 _canBeChild = driver_can_be_child;
101 _canBeRoot = driver_can_be_root;
102 _canBeRoot = driver_can_be_root;
102 _VID = driver_VID;
103 _VID = driver_VID;
103 _PID = driver_PID;
104 _PID = driver_PID;
104 if(createPyObject)
105 if(createPyObject)
105 {
106 {
106 this->makeGenericPyWrapper();
107 this->makeGenericPyWrapper();
107 }
108 }
108 }
109 }
109 //! Tells if the plugin is connected, it is used to enable or disable all childrens interfaces.
110 //! Tells if the plugin is connected, it is used to enable or disable all childrens interfaces.
110 virtual int isConnected();
111 virtual int isConnected();
111 //! Gives the associated Vendor IDentifier, usefull to automatically associate plugins with found
112 //! Gives the associated Vendor IDentifier, usefull to automatically associate plugins with found
112 //! hardware while board enumeration.
113 //! hardware while board enumeration.
113 virtual int VID(){return _PID;}
114 virtual int VID(){return _PID;}
114 //! Gives the associated Product IDentifier, usefull to automatically associate plugins with found
115 //! Gives the associated Product IDentifier, usefull to automatically associate plugins with found
115 //! hardware while board enumeration.
116 //! hardware while board enumeration.
116 virtual int PID(){return _VID;}
117 virtual int PID(){return _VID;}
117 //! Gives the plugin's base name, usefull to automatically generate instance name.
118 //! Gives the plugin's base name, usefull to automatically generate instance name.
118 virtual QString baseName();
119 virtual QString baseName();
119 //! Gives the base address of the current instance, for example if your plugin is supposed to drive
120 //! Gives the base address of the current instance, for example if your plugin is supposed to drive
120 //! an UART it will correspond to the address of it's first register. This address have at least to
121 //! an UART it will correspond to the address of it's first register. This address have at least to
121 //! be set by SocExplorer and it can be user accessible if you want.
122 //! be set by SocExplorer and it can be user accessible if you want.
122 virtual int baseAddress();
123 virtual int baseAddress();
123 //! Sets the base address of the current instance, for example if your plugin is supposed to drive
124 //! Sets the base address of the current instance, for example if your plugin is supposed to drive
124 //! an UART it will correspond to the address of it's first register. This address have at least to
125 //! an UART it will correspond to the address of it's first register. This address have at least to
125 //! be set by SocExplorer and it can be user accessible if you want.
126 //! be set by SocExplorer and it can be user accessible if you want.
126 virtual void setBaseAddress(unsigned int baseAddress);
127 virtual void setBaseAddress(unsigned int baseAddress);
127
128
128 genericPySysdriver* getPyObjectWrapper(){return this->pyObject;}
129 genericPySysdriver* getPyObjectWrapper(){return this->pyObject;}
129 QList<socexplorerplugin*> childs;
130 QList<socexplorerplugin*> childs;
130 socexplorerplugin* parent;
131 socexplorerplugin* parent;
131 QAction* closeAction;
132 QAction* closeAction;
132 QString instanceName();
133 QString instanceName();
133 QMenu* menu;
134 QMenu* menu;
134 QMenu* ChildsMenu;
135 QMenu* ChildsMenu;
135
136
136 signals:
137 signals:
137 //! Signal emited each time the plugin is about to be closed.
138 //! Signal emited each time the plugin is about to be closed.
138 void closePlugin(socexplorerplugin* driver);
139 void closePlugin(socexplorerplugin* driver);
139 void activateSig(bool flag);
140 void activateSig(bool flag);
140 void registerObject(QObject* object,const QString& instanceName);
141 void registerObject(QObject* object,const QString& instanceName);
141
142
142 public slots:
143 public slots:
143 virtual int registermenu(QMenu* menu);
144 virtual int registermenu(QMenu* menu);
144 virtual void postInstantiationTrigger();
145 virtual void postInstantiationTrigger();
145 //! Write slot this is the way your children plugins ask you for writing data.
146 //! Write slot this is the way your children plugins ask you for writing data.
146 //! If your plugin is supposed to have childern drivers you should implement this methode.
147 //! If your plugin is supposed to have childern drivers you should implement this methode.
147 //! By default this methode forward the write request to the parent plugin.
148 //! By default this methode forward the write request to the parent plugin.
148 //! \param Value Pointer the data buffer.
149 //! \param Value Pointer the data buffer.
149 //! \param count Number of 32 bits words you should to write.
150 //! \param count Number of 32 bits words you should to write.
150 //! \param address Address from where you should to start to write.
151 //! \param address Address from where you should to start to write.
151 //! \return Quantity of 32 bits words writtens.
152 //! \return Quantity of 32 bits words writtens.
152 virtual unsigned int Write(unsigned int* Value, unsigned int count,unsigned int address);
153 virtual unsigned int Write(unsigned int* Value, unsigned int count,unsigned int address);
153 //! Read slot this is the way your children plugins ask you for reading data.
154 //! Read slot this is the way your children plugins ask you for reading data.
154 //! If your plugin is supposed to have childern drivers you should implement this methode.
155 //! If your plugin is supposed to have childern drivers you should implement this methode.
155 //! By default this methode forward the write request to the parent plugin.
156 //! By default this methode forward the write request to the parent plugin.
156 //! \param Value Pointer the data buffer.
157 //! \param Value Pointer the data buffer.
157 //! \param count Number of 32 bits words you should to read.
158 //! \param count Number of 32 bits words you should to read.
158 //! \param address Address from where you should to start to read.
159 //! \param address Address from where you should to start to read.
159 //! \return Quantity of 32 bits words read.
160 //! \return Quantity of 32 bits words read.
160 virtual unsigned int Read(unsigned int* Value, unsigned int count,unsigned int address);
161 virtual unsigned int Read(unsigned int* Value, unsigned int count,unsigned int address);
161 virtual void closeMe();
162 virtual void closeMe();
162 virtual void activate(bool flag);
163 virtual void activate(bool flag);
163 virtual void setInstanceName(const QString& newName);
164 virtual void setInstanceName(const QString& newName);
165
166 virtual bool dumpMemory(unsigned int address,unsigned int count,QString file);
167 virtual bool memSet(unsigned int address,int value, unsigned int count);
168 virtual bool loadbin(unsigned int address,QString file);
169 virtual bool loadfile(abstractBinFile* file);
170 virtual bool dumpMemory(unsigned int address,unsigned int count,QString file,const QString& format);
164 protected:
171 protected:
165 void makeGenericPyWrapper();
172 void makeGenericPyWrapper();
166 int BaseAddress;
173 int BaseAddress;
167 bool Connected;
174 bool Connected;
168 genericPySysdriver* pyObject;
175 genericPySysdriver* pyObject;
169 QString* _Name;
176 QString* _Name;
170 QString* _Author;
177 QString* _Author;
171 QString* _Version;
178 QString* _Version;
172 QString* _Description;
179 QString* _Description;
173 QString _instanceName;
180 QString _instanceName;
174 int _canBeChild;
181 int _canBeChild;
175 int _canBeRoot;
182 int _canBeRoot;
176 int _VID;
183 int _VID;
177 int _PID;
184 int _PID;
178 };
185 };
179
186
180 #endif // SOCEXPLORERPLUGIN_H
187 #endif // SOCEXPLORERPLUGIN_H
Show file before | Show file after | Hide comments
This diff has been collapsed as it changes many lines, (4709 lines changed) Show them Hide them
@@ -1,8711 +1,9478
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>
6 #include <QVariant>
5 #include <QVariant>
7 #include <abstractbinfile.h>
6 #include <abstractbinfile.h>
8 #include <elfparser.h>
7 #include <elfparser.h>
9 #include <qaction.h>
8 #include <qaction.h>
9 #include <qbackingstore.h>
10 #include <qbitmap.h>
10 #include <qbitmap.h>
11 #include <qbytearray.h>
11 #include <qbytearray.h>
12 #include <qcolor.h>
12 #include <qcolor.h>
13 #include <qcoreevent.h>
13 #include <qcoreevent.h>
14 #include <qcursor.h>
14 #include <qcursor.h>
15 #include <qevent.h>
15 #include <qevent.h>
16 #include <qfile.h>
16 #include <qfile.h>
17 #include <qfont.h>
17 #include <qfont.h>
18 #include <qgraphicseffect.h>
18 #include <qgraphicseffect.h>
19 #include <qgraphicsproxywidget.h>
19 #include <qgraphicsproxywidget.h>
20 #include <qicon.h>
20 #include <qkeysequence.h>
21 #include <qkeysequence.h>
21 #include <qlayout.h>
22 #include <qlayout.h>
22 #include <qlineedit.h>
23 #include <qlineedit.h>
23 #include <qlist.h>
24 #include <qlist.h>
24 #include <qlocale.h>
25 #include <qlocale.h>
25 #include <qmargins.h>
26 #include <qmargins.h>
27 #include <qmetaobject.h>
26 #include <qobject.h>
28 #include <qobject.h>
27 #include <qpaintdevice.h>
29 #include <qpaintdevice.h>
28 #include <qpaintengine.h>
30 #include <qpaintengine.h>
29 #include <qpainter.h>
31 #include <qpainter.h>
30 #include <qpalette.h>
32 #include <qpalette.h>
31 #include <qpen.h>
33 #include <qpen.h>
32 #include <qpixmap.h>
34 #include <qpixmap.h>
33 #include <qpoint.h>
35 #include <qpoint.h>
34 #include <qrect.h>
36 #include <qrect.h>
35 #include <qregion.h>
37 #include <qregion.h>
36 #include <qscrollarea.h>
38 #include <qscrollarea.h>
37 #include <qscrollbar.h>
39 #include <qscrollbar.h>
38 #include <qsize.h>
40 #include <qsize.h>
39 #include <qsizepolicy.h>
41 #include <qsizepolicy.h>
40 #include <qspinbox.h>
42 #include <qspinbox.h>
41 #include <qstringlist.h>
43 #include <qstringlist.h>
42 #include <qstyle.h>
44 #include <qstyle.h>
43 #include <qstyleoption.h>
45 #include <qstyleoption.h>
44 #include <qwidget.h>
46 #include <qwidget.h>
47 #include <qwindow.h>
45
48
46 PythonQtShell_ElfFile::~PythonQtShell_ElfFile() {
49 PythonQtShell_ElfFile::~PythonQtShell_ElfFile() {
47 PythonQtPrivate* priv = PythonQt::priv();
50 PythonQtPrivate* priv = PythonQt::priv();
48 if (priv) { priv->shellClassDeleted(this); }
51 if (priv) { priv->shellClassDeleted(this); }
49 }
52 }
50 int PythonQtShell_ElfFile::closeFile()
53 int PythonQtShell_ElfFile::closeFile()
51 {
54 {
52 if (_wrapper) {
55 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
53 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
56 static PyObject* name = PyString_FromString("closeFile");
54 PyErr_Clear();
57 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
55 if (obj && !PythonQtSlotFunction_Check(obj)) {
58 if (obj) {
56 static const char* argumentList[] ={"int"};
59 static const char* argumentList[] ={"int"};
57 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
60 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
58 int returnValue;
61 int returnValue;
59 void* args[1] = {NULL};
62 void* args[1] = {NULL};
60 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
63 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
61 if (result) {
64 if (result) {
62 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
65 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
63 if (args[0]!=&returnValue) {
66 if (args[0]!=&returnValue) {
64 if (args[0]==NULL) {
67 if (args[0]==NULL) {
65 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
68 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
66 } else {
69 } else {
67 returnValue = *((int*)args[0]);
70 returnValue = *((int*)args[0]);
68 }
71 }
69 }
72 }
70 }
73 }
71 if (result) { Py_DECREF(result); }
74 if (result) { Py_DECREF(result); }
72 Py_DECREF(obj);
75 Py_DECREF(obj);
73 return returnValue;
76 return returnValue;
77 } else {
78 PyErr_Clear();
74 }
79 }
75 }
80 }
76 return ElfFile::closeFile();
81 return ElfFile::closeFile();
77 }
82 }
78 QList<codeFragment* > PythonQtShell_ElfFile::getFragments()
83 QList<codeFragment* > PythonQtShell_ElfFile::getFragments()
79 {
84 {
80 if (_wrapper) {
85 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
81 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
86 static PyObject* name = PyString_FromString("getFragments");
82 PyErr_Clear();
87 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
83 if (obj && !PythonQtSlotFunction_Check(obj)) {
88 if (obj) {
84 static const char* argumentList[] ={"QList<codeFragment* >"};
89 static const char* argumentList[] ={"QList<codeFragment* >"};
85 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
90 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
86 QList<codeFragment* > returnValue;
91 QList<codeFragment* > returnValue;
87 void* args[1] = {NULL};
92 void* args[1] = {NULL};
88 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
93 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
89 if (result) {
94 if (result) {
90 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);
91 if (args[0]!=&returnValue) {
96 if (args[0]!=&returnValue) {
92 if (args[0]==NULL) {
97 if (args[0]==NULL) {
93 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
98 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
94 } else {
99 } else {
95 returnValue = *((QList<codeFragment* >*)args[0]);
100 returnValue = *((QList<codeFragment* >*)args[0]);
96 }
101 }
97 }
102 }
98 }
103 }
99 if (result) { Py_DECREF(result); }
104 if (result) { Py_DECREF(result); }
100 Py_DECREF(obj);
105 Py_DECREF(obj);
101 return returnValue;
106 return returnValue;
107 } else {
108 PyErr_Clear();
102 }
109 }
103 }
110 }
104 return ElfFile::getFragments();
111 return ElfFile::getFragments();
105 }
112 }
106 bool PythonQtShell_ElfFile::isopened()
113 bool PythonQtShell_ElfFile::isopened()
107 {
114 {
108 if (_wrapper) {
115 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
109 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
116 static PyObject* name = PyString_FromString("isopened");
110 PyErr_Clear();
117 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
111 if (obj && !PythonQtSlotFunction_Check(obj)) {
118 if (obj) {
112 static const char* argumentList[] ={"bool"};
119 static const char* argumentList[] ={"bool"};
113 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
120 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
114 bool returnValue;
121 bool returnValue;
115 void* args[1] = {NULL};
122 void* args[1] = {NULL};
116 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
123 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
117 if (result) {
124 if (result) {
118 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
125 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
119 if (args[0]!=&returnValue) {
126 if (args[0]!=&returnValue) {
120 if (args[0]==NULL) {
127 if (args[0]==NULL) {
121 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
128 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
122 } else {
129 } else {
123 returnValue = *((bool*)args[0]);
130 returnValue = *((bool*)args[0]);
124 }
131 }
125 }
132 }
126 }
133 }
127 if (result) { Py_DECREF(result); }
134 if (result) { Py_DECREF(result); }
128 Py_DECREF(obj);
135 Py_DECREF(obj);
129 return returnValue;
136 return returnValue;
137 } else {
138 PyErr_Clear();
130 }
139 }
131 }
140 }
132 return ElfFile::isopened();
141 return ElfFile::isopened();
133 }
142 }
134 bool PythonQtShell_ElfFile::openFile(const QString& File)
143 bool PythonQtShell_ElfFile::openFile(const QString& File0)
135 {
144 {
136 if (_wrapper) {
145 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
137 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
146 static PyObject* name = PyString_FromString("openFile");
138 PyErr_Clear();
147 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
139 if (obj && !PythonQtSlotFunction_Check(obj)) {
148 if (obj) {
140 static const char* argumentList[] ={"bool" , "const QString&"};
149 static const char* argumentList[] ={"bool" , "const QString&"};
141 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
150 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
142 bool returnValue;
151 bool returnValue;
143 void* args[2] = {NULL, (void*)&File};
152 void* args[2] = {NULL, (void*)&File0};
144 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
153 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
145 if (result) {
154 if (result) {
146 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
155 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
147 if (args[0]!=&returnValue) {
156 if (args[0]!=&returnValue) {
148 if (args[0]==NULL) {
157 if (args[0]==NULL) {
149 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
158 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
150 } else {
159 } else {
151 returnValue = *((bool*)args[0]);
160 returnValue = *((bool*)args[0]);
152 }
161 }
153 }
162 }
154 }
163 }
155 if (result) { Py_DECREF(result); }
164 if (result) { Py_DECREF(result); }
156 Py_DECREF(obj);
165 Py_DECREF(obj);
157 return returnValue;
166 return returnValue;
158 }
167 } else {
159 }
168 PyErr_Clear();
160 return ElfFile::openFile(File);
169 }
161 }
170 }
162 bool PythonQtShell_ElfFile::toBinary(const QString& File)
171 return ElfFile::openFile(File0);
163 {
172 }
164 if (_wrapper) {
173 bool PythonQtShell_ElfFile::toBinary(const QString& File0)
165 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
174 {
166 PyErr_Clear();
175 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
167 if (obj && !PythonQtSlotFunction_Check(obj)) {
176 static PyObject* name = PyString_FromString("toBinary");
177 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
178 if (obj) {
168 static const char* argumentList[] ={"bool" , "const QString&"};
179 static const char* argumentList[] ={"bool" , "const QString&"};
169 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
180 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
170 bool returnValue;
181 bool returnValue;
171 void* args[2] = {NULL, (void*)&File};
182 void* args[2] = {NULL, (void*)&File0};
172 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
183 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
173 if (result) {
184 if (result) {
174 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
185 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
175 if (args[0]!=&returnValue) {
186 if (args[0]!=&returnValue) {
176 if (args[0]==NULL) {
187 if (args[0]==NULL) {
177 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
188 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
178 } else {
189 } else {
179 returnValue = *((bool*)args[0]);
190 returnValue = *((bool*)args[0]);
180 }
191 }
181 }
192 }
182 }
193 }
183 if (result) { Py_DECREF(result); }
194 if (result) { Py_DECREF(result); }
184 Py_DECREF(obj);
195 Py_DECREF(obj);
185 return returnValue;
196 return returnValue;
186 }
197 } else {
187 }
198 PyErr_Clear();
188 return ElfFile::toBinary(File);
199 }
189 }
200 }
190 bool PythonQtShell_ElfFile::toSrec(const QString& File)
201 return ElfFile::toBinary(File0);
191 {
202 }
192 if (_wrapper) {
203 bool PythonQtShell_ElfFile::toSrec(const QString& File0)
193 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
204 {
194 PyErr_Clear();
205 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
195 if (obj && !PythonQtSlotFunction_Check(obj)) {
206 static PyObject* name = PyString_FromString("toSrec");
207 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
208 if (obj) {
196 static const char* argumentList[] ={"bool" , "const QString&"};
209 static const char* argumentList[] ={"bool" , "const QString&"};
197 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
210 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
198 bool returnValue;
211 bool returnValue;
199 void* args[2] = {NULL, (void*)&File};
212 void* args[2] = {NULL, (void*)&File0};
200 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
213 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
201 if (result) {
214 if (result) {
202 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
215 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
203 if (args[0]!=&returnValue) {
216 if (args[0]!=&returnValue) {
204 if (args[0]==NULL) {
217 if (args[0]==NULL) {
205 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
218 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
206 } else {
219 } else {
207 returnValue = *((bool*)args[0]);
220 returnValue = *((bool*)args[0]);
208 }
221 }
209 }
222 }
210 }
223 }
211 if (result) { Py_DECREF(result); }
224 if (result) { Py_DECREF(result); }
212 Py_DECREF(obj);
225 Py_DECREF(obj);
213 return returnValue;
226 return returnValue;
214 }
227 } else {
215 }
228 PyErr_Clear();
216 return ElfFile::toSrec(File);
229 }
230 }
231 return ElfFile::toSrec(File0);
217 }
232 }
218 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile()
233 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile()
219 {
234 {
220 return new PythonQtShell_ElfFile(); }
235 return new PythonQtShell_ElfFile(); }
221
236
222 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile(const QString& File)
237 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile(const QString& File)
223 {
238 {
224 return new PythonQtShell_ElfFile(File); }
239 return new PythonQtShell_ElfFile(File); }
225
240
226 int PythonQtWrapper_ElfFile::closeFile(ElfFile* theWrappedObject)
241 int PythonQtWrapper_ElfFile::closeFile(ElfFile* theWrappedObject)
227 {
242 {
228 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_closeFile());
243 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_closeFile());
229 }
244 }
230
245
231 QString PythonQtWrapper_ElfFile::getABI(ElfFile* theWrappedObject)
246 QString PythonQtWrapper_ElfFile::getABI(ElfFile* theWrappedObject)
232 {
247 {
233 return ( theWrappedObject->getABI());
248 return ( theWrappedObject->getABI());
234 }
249 }
235
250
236 QString PythonQtWrapper_ElfFile::getArchitecture(ElfFile* theWrappedObject)
251 QString PythonQtWrapper_ElfFile::getArchitecture(ElfFile* theWrappedObject)
237 {
252 {
238 return ( theWrappedObject->getArchitecture());
253 return ( theWrappedObject->getArchitecture());
239 }
254 }
240
255
241 QString PythonQtWrapper_ElfFile::getClass(ElfFile* theWrappedObject)
256 QString PythonQtWrapper_ElfFile::getClass(ElfFile* theWrappedObject)
242 {
257 {
243 return ( theWrappedObject->getClass());
258 return ( theWrappedObject->getClass());
244 }
259 }
245
260
246 QString PythonQtWrapper_ElfFile::getEndianness(ElfFile* theWrappedObject)
261 QString PythonQtWrapper_ElfFile::getEndianness(ElfFile* theWrappedObject)
247 {
262 {
248 return ( theWrappedObject->getEndianness());
263 return ( theWrappedObject->getEndianness());
249 }
264 }
250
265
251 qint64 PythonQtWrapper_ElfFile::getEntryPointAddress(ElfFile* theWrappedObject)
266 qint64 PythonQtWrapper_ElfFile::getEntryPointAddress(ElfFile* theWrappedObject)
252 {
267 {
253 return ( theWrappedObject->getEntryPointAddress());
268 return ( theWrappedObject->getEntryPointAddress());
254 }
269 }
255
270
256 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject)
271 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject)
257 {
272 {
258 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_getFragments());
273 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_getFragments());
259 }
274 }
260
275
261 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject, QStringList fragmentList)
276 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject, QStringList fragmentList)
262 {
277 {
263 return ( theWrappedObject->getFragments(fragmentList));
278 return ( theWrappedObject->getFragments(fragmentList));
264 }
279 }
265
280
266 int PythonQtWrapper_ElfFile::getSectionCount(ElfFile* theWrappedObject)
281 int PythonQtWrapper_ElfFile::getSectionCount(ElfFile* theWrappedObject)
267 {
282 {
268 return ( theWrappedObject->getSectionCount());
283 return ( theWrappedObject->getSectionCount());
269 }
284 }
270
285
271 bool PythonQtWrapper_ElfFile::getSectionData(ElfFile* theWrappedObject, int index, char** buffer)
286 bool PythonQtWrapper_ElfFile::getSectionData(ElfFile* theWrappedObject, int index, char** buffer)
272 {
287 {
273 return ( theWrappedObject->getSectionData(index, buffer));
288 return ( theWrappedObject->getSectionData(index, buffer));
274 }
289 }
275
290
276 qint64 PythonQtWrapper_ElfFile::getSectionDatasz(ElfFile* theWrappedObject, int index)
291 qint64 PythonQtWrapper_ElfFile::getSectionDatasz(ElfFile* theWrappedObject, int index)
277 {
292 {
278 return ( theWrappedObject->getSectionDatasz(index));
293 return ( theWrappedObject->getSectionDatasz(index));
279 }
294 }
280
295
281 int PythonQtWrapper_ElfFile::getSectionIndex(ElfFile* theWrappedObject, QString name)
296 int PythonQtWrapper_ElfFile::getSectionIndex(ElfFile* theWrappedObject, QString name)
282 {
297 {
283 return ( theWrappedObject->getSectionIndex(name));
298 return ( theWrappedObject->getSectionIndex(name));
284 }
299 }
285
300
286 qint64 PythonQtWrapper_ElfFile::getSectionMemsz(ElfFile* theWrappedObject, int index)
301 qint64 PythonQtWrapper_ElfFile::getSectionMemsz(ElfFile* theWrappedObject, int index)
287 {
302 {
288 return ( theWrappedObject->getSectionMemsz(index));
303 return ( theWrappedObject->getSectionMemsz(index));
289 }
304 }
290
305
291 QString PythonQtWrapper_ElfFile::getSectionName(ElfFile* theWrappedObject, int index)
306 QString PythonQtWrapper_ElfFile::getSectionName(ElfFile* theWrappedObject, int index)
292 {
307 {
293 return ( theWrappedObject->getSectionName(index));
308 return ( theWrappedObject->getSectionName(index));
294 }
309 }
295
310
296 qint64 PythonQtWrapper_ElfFile::getSectionPaddr(ElfFile* theWrappedObject, int index)
311 qint64 PythonQtWrapper_ElfFile::getSectionPaddr(ElfFile* theWrappedObject, int index)
297 {
312 {
298 return ( theWrappedObject->getSectionPaddr(index));
313 return ( theWrappedObject->getSectionPaddr(index));
299 }
314 }
300
315
301 QString PythonQtWrapper_ElfFile::getSectionType(ElfFile* theWrappedObject, int index)
316 QString PythonQtWrapper_ElfFile::getSectionType(ElfFile* theWrappedObject, int index)
302 {
317 {
303 return ( theWrappedObject->getSectionType(index));
318 return ( theWrappedObject->getSectionType(index));
304 }
319 }
305
320
306 int PythonQtWrapper_ElfFile::getSegmentCount(ElfFile* theWrappedObject)
321 int PythonQtWrapper_ElfFile::getSegmentCount(ElfFile* theWrappedObject)
307 {
322 {
308 return ( theWrappedObject->getSegmentCount());
323 return ( theWrappedObject->getSegmentCount());
309 }
324 }
310
325
311 qint64 PythonQtWrapper_ElfFile::getSegmentFilesz(ElfFile* theWrappedObject, int index)
326 qint64 PythonQtWrapper_ElfFile::getSegmentFilesz(ElfFile* theWrappedObject, int index)
312 {
327 {
313 return ( theWrappedObject->getSegmentFilesz(index));
328 return ( theWrappedObject->getSegmentFilesz(index));
314 }
329 }
315
330
316 QString PythonQtWrapper_ElfFile::getSegmentFlags(ElfFile* theWrappedObject, int index)
331 QString PythonQtWrapper_ElfFile::getSegmentFlags(ElfFile* theWrappedObject, int index)
317 {
332 {
318 return ( theWrappedObject->getSegmentFlags(index));
333 return ( theWrappedObject->getSegmentFlags(index));
319 }
334 }
320
335
321 qint64 PythonQtWrapper_ElfFile::getSegmentMemsz(ElfFile* theWrappedObject, int index)
336 qint64 PythonQtWrapper_ElfFile::getSegmentMemsz(ElfFile* theWrappedObject, int index)
322 {
337 {
323 return ( theWrappedObject->getSegmentMemsz(index));
338 return ( theWrappedObject->getSegmentMemsz(index));
324 }
339 }
325
340
326 qint64 PythonQtWrapper_ElfFile::getSegmentOffset(ElfFile* theWrappedObject, int index)
341 qint64 PythonQtWrapper_ElfFile::getSegmentOffset(ElfFile* theWrappedObject, int index)
327 {
342 {
328 return ( theWrappedObject->getSegmentOffset(index));
343 return ( theWrappedObject->getSegmentOffset(index));
329 }
344 }
330
345
331 qint64 PythonQtWrapper_ElfFile::getSegmentPaddr(ElfFile* theWrappedObject, int index)
346 qint64 PythonQtWrapper_ElfFile::getSegmentPaddr(ElfFile* theWrappedObject, int index)
332 {
347 {
333 return ( theWrappedObject->getSegmentPaddr(index));
348 return ( theWrappedObject->getSegmentPaddr(index));
334 }
349 }
335
350
336 QString PythonQtWrapper_ElfFile::getSegmentType(ElfFile* theWrappedObject, int index)
351 QString PythonQtWrapper_ElfFile::getSegmentType(ElfFile* theWrappedObject, int index)
337 {
352 {
338 return ( theWrappedObject->getSegmentType(index));
353 return ( theWrappedObject->getSegmentType(index));
339 }
354 }
340
355
341 qint64 PythonQtWrapper_ElfFile::getSegmentVaddr(ElfFile* theWrappedObject, int index)
356 qint64 PythonQtWrapper_ElfFile::getSegmentVaddr(ElfFile* theWrappedObject, int index)
342 {
357 {
343 return ( theWrappedObject->getSegmentVaddr(index));
358 return ( theWrappedObject->getSegmentVaddr(index));
344 }
359 }
345
360
346 quint64 PythonQtWrapper_ElfFile::getSymbolAddress(ElfFile* theWrappedObject, int index)
361 quint64 PythonQtWrapper_ElfFile::getSymbolAddress(ElfFile* theWrappedObject, int index)
347 {
362 {
348 return ( theWrappedObject->getSymbolAddress(index));
363 return ( theWrappedObject->getSymbolAddress(index));
349 }
364 }
350
365
351 int PythonQtWrapper_ElfFile::getSymbolCount(ElfFile* theWrappedObject)
366 int PythonQtWrapper_ElfFile::getSymbolCount(ElfFile* theWrappedObject)
352 {
367 {
353 return ( theWrappedObject->getSymbolCount());
368 return ( theWrappedObject->getSymbolCount());
354 }
369 }
355
370
356 QString PythonQtWrapper_ElfFile::getSymbolLinkType(ElfFile* theWrappedObject, int index)
371 QString PythonQtWrapper_ElfFile::getSymbolLinkType(ElfFile* theWrappedObject, int index)
357 {
372 {
358 return ( theWrappedObject->getSymbolLinkType(index));
373 return ( theWrappedObject->getSymbolLinkType(index));
359 }
374 }
360
375
361 QString PythonQtWrapper_ElfFile::getSymbolName(ElfFile* theWrappedObject, int index)
376 QString PythonQtWrapper_ElfFile::getSymbolName(ElfFile* theWrappedObject, int index)
362 {
377 {
363 return ( theWrappedObject->getSymbolName(index));
378 return ( theWrappedObject->getSymbolName(index));
364 }
379 }
365
380
366 int PythonQtWrapper_ElfFile::getSymbolSectionIndex(ElfFile* theWrappedObject, int index)
381 int PythonQtWrapper_ElfFile::getSymbolSectionIndex(ElfFile* theWrappedObject, int index)
367 {
382 {
368 return ( theWrappedObject->getSymbolSectionIndex(index));
383 return ( theWrappedObject->getSymbolSectionIndex(index));
369 }
384 }
370
385
371 QString PythonQtWrapper_ElfFile::getSymbolSectionName(ElfFile* theWrappedObject, int index)
386 QString PythonQtWrapper_ElfFile::getSymbolSectionName(ElfFile* theWrappedObject, int index)
372 {
387 {
373 return ( theWrappedObject->getSymbolSectionName(index));
388 return ( theWrappedObject->getSymbolSectionName(index));
374 }
389 }
375
390
376 quint64 PythonQtWrapper_ElfFile::getSymbolSize(ElfFile* theWrappedObject, int index)
391 quint64 PythonQtWrapper_ElfFile::getSymbolSize(ElfFile* theWrappedObject, int index)
377 {
392 {
378 return ( theWrappedObject->getSymbolSize(index));
393 return ( theWrappedObject->getSymbolSize(index));
379 }
394 }
380
395
381 QString PythonQtWrapper_ElfFile::getSymbolType(ElfFile* theWrappedObject, int index)
396 QString PythonQtWrapper_ElfFile::getSymbolType(ElfFile* theWrappedObject, int index)
382 {
397 {
383 return ( theWrappedObject->getSymbolType(index));
398 return ( theWrappedObject->getSymbolType(index));
384 }
399 }
385
400
386 QString PythonQtWrapper_ElfFile::getType(ElfFile* theWrappedObject)
401 QString PythonQtWrapper_ElfFile::getType(ElfFile* theWrappedObject)
387 {
402 {
388 return ( theWrappedObject->getType());
403 return ( theWrappedObject->getType());
389 }
404 }
390
405
391 qint64 PythonQtWrapper_ElfFile::getVersion(ElfFile* theWrappedObject)
406 qint64 PythonQtWrapper_ElfFile::getVersion(ElfFile* theWrappedObject)
392 {
407 {
393 return ( theWrappedObject->getVersion());
408 return ( theWrappedObject->getVersion());
394 }
409 }
395
410
411 bool PythonQtWrapper_ElfFile::isBigEndian(ElfFile* theWrappedObject)
412 {
413 return ( theWrappedObject->isBigEndian());
414 }
415
396 bool PythonQtWrapper_ElfFile::static_ElfFile_isElf(const QString& File)
416 bool PythonQtWrapper_ElfFile::static_ElfFile_isElf(const QString& File)
397 {
417 {
398 return (ElfFile::isElf(File));
418 return (ElfFile::isElf(File));
399 }
419 }
400
420
421 bool PythonQtWrapper_ElfFile::isLitleEndian(ElfFile* theWrappedObject)
422 {
423 return ( theWrappedObject->isLitleEndian());
424 }
425
401 bool PythonQtWrapper_ElfFile::iself(ElfFile* theWrappedObject)
426 bool PythonQtWrapper_ElfFile::iself(ElfFile* theWrappedObject)
402 {
427 {
403 return ( theWrappedObject->iself());
428 return ( theWrappedObject->iself());
404 }
429 }
405
430
406 bool PythonQtWrapper_ElfFile::isopened(ElfFile* theWrappedObject)
431 bool PythonQtWrapper_ElfFile::isopened(ElfFile* theWrappedObject)
407 {
432 {
408 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_isopened());
433 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_isopened());
409 }
434 }
410
435
411 bool PythonQtWrapper_ElfFile::openFile(ElfFile* theWrappedObject, const QString& File)
436 bool PythonQtWrapper_ElfFile::openFile(ElfFile* theWrappedObject, const QString& File)
412 {
437 {
413 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_openFile(File));
438 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_openFile(File));
414 }
439 }
415
440
416 bool PythonQtWrapper_ElfFile::sectionIsNobits(ElfFile* theWrappedObject, int index)
441 bool PythonQtWrapper_ElfFile::sectionIsNobits(ElfFile* theWrappedObject, int index)
417 {
442 {
418 return ( theWrappedObject->sectionIsNobits(index));
443 return ( theWrappedObject->sectionIsNobits(index));
419 }
444 }
420
445
421 bool PythonQtWrapper_ElfFile::toBinary(ElfFile* theWrappedObject, const QString& File)
446 bool PythonQtWrapper_ElfFile::toBinary(ElfFile* theWrappedObject, const QString& File)
422 {
447 {
423 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_toBinary(File));
448 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_toBinary(File));
424 }
449 }
425
450
426 bool PythonQtWrapper_ElfFile::toSrec(ElfFile* theWrappedObject, const QString& File)
451 bool PythonQtWrapper_ElfFile::toSrec(ElfFile* theWrappedObject, const QString& File)
427 {
452 {
428 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_toSrec(File));
453 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_toSrec(File));
429 }
454 }
430
455
431
456
432
457
433 PythonQtShell_MemSizeWdgt::~PythonQtShell_MemSizeWdgt() {
458 PythonQtShell_MemSizeWdgt::~PythonQtShell_MemSizeWdgt() {
434 PythonQtPrivate* priv = PythonQt::priv();
459 PythonQtPrivate* priv = PythonQt::priv();
435 if (priv) { priv->shellClassDeleted(this); }
460 if (priv) { priv->shellClassDeleted(this); }
436 }
461 }
437 void PythonQtShell_MemSizeWdgt::actionEvent(QActionEvent* arg__1)
462 void PythonQtShell_MemSizeWdgt::actionEvent(QActionEvent* arg__1)
438 {
463 {
439 if (_wrapper) {
464 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
440 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
465 static PyObject* name = PyString_FromString("actionEvent");
441 PyErr_Clear();
466 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
442 if (obj && !PythonQtSlotFunction_Check(obj)) {
467 if (obj) {
443 static const char* argumentList[] ={"" , "QActionEvent*"};
468 static const char* argumentList[] ={"" , "QActionEvent*"};
444 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
469 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
445 void* args[2] = {NULL, (void*)&arg__1};
470 void* args[2] = {NULL, (void*)&arg__1};
446 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
471 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
447 if (result) { Py_DECREF(result); }
472 if (result) { Py_DECREF(result); }
448 Py_DECREF(obj);
473 Py_DECREF(obj);
449 return;
474 return;
475 } else {
476 PyErr_Clear();
450 }
477 }
451 }
478 }
452 MemSizeWdgt::actionEvent(arg__1);
479 MemSizeWdgt::actionEvent(arg__1);
453 }
480 }
454 void PythonQtShell_MemSizeWdgt::changeEvent(QEvent* arg__1)
481 void PythonQtShell_MemSizeWdgt::changeEvent(QEvent* arg__1)
455 {
482 {
456 if (_wrapper) {
483 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
457 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
484 static PyObject* name = PyString_FromString("changeEvent");
458 PyErr_Clear();
485 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
459 if (obj && !PythonQtSlotFunction_Check(obj)) {
486 if (obj) {
460 static const char* argumentList[] ={"" , "QEvent*"};
487 static const char* argumentList[] ={"" , "QEvent*"};
461 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
488 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
462 void* args[2] = {NULL, (void*)&arg__1};
489 void* args[2] = {NULL, (void*)&arg__1};
463 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
490 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
464 if (result) { Py_DECREF(result); }
491 if (result) { Py_DECREF(result); }
465 Py_DECREF(obj);
492 Py_DECREF(obj);
466 return;
493 return;
494 } else {
495 PyErr_Clear();
467 }
496 }
468 }
497 }
469 MemSizeWdgt::changeEvent(arg__1);
498 MemSizeWdgt::changeEvent(arg__1);
470 }
499 }
471 void PythonQtShell_MemSizeWdgt::childEvent(QChildEvent* arg__1)
500 void PythonQtShell_MemSizeWdgt::childEvent(QChildEvent* arg__1)
472 {
501 {
473 if (_wrapper) {
502 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
474 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
503 static PyObject* name = PyString_FromString("childEvent");
475 PyErr_Clear();
504 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
476 if (obj && !PythonQtSlotFunction_Check(obj)) {
505 if (obj) {
477 static const char* argumentList[] ={"" , "QChildEvent*"};
506 static const char* argumentList[] ={"" , "QChildEvent*"};
478 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
507 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
479 void* args[2] = {NULL, (void*)&arg__1};
508 void* args[2] = {NULL, (void*)&arg__1};
480 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
509 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
481 if (result) { Py_DECREF(result); }
510 if (result) { Py_DECREF(result); }
482 Py_DECREF(obj);
511 Py_DECREF(obj);
483 return;
512 return;
513 } else {
514 PyErr_Clear();
484 }
515 }
485 }
516 }
486 MemSizeWdgt::childEvent(arg__1);
517 MemSizeWdgt::childEvent(arg__1);
487 }
518 }
488 void PythonQtShell_MemSizeWdgt::closeEvent(QCloseEvent* arg__1)
519 void PythonQtShell_MemSizeWdgt::closeEvent(QCloseEvent* arg__1)
489 {
520 {
490 if (_wrapper) {
521 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
491 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
522 static PyObject* name = PyString_FromString("closeEvent");
492 PyErr_Clear();
523 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
493 if (obj && !PythonQtSlotFunction_Check(obj)) {
524 if (obj) {
494 static const char* argumentList[] ={"" , "QCloseEvent*"};
525 static const char* argumentList[] ={"" , "QCloseEvent*"};
495 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
526 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
496 void* args[2] = {NULL, (void*)&arg__1};
527 void* args[2] = {NULL, (void*)&arg__1};
497 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
528 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
498 if (result) { Py_DECREF(result); }
529 if (result) { Py_DECREF(result); }
499 Py_DECREF(obj);
530 Py_DECREF(obj);
500 return;
531 return;
532 } else {
533 PyErr_Clear();
501 }
534 }
502 }
535 }
503 MemSizeWdgt::closeEvent(arg__1);
536 MemSizeWdgt::closeEvent(arg__1);
504 }
537 }
505 void PythonQtShell_MemSizeWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
538 void PythonQtShell_MemSizeWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
506 {
539 {
507 if (_wrapper) {
540 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
508 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
541 static PyObject* name = PyString_FromString("contextMenuEvent");
509 PyErr_Clear();
542 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
510 if (obj && !PythonQtSlotFunction_Check(obj)) {
543 if (obj) {
511 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
544 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
512 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
545 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
513 void* args[2] = {NULL, (void*)&arg__1};
546 void* args[2] = {NULL, (void*)&arg__1};
514 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
547 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
515 if (result) { Py_DECREF(result); }
548 if (result) { Py_DECREF(result); }
516 Py_DECREF(obj);
549 Py_DECREF(obj);
517 return;
550 return;
551 } else {
552 PyErr_Clear();
518 }
553 }
519 }
554 }
520 MemSizeWdgt::contextMenuEvent(arg__1);
555 MemSizeWdgt::contextMenuEvent(arg__1);
521 }
556 }
522 void PythonQtShell_MemSizeWdgt::customEvent(QEvent* arg__1)
557 void PythonQtShell_MemSizeWdgt::customEvent(QEvent* arg__1)
523 {
558 {
524 if (_wrapper) {
559 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
525 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
560 static PyObject* name = PyString_FromString("customEvent");
526 PyErr_Clear();
561 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
527 if (obj && !PythonQtSlotFunction_Check(obj)) {
562 if (obj) {
528 static const char* argumentList[] ={"" , "QEvent*"};
563 static const char* argumentList[] ={"" , "QEvent*"};
529 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
564 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
530 void* args[2] = {NULL, (void*)&arg__1};
565 void* args[2] = {NULL, (void*)&arg__1};
531 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
566 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
532 if (result) { Py_DECREF(result); }
567 if (result) { Py_DECREF(result); }
533 Py_DECREF(obj);
568 Py_DECREF(obj);
534 return;
569 return;
570 } else {
571 PyErr_Clear();
535 }
572 }
536 }
573 }
537 MemSizeWdgt::customEvent(arg__1);
574 MemSizeWdgt::customEvent(arg__1);
538 }
575 }
539 int PythonQtShell_MemSizeWdgt::devType() const
576 int PythonQtShell_MemSizeWdgt::devType() const
540 {
577 {
541 if (_wrapper) {
578 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
542 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
579 static PyObject* name = PyString_FromString("devType");
543 PyErr_Clear();
580 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
544 if (obj && !PythonQtSlotFunction_Check(obj)) {
581 if (obj) {
545 static const char* argumentList[] ={"int"};
582 static const char* argumentList[] ={"int"};
546 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
583 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
547 int returnValue;
584 int returnValue;
548 void* args[1] = {NULL};
585 void* args[1] = {NULL};
549 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
586 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
550 if (result) {
587 if (result) {
551 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
588 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
552 if (args[0]!=&returnValue) {
589 if (args[0]!=&returnValue) {
553 if (args[0]==NULL) {
590 if (args[0]==NULL) {
554 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
591 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
555 } else {
592 } else {
556 returnValue = *((int*)args[0]);
593 returnValue = *((int*)args[0]);
557 }
594 }
558 }
595 }
559 }
596 }
560 if (result) { Py_DECREF(result); }
597 if (result) { Py_DECREF(result); }
561 Py_DECREF(obj);
598 Py_DECREF(obj);
562 return returnValue;
599 return returnValue;
600 } else {
601 PyErr_Clear();
563 }
602 }
564 }
603 }
565 return MemSizeWdgt::devType();
604 return MemSizeWdgt::devType();
566 }
605 }
567 void PythonQtShell_MemSizeWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
606 void PythonQtShell_MemSizeWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
568 {
607 {
569 if (_wrapper) {
608 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
570 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
609 static PyObject* name = PyString_FromString("dragEnterEvent");
571 PyErr_Clear();
610 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
572 if (obj && !PythonQtSlotFunction_Check(obj)) {
611 if (obj) {
573 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
612 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
574 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
613 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
575 void* args[2] = {NULL, (void*)&arg__1};
614 void* args[2] = {NULL, (void*)&arg__1};
576 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
615 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
577 if (result) { Py_DECREF(result); }
616 if (result) { Py_DECREF(result); }
578 Py_DECREF(obj);
617 Py_DECREF(obj);
579 return;
618 return;
619 } else {
620 PyErr_Clear();
580 }
621 }
581 }
622 }
582 MemSizeWdgt::dragEnterEvent(arg__1);
623 MemSizeWdgt::dragEnterEvent(arg__1);
583 }
624 }
584 void PythonQtShell_MemSizeWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
625 void PythonQtShell_MemSizeWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
585 {
626 {
586 if (_wrapper) {
627 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
587 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
628 static PyObject* name = PyString_FromString("dragLeaveEvent");
588 PyErr_Clear();
629 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
589 if (obj && !PythonQtSlotFunction_Check(obj)) {
630 if (obj) {
590 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
631 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
591 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
632 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
592 void* args[2] = {NULL, (void*)&arg__1};
633 void* args[2] = {NULL, (void*)&arg__1};
593 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
634 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
594 if (result) { Py_DECREF(result); }
635 if (result) { Py_DECREF(result); }
595 Py_DECREF(obj);
636 Py_DECREF(obj);
596 return;
637 return;
638 } else {
639 PyErr_Clear();
597 }
640 }
598 }
641 }
599 MemSizeWdgt::dragLeaveEvent(arg__1);
642 MemSizeWdgt::dragLeaveEvent(arg__1);
600 }
643 }
601 void PythonQtShell_MemSizeWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
644 void PythonQtShell_MemSizeWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
602 {
645 {
603 if (_wrapper) {
646 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
604 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
647 static PyObject* name = PyString_FromString("dragMoveEvent");
605 PyErr_Clear();
648 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
606 if (obj && !PythonQtSlotFunction_Check(obj)) {
649 if (obj) {
607 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
650 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
608 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
651 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
609 void* args[2] = {NULL, (void*)&arg__1};
652 void* args[2] = {NULL, (void*)&arg__1};
610 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
653 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
611 if (result) { Py_DECREF(result); }
654 if (result) { Py_DECREF(result); }
612 Py_DECREF(obj);
655 Py_DECREF(obj);
613 return;
656 return;
657 } else {
658 PyErr_Clear();
614 }
659 }
615 }
660 }
616 MemSizeWdgt::dragMoveEvent(arg__1);
661 MemSizeWdgt::dragMoveEvent(arg__1);
617 }
662 }
618 void PythonQtShell_MemSizeWdgt::dropEvent(QDropEvent* arg__1)
663 void PythonQtShell_MemSizeWdgt::dropEvent(QDropEvent* arg__1)
619 {
664 {
620 if (_wrapper) {
665 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
621 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
666 static PyObject* name = PyString_FromString("dropEvent");
622 PyErr_Clear();
667 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
623 if (obj && !PythonQtSlotFunction_Check(obj)) {
668 if (obj) {
624 static const char* argumentList[] ={"" , "QDropEvent*"};
669 static const char* argumentList[] ={"" , "QDropEvent*"};
625 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
670 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
626 void* args[2] = {NULL, (void*)&arg__1};
671 void* args[2] = {NULL, (void*)&arg__1};
627 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
672 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
628 if (result) { Py_DECREF(result); }
673 if (result) { Py_DECREF(result); }
629 Py_DECREF(obj);
674 Py_DECREF(obj);
630 return;
675 return;
676 } else {
677 PyErr_Clear();
631 }
678 }
632 }
679 }
633 MemSizeWdgt::dropEvent(arg__1);
680 MemSizeWdgt::dropEvent(arg__1);
634 }
681 }
635 void PythonQtShell_MemSizeWdgt::enterEvent(QEvent* arg__1)
682 void PythonQtShell_MemSizeWdgt::enterEvent(QEvent* arg__1)
636 {
683 {
637 if (_wrapper) {
684 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
638 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
685 static PyObject* name = PyString_FromString("enterEvent");
639 PyErr_Clear();
686 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
640 if (obj && !PythonQtSlotFunction_Check(obj)) {
687 if (obj) {
641 static const char* argumentList[] ={"" , "QEvent*"};
688 static const char* argumentList[] ={"" , "QEvent*"};
642 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
689 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
643 void* args[2] = {NULL, (void*)&arg__1};
690 void* args[2] = {NULL, (void*)&arg__1};
644 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
691 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
645 if (result) { Py_DECREF(result); }
692 if (result) { Py_DECREF(result); }
646 Py_DECREF(obj);
693 Py_DECREF(obj);
647 return;
694 return;
695 } else {
696 PyErr_Clear();
648 }
697 }
649 }
698 }
650 MemSizeWdgt::enterEvent(arg__1);
699 MemSizeWdgt::enterEvent(arg__1);
651 }
700 }
652 bool PythonQtShell_MemSizeWdgt::event(QEvent* arg__1)
701 bool PythonQtShell_MemSizeWdgt::event(QEvent* arg__1)
653 {
702 {
654 if (_wrapper) {
703 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
655 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
704 static PyObject* name = PyString_FromString("event");
656 PyErr_Clear();
705 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
657 if (obj && !PythonQtSlotFunction_Check(obj)) {
706 if (obj) {
658 static const char* argumentList[] ={"bool" , "QEvent*"};
707 static const char* argumentList[] ={"bool" , "QEvent*"};
659 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
708 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
660 bool returnValue;
709 bool returnValue;
661 void* args[2] = {NULL, (void*)&arg__1};
710 void* args[2] = {NULL, (void*)&arg__1};
662 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
711 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
663 if (result) {
712 if (result) {
664 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
713 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
665 if (args[0]!=&returnValue) {
714 if (args[0]!=&returnValue) {
666 if (args[0]==NULL) {
715 if (args[0]==NULL) {
667 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
716 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
668 } else {
717 } else {
669 returnValue = *((bool*)args[0]);
718 returnValue = *((bool*)args[0]);
670 }
719 }
671 }
720 }
672 }
721 }
673 if (result) { Py_DECREF(result); }
722 if (result) { Py_DECREF(result); }
674 Py_DECREF(obj);
723 Py_DECREF(obj);
675 return returnValue;
724 return returnValue;
725 } else {
726 PyErr_Clear();
676 }
727 }
677 }
728 }
678 return MemSizeWdgt::event(arg__1);
729 return MemSizeWdgt::event(arg__1);
679 }
730 }
680 bool PythonQtShell_MemSizeWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
731 bool PythonQtShell_MemSizeWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
681 {
732 {
682 if (_wrapper) {
733 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
683 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
734 static PyObject* name = PyString_FromString("eventFilter");
684 PyErr_Clear();
735 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
685 if (obj && !PythonQtSlotFunction_Check(obj)) {
736 if (obj) {
686 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
737 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
687 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
738 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
688 bool returnValue;
739 bool returnValue;
689 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
740 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
690 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
741 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
691 if (result) {
742 if (result) {
692 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
743 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
693 if (args[0]!=&returnValue) {
744 if (args[0]!=&returnValue) {
694 if (args[0]==NULL) {
745 if (args[0]==NULL) {
695 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
746 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
696 } else {
747 } else {
697 returnValue = *((bool*)args[0]);
748 returnValue = *((bool*)args[0]);
698 }
749 }
699 }
750 }
700 }
751 }
701 if (result) { Py_DECREF(result); }
752 if (result) { Py_DECREF(result); }
702 Py_DECREF(obj);
753 Py_DECREF(obj);
703 return returnValue;
754 return returnValue;
755 } else {
756 PyErr_Clear();
704 }
757 }
705 }
758 }
706 return MemSizeWdgt::eventFilter(arg__1, arg__2);
759 return MemSizeWdgt::eventFilter(arg__1, arg__2);
707 }
760 }
708 void PythonQtShell_MemSizeWdgt::focusInEvent(QFocusEvent* arg__1)
761 void PythonQtShell_MemSizeWdgt::focusInEvent(QFocusEvent* arg__1)
709 {
762 {
710 if (_wrapper) {
763 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
711 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
764 static PyObject* name = PyString_FromString("focusInEvent");
712 PyErr_Clear();
765 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
713 if (obj && !PythonQtSlotFunction_Check(obj)) {
766 if (obj) {
714 static const char* argumentList[] ={"" , "QFocusEvent*"};
767 static const char* argumentList[] ={"" , "QFocusEvent*"};
715 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
768 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
716 void* args[2] = {NULL, (void*)&arg__1};
769 void* args[2] = {NULL, (void*)&arg__1};
717 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
770 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
718 if (result) { Py_DECREF(result); }
771 if (result) { Py_DECREF(result); }
719 Py_DECREF(obj);
772 Py_DECREF(obj);
720 return;
773 return;
774 } else {
775 PyErr_Clear();
721 }
776 }
722 }
777 }
723 MemSizeWdgt::focusInEvent(arg__1);
778 MemSizeWdgt::focusInEvent(arg__1);
724 }
779 }
725 bool PythonQtShell_MemSizeWdgt::focusNextPrevChild(bool next)
780 bool PythonQtShell_MemSizeWdgt::focusNextPrevChild(bool next0)
726 {
781 {
727 if (_wrapper) {
782 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
728 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
783 static PyObject* name = PyString_FromString("focusNextPrevChild");
729 PyErr_Clear();
784 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
730 if (obj && !PythonQtSlotFunction_Check(obj)) {
785 if (obj) {
731 static const char* argumentList[] ={"bool" , "bool"};
786 static const char* argumentList[] ={"bool" , "bool"};
732 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
787 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
733 bool returnValue;
788 bool returnValue;
734 void* args[2] = {NULL, (void*)&next};
789 void* args[2] = {NULL, (void*)&next0};
735 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
790 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
736 if (result) {
791 if (result) {
737 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
792 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
738 if (args[0]!=&returnValue) {
793 if (args[0]!=&returnValue) {
739 if (args[0]==NULL) {
794 if (args[0]==NULL) {
740 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
795 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
741 } else {
796 } else {
742 returnValue = *((bool*)args[0]);
797 returnValue = *((bool*)args[0]);
743 }
798 }
744 }
799 }
745 }
800 }
746 if (result) { Py_DECREF(result); }
801 if (result) { Py_DECREF(result); }
747 Py_DECREF(obj);
802 Py_DECREF(obj);
748 return returnValue;
803 return returnValue;
749 }
804 } else {
750 }
805 PyErr_Clear();
751 return MemSizeWdgt::focusNextPrevChild(next);
806 }
807 }
808 return MemSizeWdgt::focusNextPrevChild(next0);
752 }
809 }
753 void PythonQtShell_MemSizeWdgt::focusOutEvent(QFocusEvent* arg__1)
810 void PythonQtShell_MemSizeWdgt::focusOutEvent(QFocusEvent* arg__1)
754 {
811 {
755 if (_wrapper) {
812 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
756 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
813 static PyObject* name = PyString_FromString("focusOutEvent");
757 PyErr_Clear();
814 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
758 if (obj && !PythonQtSlotFunction_Check(obj)) {
815 if (obj) {
759 static const char* argumentList[] ={"" , "QFocusEvent*"};
816 static const char* argumentList[] ={"" , "QFocusEvent*"};
760 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
817 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
761 void* args[2] = {NULL, (void*)&arg__1};
818 void* args[2] = {NULL, (void*)&arg__1};
762 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
819 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
763 if (result) { Py_DECREF(result); }
820 if (result) { Py_DECREF(result); }
764 Py_DECREF(obj);
821 Py_DECREF(obj);
765 return;
822 return;
823 } else {
824 PyErr_Clear();
766 }
825 }
767 }
826 }
768 MemSizeWdgt::focusOutEvent(arg__1);
827 MemSizeWdgt::focusOutEvent(arg__1);
769 }
828 }
770 bool PythonQtShell_MemSizeWdgt::hasHeightForWidth() const
829 bool PythonQtShell_MemSizeWdgt::hasHeightForWidth() const
771 {
830 {
772 if (_wrapper) {
831 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
773 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
832 static PyObject* name = PyString_FromString("hasHeightForWidth");
774 PyErr_Clear();
833 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
775 if (obj && !PythonQtSlotFunction_Check(obj)) {
834 if (obj) {
776 static const char* argumentList[] ={"bool"};
835 static const char* argumentList[] ={"bool"};
777 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
836 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
778 bool returnValue;
837 bool returnValue;
779 void* args[1] = {NULL};
838 void* args[1] = {NULL};
780 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
839 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
781 if (result) {
840 if (result) {
782 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
841 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
783 if (args[0]!=&returnValue) {
842 if (args[0]!=&returnValue) {
784 if (args[0]==NULL) {
843 if (args[0]==NULL) {
785 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
844 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
786 } else {
845 } else {
787 returnValue = *((bool*)args[0]);
846 returnValue = *((bool*)args[0]);
788 }
847 }
789 }
848 }
790 }
849 }
791 if (result) { Py_DECREF(result); }
850 if (result) { Py_DECREF(result); }
792 Py_DECREF(obj);
851 Py_DECREF(obj);
793 return returnValue;
852 return returnValue;
853 } else {
854 PyErr_Clear();
794 }
855 }
795 }
856 }
796 return MemSizeWdgt::hasHeightForWidth();
857 return MemSizeWdgt::hasHeightForWidth();
797 }
858 }
798 int PythonQtShell_MemSizeWdgt::heightForWidth(int arg__1) const
859 int PythonQtShell_MemSizeWdgt::heightForWidth(int arg__1) const
799 {
860 {
800 if (_wrapper) {
861 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
801 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
862 static PyObject* name = PyString_FromString("heightForWidth");
802 PyErr_Clear();
863 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
803 if (obj && !PythonQtSlotFunction_Check(obj)) {
864 if (obj) {
804 static const char* argumentList[] ={"int" , "int"};
865 static const char* argumentList[] ={"int" , "int"};
805 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
866 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
806 int returnValue;
867 int returnValue;
807 void* args[2] = {NULL, (void*)&arg__1};
868 void* args[2] = {NULL, (void*)&arg__1};
808 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
869 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
809 if (result) {
870 if (result) {
810 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
871 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
811 if (args[0]!=&returnValue) {
872 if (args[0]!=&returnValue) {
812 if (args[0]==NULL) {
873 if (args[0]==NULL) {
813 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
874 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
814 } else {
875 } else {
815 returnValue = *((int*)args[0]);
876 returnValue = *((int*)args[0]);
816 }
877 }
817 }
878 }
818 }
879 }
819 if (result) { Py_DECREF(result); }
880 if (result) { Py_DECREF(result); }
820 Py_DECREF(obj);
881 Py_DECREF(obj);
821 return returnValue;
882 return returnValue;
883 } else {
884 PyErr_Clear();
822 }
885 }
823 }
886 }
824 return MemSizeWdgt::heightForWidth(arg__1);
887 return MemSizeWdgt::heightForWidth(arg__1);
825 }
888 }
826 void PythonQtShell_MemSizeWdgt::hideEvent(QHideEvent* arg__1)
889 void PythonQtShell_MemSizeWdgt::hideEvent(QHideEvent* arg__1)
827 {
890 {
828 if (_wrapper) {
891 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
829 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
892 static PyObject* name = PyString_FromString("hideEvent");
830 PyErr_Clear();
893 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
831 if (obj && !PythonQtSlotFunction_Check(obj)) {
894 if (obj) {
832 static const char* argumentList[] ={"" , "QHideEvent*"};
895 static const char* argumentList[] ={"" , "QHideEvent*"};
833 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
896 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
834 void* args[2] = {NULL, (void*)&arg__1};
897 void* args[2] = {NULL, (void*)&arg__1};
835 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
898 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
836 if (result) { Py_DECREF(result); }
899 if (result) { Py_DECREF(result); }
837 Py_DECREF(obj);
900 Py_DECREF(obj);
838 return;
901 return;
902 } else {
903 PyErr_Clear();
839 }
904 }
840 }
905 }
841 MemSizeWdgt::hideEvent(arg__1);
906 MemSizeWdgt::hideEvent(arg__1);
842 }
907 }
843 void PythonQtShell_MemSizeWdgt::initPainter(QPainter* painter) const
908 void PythonQtShell_MemSizeWdgt::initPainter(QPainter* painter0) const
844 {
909 {
845 if (_wrapper) {
910 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
846 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
911 static PyObject* name = PyString_FromString("initPainter");
847 PyErr_Clear();
912 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
848 if (obj && !PythonQtSlotFunction_Check(obj)) {
913 if (obj) {
849 static const char* argumentList[] ={"" , "QPainter*"};
914 static const char* argumentList[] ={"" , "QPainter*"};
850 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
915 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
851 void* args[2] = {NULL, (void*)&painter};
916 void* args[2] = {NULL, (void*)&painter0};
852 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
917 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
853 if (result) { Py_DECREF(result); }
918 if (result) { Py_DECREF(result); }
854 Py_DECREF(obj);
919 Py_DECREF(obj);
855 return;
920 return;
856 }
921 } else {
857 }
922 PyErr_Clear();
858 MemSizeWdgt::initPainter(painter);
923 }
924 }
925 MemSizeWdgt::initPainter(painter0);
859 }
926 }
860 void PythonQtShell_MemSizeWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
927 void PythonQtShell_MemSizeWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
861 {
928 {
862 if (_wrapper) {
929 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
863 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
930 static PyObject* name = PyString_FromString("inputMethodEvent");
864 PyErr_Clear();
931 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
865 if (obj && !PythonQtSlotFunction_Check(obj)) {
932 if (obj) {
866 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
933 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
867 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
934 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
868 void* args[2] = {NULL, (void*)&arg__1};
935 void* args[2] = {NULL, (void*)&arg__1};
869 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
936 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
870 if (result) { Py_DECREF(result); }
937 if (result) { Py_DECREF(result); }
871 Py_DECREF(obj);
938 Py_DECREF(obj);
872 return;
939 return;
940 } else {
941 PyErr_Clear();
873 }
942 }
874 }
943 }
875 MemSizeWdgt::inputMethodEvent(arg__1);
944 MemSizeWdgt::inputMethodEvent(arg__1);
876 }
945 }
877 QVariant PythonQtShell_MemSizeWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
946 QVariant PythonQtShell_MemSizeWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
878 {
947 {
879 if (_wrapper) {
948 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
880 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
949 static PyObject* name = PyString_FromString("inputMethodQuery");
881 PyErr_Clear();
950 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
882 if (obj && !PythonQtSlotFunction_Check(obj)) {
951 if (obj) {
883 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
952 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
884 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
953 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
885 QVariant returnValue;
954 QVariant returnValue;
886 void* args[2] = {NULL, (void*)&arg__1};
955 void* args[2] = {NULL, (void*)&arg__1};
887 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
956 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
888 if (result) {
957 if (result) {
889 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
958 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
890 if (args[0]!=&returnValue) {
959 if (args[0]!=&returnValue) {
891 if (args[0]==NULL) {
960 if (args[0]==NULL) {
892 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
961 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
893 } else {
962 } else {
894 returnValue = *((QVariant*)args[0]);
963 returnValue = *((QVariant*)args[0]);
895 }
964 }
896 }
965 }
897 }
966 }
898 if (result) { Py_DECREF(result); }
967 if (result) { Py_DECREF(result); }
899 Py_DECREF(obj);
968 Py_DECREF(obj);
900 return returnValue;
969 return returnValue;
970 } else {
971 PyErr_Clear();
901 }
972 }
902 }
973 }
903 return MemSizeWdgt::inputMethodQuery(arg__1);
974 return MemSizeWdgt::inputMethodQuery(arg__1);
904 }
975 }
905 void PythonQtShell_MemSizeWdgt::keyPressEvent(QKeyEvent* arg__1)
976 void PythonQtShell_MemSizeWdgt::keyPressEvent(QKeyEvent* arg__1)
906 {
977 {
907 if (_wrapper) {
978 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
908 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
979 static PyObject* name = PyString_FromString("keyPressEvent");
909 PyErr_Clear();
980 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
910 if (obj && !PythonQtSlotFunction_Check(obj)) {
981 if (obj) {
911 static const char* argumentList[] ={"" , "QKeyEvent*"};
982 static const char* argumentList[] ={"" , "QKeyEvent*"};
912 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
983 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
913 void* args[2] = {NULL, (void*)&arg__1};
984 void* args[2] = {NULL, (void*)&arg__1};
914 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
985 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
915 if (result) { Py_DECREF(result); }
986 if (result) { Py_DECREF(result); }
916 Py_DECREF(obj);
987 Py_DECREF(obj);
917 return;
988 return;
989 } else {
990 PyErr_Clear();
918 }
991 }
919 }
992 }
920 MemSizeWdgt::keyPressEvent(arg__1);
993 MemSizeWdgt::keyPressEvent(arg__1);
921 }
994 }
922 void PythonQtShell_MemSizeWdgt::keyReleaseEvent(QKeyEvent* arg__1)
995 void PythonQtShell_MemSizeWdgt::keyReleaseEvent(QKeyEvent* arg__1)
923 {
996 {
924 if (_wrapper) {
997 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
925 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
998 static PyObject* name = PyString_FromString("keyReleaseEvent");
926 PyErr_Clear();
999 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
927 if (obj && !PythonQtSlotFunction_Check(obj)) {
1000 if (obj) {
928 static const char* argumentList[] ={"" , "QKeyEvent*"};
1001 static const char* argumentList[] ={"" , "QKeyEvent*"};
929 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1002 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
930 void* args[2] = {NULL, (void*)&arg__1};
1003 void* args[2] = {NULL, (void*)&arg__1};
931 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1004 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
932 if (result) { Py_DECREF(result); }
1005 if (result) { Py_DECREF(result); }
933 Py_DECREF(obj);
1006 Py_DECREF(obj);
934 return;
1007 return;
1008 } else {
1009 PyErr_Clear();
935 }
1010 }
936 }
1011 }
937 MemSizeWdgt::keyReleaseEvent(arg__1);
1012 MemSizeWdgt::keyReleaseEvent(arg__1);
938 }
1013 }
939 void PythonQtShell_MemSizeWdgt::leaveEvent(QEvent* arg__1)
1014 void PythonQtShell_MemSizeWdgt::leaveEvent(QEvent* arg__1)
940 {
1015 {
941 if (_wrapper) {
1016 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
942 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
1017 static PyObject* name = PyString_FromString("leaveEvent");
943 PyErr_Clear();
1018 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
944 if (obj && !PythonQtSlotFunction_Check(obj)) {
1019 if (obj) {
945 static const char* argumentList[] ={"" , "QEvent*"};
1020 static const char* argumentList[] ={"" , "QEvent*"};
946 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1021 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
947 void* args[2] = {NULL, (void*)&arg__1};
1022 void* args[2] = {NULL, (void*)&arg__1};
948 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1023 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
949 if (result) { Py_DECREF(result); }
1024 if (result) { Py_DECREF(result); }
950 Py_DECREF(obj);
1025 Py_DECREF(obj);
951 return;
1026 return;
1027 } else {
1028 PyErr_Clear();
952 }
1029 }
953 }
1030 }
954 MemSizeWdgt::leaveEvent(arg__1);
1031 MemSizeWdgt::leaveEvent(arg__1);
955 }
1032 }
956 int PythonQtShell_MemSizeWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
1033 int PythonQtShell_MemSizeWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
957 {
1034 {
958 if (_wrapper) {
1035 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
959 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
1036 static PyObject* name = PyString_FromString("metric");
960 PyErr_Clear();
1037 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
961 if (obj && !PythonQtSlotFunction_Check(obj)) {
1038 if (obj) {
962 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
1039 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
963 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1040 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
964 int returnValue;
1041 int returnValue;
965 void* args[2] = {NULL, (void*)&arg__1};
1042 void* args[2] = {NULL, (void*)&arg__1};
966 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1043 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
967 if (result) {
1044 if (result) {
968 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1045 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
969 if (args[0]!=&returnValue) {
1046 if (args[0]!=&returnValue) {
970 if (args[0]==NULL) {
1047 if (args[0]==NULL) {
971 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
1048 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
972 } else {
1049 } else {
973 returnValue = *((int*)args[0]);
1050 returnValue = *((int*)args[0]);
974 }
1051 }
975 }
1052 }
976 }
1053 }
977 if (result) { Py_DECREF(result); }
1054 if (result) { Py_DECREF(result); }
978 Py_DECREF(obj);
1055 Py_DECREF(obj);
979 return returnValue;
1056 return returnValue;
1057 } else {
1058 PyErr_Clear();
980 }
1059 }
981 }
1060 }
982 return MemSizeWdgt::metric(arg__1);
1061 return MemSizeWdgt::metric(arg__1);
983 }
1062 }
984 QSize PythonQtShell_MemSizeWdgt::minimumSizeHint() const
1063 QSize PythonQtShell_MemSizeWdgt::minimumSizeHint() const
985 {
1064 {
986 if (_wrapper) {
1065 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
987 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
1066 static PyObject* name = PyString_FromString("getMinimumSizeHint");
988 PyErr_Clear();
1067 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
989 if (obj && !PythonQtSlotFunction_Check(obj)) {
1068 if (obj) {
990 static const char* argumentList[] ={"QSize"};
1069 static const char* argumentList[] ={"QSize"};
991 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1070 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
992 QSize returnValue;
1071 QSize returnValue;
993 void* args[1] = {NULL};
1072 void* args[1] = {NULL};
994 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1073 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
995 if (result) {
1074 if (result) {
996 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1075 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
997 if (args[0]!=&returnValue) {
1076 if (args[0]!=&returnValue) {
998 if (args[0]==NULL) {
1077 if (args[0]==NULL) {
999 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
1078 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
1000 } else {
1079 } else {
1001 returnValue = *((QSize*)args[0]);
1080 returnValue = *((QSize*)args[0]);
1002 }
1081 }
1003 }
1082 }
1004 }
1083 }
1005 if (result) { Py_DECREF(result); }
1084 if (result) { Py_DECREF(result); }
1006 Py_DECREF(obj);
1085 Py_DECREF(obj);
1007 return returnValue;
1086 return returnValue;
1087 } else {
1088 PyErr_Clear();
1008 }
1089 }
1009 }
1090 }
1010 return MemSizeWdgt::minimumSizeHint();
1091 return MemSizeWdgt::minimumSizeHint();
1011 }
1092 }
1012 void PythonQtShell_MemSizeWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
1093 void PythonQtShell_MemSizeWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
1013 {
1094 {
1014 if (_wrapper) {
1095 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1015 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
1096 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
1016 PyErr_Clear();
1097 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1017 if (obj && !PythonQtSlotFunction_Check(obj)) {
1098 if (obj) {
1018 static const char* argumentList[] ={"" , "QMouseEvent*"};
1099 static const char* argumentList[] ={"" , "QMouseEvent*"};
1019 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1100 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1020 void* args[2] = {NULL, (void*)&arg__1};
1101 void* args[2] = {NULL, (void*)&arg__1};
1021 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1102 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1022 if (result) { Py_DECREF(result); }
1103 if (result) { Py_DECREF(result); }
1023 Py_DECREF(obj);
1104 Py_DECREF(obj);
1024 return;
1105 return;
1106 } else {
1107 PyErr_Clear();
1025 }
1108 }
1026 }
1109 }
1027 MemSizeWdgt::mouseDoubleClickEvent(arg__1);
1110 MemSizeWdgt::mouseDoubleClickEvent(arg__1);
1028 }
1111 }
1029 void PythonQtShell_MemSizeWdgt::mouseMoveEvent(QMouseEvent* arg__1)
1112 void PythonQtShell_MemSizeWdgt::mouseMoveEvent(QMouseEvent* arg__1)
1030 {
1113 {
1031 if (_wrapper) {
1114 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1032 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
1115 static PyObject* name = PyString_FromString("mouseMoveEvent");
1033 PyErr_Clear();
1116 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1034 if (obj && !PythonQtSlotFunction_Check(obj)) {
1117 if (obj) {
1035 static const char* argumentList[] ={"" , "QMouseEvent*"};
1118 static const char* argumentList[] ={"" , "QMouseEvent*"};
1036 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1119 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1037 void* args[2] = {NULL, (void*)&arg__1};
1120 void* args[2] = {NULL, (void*)&arg__1};
1038 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1121 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1039 if (result) { Py_DECREF(result); }
1122 if (result) { Py_DECREF(result); }
1040 Py_DECREF(obj);
1123 Py_DECREF(obj);
1041 return;
1124 return;
1125 } else {
1126 PyErr_Clear();
1042 }
1127 }
1043 }
1128 }
1044 MemSizeWdgt::mouseMoveEvent(arg__1);
1129 MemSizeWdgt::mouseMoveEvent(arg__1);
1045 }
1130 }
1046 void PythonQtShell_MemSizeWdgt::mousePressEvent(QMouseEvent* arg__1)
1131 void PythonQtShell_MemSizeWdgt::mousePressEvent(QMouseEvent* arg__1)
1047 {
1132 {
1048 if (_wrapper) {
1133 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1049 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
1134 static PyObject* name = PyString_FromString("mousePressEvent");
1050 PyErr_Clear();
1135 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1051 if (obj && !PythonQtSlotFunction_Check(obj)) {
1136 if (obj) {
1052 static const char* argumentList[] ={"" , "QMouseEvent*"};
1137 static const char* argumentList[] ={"" , "QMouseEvent*"};
1053 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1138 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1054 void* args[2] = {NULL, (void*)&arg__1};
1139 void* args[2] = {NULL, (void*)&arg__1};
1055 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1140 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1056 if (result) { Py_DECREF(result); }
1141 if (result) { Py_DECREF(result); }
1057 Py_DECREF(obj);
1142 Py_DECREF(obj);
1058 return;
1143 return;
1144 } else {
1145 PyErr_Clear();
1059 }
1146 }
1060 }
1147 }
1061 MemSizeWdgt::mousePressEvent(arg__1);
1148 MemSizeWdgt::mousePressEvent(arg__1);
1062 }
1149 }
1063 void PythonQtShell_MemSizeWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
1150 void PythonQtShell_MemSizeWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
1064 {
1151 {
1065 if (_wrapper) {
1152 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1066 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
1153 static PyObject* name = PyString_FromString("mouseReleaseEvent");
1067 PyErr_Clear();
1154 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1068 if (obj && !PythonQtSlotFunction_Check(obj)) {
1155 if (obj) {
1069 static const char* argumentList[] ={"" , "QMouseEvent*"};
1156 static const char* argumentList[] ={"" , "QMouseEvent*"};
1070 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1157 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1071 void* args[2] = {NULL, (void*)&arg__1};
1158 void* args[2] = {NULL, (void*)&arg__1};
1072 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1159 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1073 if (result) { Py_DECREF(result); }
1160 if (result) { Py_DECREF(result); }
1074 Py_DECREF(obj);
1161 Py_DECREF(obj);
1075 return;
1162 return;
1163 } else {
1164 PyErr_Clear();
1076 }
1165 }
1077 }
1166 }
1078 MemSizeWdgt::mouseReleaseEvent(arg__1);
1167 MemSizeWdgt::mouseReleaseEvent(arg__1);
1079 }
1168 }
1080 void PythonQtShell_MemSizeWdgt::moveEvent(QMoveEvent* arg__1)
1169 void PythonQtShell_MemSizeWdgt::moveEvent(QMoveEvent* arg__1)
1081 {
1170 {
1082 if (_wrapper) {
1171 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1083 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
1172 static PyObject* name = PyString_FromString("moveEvent");
1084 PyErr_Clear();
1173 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1085 if (obj && !PythonQtSlotFunction_Check(obj)) {
1174 if (obj) {
1086 static const char* argumentList[] ={"" , "QMoveEvent*"};
1175 static const char* argumentList[] ={"" , "QMoveEvent*"};
1087 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1176 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1088 void* args[2] = {NULL, (void*)&arg__1};
1177 void* args[2] = {NULL, (void*)&arg__1};
1089 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1178 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1090 if (result) { Py_DECREF(result); }
1179 if (result) { Py_DECREF(result); }
1091 Py_DECREF(obj);
1180 Py_DECREF(obj);
1092 return;
1181 return;
1182 } else {
1183 PyErr_Clear();
1093 }
1184 }
1094 }
1185 }
1095 MemSizeWdgt::moveEvent(arg__1);
1186 MemSizeWdgt::moveEvent(arg__1);
1096 }
1187 }
1097 bool PythonQtShell_MemSizeWdgt::nativeEvent(const QByteArray& eventType, void* message, long* result)
1188 bool PythonQtShell_MemSizeWdgt::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
1098 {
1189 {
1099 if (_wrapper) {
1190 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1100 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
1191 static PyObject* name = PyString_FromString("nativeEvent");
1101 PyErr_Clear();
1192 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1102 if (obj && !PythonQtSlotFunction_Check(obj)) {
1193 if (obj) {
1103 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
1194 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
1104 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
1195 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
1105 bool returnValue;
1196 bool returnValue;
1106 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
1197 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
1107 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1198 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1108 if (result) {
1199 if (result) {
1109 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1200 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1110 if (args[0]!=&returnValue) {
1201 if (args[0]!=&returnValue) {
1111 if (args[0]==NULL) {
1202 if (args[0]==NULL) {
1112 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
1203 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
1113 } else {
1204 } else {
1114 returnValue = *((bool*)args[0]);
1205 returnValue = *((bool*)args[0]);
1115 }
1206 }
1116 }
1207 }
1117 }
1208 }
1118 if (result) { Py_DECREF(result); }
1209 if (result) { Py_DECREF(result); }
1119 Py_DECREF(obj);
1210 Py_DECREF(obj);
1120 return returnValue;
1211 return returnValue;
1121 }
1212 } else {
1122 }
1213 PyErr_Clear();
1123 return MemSizeWdgt::nativeEvent(eventType, message, result);
1214 }
1215 }
1216 return MemSizeWdgt::nativeEvent(eventType0, message1, result2);
1124 }
1217 }
1125 QPaintEngine* PythonQtShell_MemSizeWdgt::paintEngine() const
1218 QPaintEngine* PythonQtShell_MemSizeWdgt::paintEngine() const
1126 {
1219 {
1127 if (_wrapper) {
1220 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1128 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
1221 static PyObject* name = PyString_FromString("paintEngine");
1129 PyErr_Clear();
1222 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1130 if (obj && !PythonQtSlotFunction_Check(obj)) {
1223 if (obj) {
1131 static const char* argumentList[] ={"QPaintEngine*"};
1224 static const char* argumentList[] ={"QPaintEngine*"};
1132 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1225 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1133 QPaintEngine* returnValue;
1226 QPaintEngine* returnValue;
1134 void* args[1] = {NULL};
1227 void* args[1] = {NULL};
1135 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1228 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1136 if (result) {
1229 if (result) {
1137 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1230 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1138 if (args[0]!=&returnValue) {
1231 if (args[0]!=&returnValue) {
1139 if (args[0]==NULL) {
1232 if (args[0]==NULL) {
1140 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
1233 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
1141 } else {
1234 } else {
1142 returnValue = *((QPaintEngine**)args[0]);
1235 returnValue = *((QPaintEngine**)args[0]);
1143 }
1236 }
1144 }
1237 }
1145 }
1238 }
1146 if (result) { Py_DECREF(result); }
1239 if (result) { Py_DECREF(result); }
1147 Py_DECREF(obj);
1240 Py_DECREF(obj);
1148 return returnValue;
1241 return returnValue;
1242 } else {
1243 PyErr_Clear();
1149 }
1244 }
1150 }
1245 }
1151 return MemSizeWdgt::paintEngine();
1246 return MemSizeWdgt::paintEngine();
1152 }
1247 }
1153 void PythonQtShell_MemSizeWdgt::paintEvent(QPaintEvent* arg__1)
1248 void PythonQtShell_MemSizeWdgt::paintEvent(QPaintEvent* arg__1)
1154 {
1249 {
1155 if (_wrapper) {
1250 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1156 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
1251 static PyObject* name = PyString_FromString("paintEvent");
1157 PyErr_Clear();
1252 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1158 if (obj && !PythonQtSlotFunction_Check(obj)) {
1253 if (obj) {
1159 static const char* argumentList[] ={"" , "QPaintEvent*"};
1254 static const char* argumentList[] ={"" , "QPaintEvent*"};
1160 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1255 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1161 void* args[2] = {NULL, (void*)&arg__1};
1256 void* args[2] = {NULL, (void*)&arg__1};
1162 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1257 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1163 if (result) { Py_DECREF(result); }
1258 if (result) { Py_DECREF(result); }
1164 Py_DECREF(obj);
1259 Py_DECREF(obj);
1165 return;
1260 return;
1261 } else {
1262 PyErr_Clear();
1166 }
1263 }
1167 }
1264 }
1168 MemSizeWdgt::paintEvent(arg__1);
1265 MemSizeWdgt::paintEvent(arg__1);
1169 }
1266 }
1170 QPaintDevice* PythonQtShell_MemSizeWdgt::redirected(QPoint* offset) const
1267 QPaintDevice* PythonQtShell_MemSizeWdgt::redirected(QPoint* offset0) const
1171 {
1268 {
1172 if (_wrapper) {
1269 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1173 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
1270 static PyObject* name = PyString_FromString("redirected");
1174 PyErr_Clear();
1271 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1175 if (obj && !PythonQtSlotFunction_Check(obj)) {
1272 if (obj) {
1176 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
1273 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
1177 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1274 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1178 QPaintDevice* returnValue;
1275 QPaintDevice* returnValue;
1179 void* args[2] = {NULL, (void*)&offset};
1276 void* args[2] = {NULL, (void*)&offset0};
1180 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1277 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1181 if (result) {
1278 if (result) {
1182 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1279 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1183 if (args[0]!=&returnValue) {
1280 if (args[0]!=&returnValue) {
1184 if (args[0]==NULL) {
1281 if (args[0]==NULL) {
1185 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
1282 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
1186 } else {
1283 } else {
1187 returnValue = *((QPaintDevice**)args[0]);
1284 returnValue = *((QPaintDevice**)args[0]);
1188 }
1285 }
1189 }
1286 }
1190 }
1287 }
1191 if (result) { Py_DECREF(result); }
1288 if (result) { Py_DECREF(result); }
1192 Py_DECREF(obj);
1289 Py_DECREF(obj);
1193 return returnValue;
1290 return returnValue;
1194 }
1291 } else {
1195 }
1292 PyErr_Clear();
1196 return MemSizeWdgt::redirected(offset);
1293 }
1294 }
1295 return MemSizeWdgt::redirected(offset0);
1197 }
1296 }
1198 void PythonQtShell_MemSizeWdgt::resizeEvent(QResizeEvent* arg__1)
1297 void PythonQtShell_MemSizeWdgt::resizeEvent(QResizeEvent* arg__1)
1199 {
1298 {
1200 if (_wrapper) {
1299 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1201 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
1300 static PyObject* name = PyString_FromString("resizeEvent");
1202 PyErr_Clear();
1301 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1203 if (obj && !PythonQtSlotFunction_Check(obj)) {
1302 if (obj) {
1204 static const char* argumentList[] ={"" , "QResizeEvent*"};
1303 static const char* argumentList[] ={"" , "QResizeEvent*"};
1205 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1304 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1206 void* args[2] = {NULL, (void*)&arg__1};
1305 void* args[2] = {NULL, (void*)&arg__1};
1207 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1306 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1208 if (result) { Py_DECREF(result); }
1307 if (result) { Py_DECREF(result); }
1209 Py_DECREF(obj);
1308 Py_DECREF(obj);
1210 return;
1309 return;
1310 } else {
1311 PyErr_Clear();
1211 }
1312 }
1212 }
1313 }
1213 MemSizeWdgt::resizeEvent(arg__1);
1314 MemSizeWdgt::resizeEvent(arg__1);
1214 }
1315 }
1215 QPainter* PythonQtShell_MemSizeWdgt::sharedPainter() const
1316 QPainter* PythonQtShell_MemSizeWdgt::sharedPainter() const
1216 {
1317 {
1217 if (_wrapper) {
1318 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1218 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
1319 static PyObject* name = PyString_FromString("sharedPainter");
1219 PyErr_Clear();
1320 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1220 if (obj && !PythonQtSlotFunction_Check(obj)) {
1321 if (obj) {
1221 static const char* argumentList[] ={"QPainter*"};
1322 static const char* argumentList[] ={"QPainter*"};
1222 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1323 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1223 QPainter* returnValue;
1324 QPainter* returnValue;
1224 void* args[1] = {NULL};
1325 void* args[1] = {NULL};
1225 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1326 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1226 if (result) {
1327 if (result) {
1227 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1328 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1228 if (args[0]!=&returnValue) {
1329 if (args[0]!=&returnValue) {
1229 if (args[0]==NULL) {
1330 if (args[0]==NULL) {
1230 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
1331 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
1231 } else {
1332 } else {
1232 returnValue = *((QPainter**)args[0]);
1333 returnValue = *((QPainter**)args[0]);
1233 }
1334 }
1234 }
1335 }
1235 }
1336 }
1236 if (result) { Py_DECREF(result); }
1337 if (result) { Py_DECREF(result); }
1237 Py_DECREF(obj);
1338 Py_DECREF(obj);
1238 return returnValue;
1339 return returnValue;
1340 } else {
1341 PyErr_Clear();
1239 }
1342 }
1240 }
1343 }
1241 return MemSizeWdgt::sharedPainter();
1344 return MemSizeWdgt::sharedPainter();
1242 }
1345 }
1243 void PythonQtShell_MemSizeWdgt::showEvent(QShowEvent* arg__1)
1346 void PythonQtShell_MemSizeWdgt::showEvent(QShowEvent* arg__1)
1244 {
1347 {
1245 if (_wrapper) {
1348 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1246 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
1349 static PyObject* name = PyString_FromString("showEvent");
1247 PyErr_Clear();
1350 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1248 if (obj && !PythonQtSlotFunction_Check(obj)) {
1351 if (obj) {
1249 static const char* argumentList[] ={"" , "QShowEvent*"};
1352 static const char* argumentList[] ={"" , "QShowEvent*"};
1250 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1353 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1251 void* args[2] = {NULL, (void*)&arg__1};
1354 void* args[2] = {NULL, (void*)&arg__1};
1252 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1355 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1253 if (result) { Py_DECREF(result); }
1356 if (result) { Py_DECREF(result); }
1254 Py_DECREF(obj);
1357 Py_DECREF(obj);
1255 return;
1358 return;
1359 } else {
1360 PyErr_Clear();
1256 }
1361 }
1257 }
1362 }
1258 MemSizeWdgt::showEvent(arg__1);
1363 MemSizeWdgt::showEvent(arg__1);
1259 }
1364 }
1260 QSize PythonQtShell_MemSizeWdgt::sizeHint() const
1365 QSize PythonQtShell_MemSizeWdgt::sizeHint() const
1261 {
1366 {
1262 if (_wrapper) {
1367 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1263 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
1368 static PyObject* name = PyString_FromString("getSizeHint");
1264 PyErr_Clear();
1369 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1265 if (obj && !PythonQtSlotFunction_Check(obj)) {
1370 if (obj) {
1266 static const char* argumentList[] ={"QSize"};
1371 static const char* argumentList[] ={"QSize"};
1267 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1372 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1268 QSize returnValue;
1373 QSize returnValue;
1269 void* args[1] = {NULL};
1374 void* args[1] = {NULL};
1270 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1375 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1271 if (result) {
1376 if (result) {
1272 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1377 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1273 if (args[0]!=&returnValue) {
1378 if (args[0]!=&returnValue) {
1274 if (args[0]==NULL) {
1379 if (args[0]==NULL) {
1275 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
1380 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
1276 } else {
1381 } else {
1277 returnValue = *((QSize*)args[0]);
1382 returnValue = *((QSize*)args[0]);
1278 }
1383 }
1279 }
1384 }
1280 }
1385 }
1281 if (result) { Py_DECREF(result); }
1386 if (result) { Py_DECREF(result); }
1282 Py_DECREF(obj);
1387 Py_DECREF(obj);
1283 return returnValue;
1388 return returnValue;
1389 } else {
1390 PyErr_Clear();
1284 }
1391 }
1285 }
1392 }
1286 return MemSizeWdgt::sizeHint();
1393 return MemSizeWdgt::sizeHint();
1287 }
1394 }
1288 void PythonQtShell_MemSizeWdgt::tabletEvent(QTabletEvent* arg__1)
1395 void PythonQtShell_MemSizeWdgt::tabletEvent(QTabletEvent* arg__1)
1289 {
1396 {
1290 if (_wrapper) {
1397 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1291 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
1398 static PyObject* name = PyString_FromString("tabletEvent");
1292 PyErr_Clear();
1399 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1293 if (obj && !PythonQtSlotFunction_Check(obj)) {
1400 if (obj) {
1294 static const char* argumentList[] ={"" , "QTabletEvent*"};
1401 static const char* argumentList[] ={"" , "QTabletEvent*"};
1295 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1402 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1296 void* args[2] = {NULL, (void*)&arg__1};
1403 void* args[2] = {NULL, (void*)&arg__1};
1297 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1404 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1298 if (result) { Py_DECREF(result); }
1405 if (result) { Py_DECREF(result); }
1299 Py_DECREF(obj);
1406 Py_DECREF(obj);
1300 return;
1407 return;
1408 } else {
1409 PyErr_Clear();
1301 }
1410 }
1302 }
1411 }
1303 MemSizeWdgt::tabletEvent(arg__1);
1412 MemSizeWdgt::tabletEvent(arg__1);
1304 }
1413 }
1305 void PythonQtShell_MemSizeWdgt::timerEvent(QTimerEvent* arg__1)
1414 void PythonQtShell_MemSizeWdgt::timerEvent(QTimerEvent* arg__1)
1306 {
1415 {
1307 if (_wrapper) {
1416 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1308 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
1417 static PyObject* name = PyString_FromString("timerEvent");
1309 PyErr_Clear();
1418 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1310 if (obj && !PythonQtSlotFunction_Check(obj)) {
1419 if (obj) {
1311 static const char* argumentList[] ={"" , "QTimerEvent*"};
1420 static const char* argumentList[] ={"" , "QTimerEvent*"};
1312 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1421 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1313 void* args[2] = {NULL, (void*)&arg__1};
1422 void* args[2] = {NULL, (void*)&arg__1};
1314 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1423 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1315 if (result) { Py_DECREF(result); }
1424 if (result) { Py_DECREF(result); }
1316 Py_DECREF(obj);
1425 Py_DECREF(obj);
1317 return;
1426 return;
1427 } else {
1428 PyErr_Clear();
1318 }
1429 }
1319 }
1430 }
1320 MemSizeWdgt::timerEvent(arg__1);
1431 MemSizeWdgt::timerEvent(arg__1);
1321 }
1432 }
1322 void PythonQtShell_MemSizeWdgt::wheelEvent(QWheelEvent* arg__1)
1433 void PythonQtShell_MemSizeWdgt::wheelEvent(QWheelEvent* arg__1)
1323 {
1434 {
1324 if (_wrapper) {
1435 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1325 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
1436 static PyObject* name = PyString_FromString("wheelEvent");
1326 PyErr_Clear();
1437 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1327 if (obj && !PythonQtSlotFunction_Check(obj)) {
1438 if (obj) {
1328 static const char* argumentList[] ={"" , "QWheelEvent*"};
1439 static const char* argumentList[] ={"" , "QWheelEvent*"};
1329 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1440 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1330 void* args[2] = {NULL, (void*)&arg__1};
1441 void* args[2] = {NULL, (void*)&arg__1};
1331 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1442 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1332 if (result) { Py_DECREF(result); }
1443 if (result) { Py_DECREF(result); }
1333 Py_DECREF(obj);
1444 Py_DECREF(obj);
1334 return;
1445 return;
1446 } else {
1447 PyErr_Clear();
1335 }
1448 }
1336 }
1449 }
1337 MemSizeWdgt::wheelEvent(arg__1);
1450 MemSizeWdgt::wheelEvent(arg__1);
1338 }
1451 }
1339 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(QWidget* parent)
1452 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(QWidget* parent)
1340 {
1453 {
1341 return new PythonQtShell_MemSizeWdgt(parent); }
1454 return new PythonQtShell_MemSizeWdgt(parent); }
1342
1455
1343 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(int defaultSize, QWidget* parent)
1456 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(int defaultSize, QWidget* parent)
1344 {
1457 {
1345 return new PythonQtShell_MemSizeWdgt(defaultSize, parent); }
1458 return new PythonQtShell_MemSizeWdgt(defaultSize, parent); }
1346
1459
1347 int PythonQtWrapper_MemSizeWdgt::getsize(MemSizeWdgt* theWrappedObject)
1460 int PythonQtWrapper_MemSizeWdgt::getsize(MemSizeWdgt* theWrappedObject)
1348 {
1461 {
1349 return ( theWrappedObject->getsize());
1462 return ( theWrappedObject->getsize());
1350 }
1463 }
1351
1464
1352 void PythonQtWrapper_MemSizeWdgt::setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max)
1465 void PythonQtWrapper_MemSizeWdgt::setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max)
1353 {
1466 {
1354 ( theWrappedObject->setMaximum(max));
1467 ( theWrappedObject->setMaximum(max));
1355 }
1468 }
1356
1469
1357 void PythonQtWrapper_MemSizeWdgt::show(MemSizeWdgt* theWrappedObject)
1470 void PythonQtWrapper_MemSizeWdgt::show(MemSizeWdgt* theWrappedObject)
1358 {
1471 {
1359 ( theWrappedObject->show());
1472 ( theWrappedObject->show());
1360 }
1473 }
1361
1474
1362 void PythonQtWrapper_MemSizeWdgt::updateSizeValue(MemSizeWdgt* theWrappedObject)
1475 void PythonQtWrapper_MemSizeWdgt::updateSizeValue(MemSizeWdgt* theWrappedObject)
1363 {
1476 {
1364 ( theWrappedObject->updateSizeValue());
1477 ( theWrappedObject->updateSizeValue());
1365 }
1478 }
1366
1479
1367
1480
1368
1481
1369 PythonQtShell_QHexEdit::~PythonQtShell_QHexEdit() {
1482 PythonQtShell_QHexEdit::~PythonQtShell_QHexEdit() {
1370 PythonQtPrivate* priv = PythonQt::priv();
1483 PythonQtPrivate* priv = PythonQt::priv();
1371 if (priv) { priv->shellClassDeleted(this); }
1484 if (priv) { priv->shellClassDeleted(this); }
1372 }
1485 }
1373 void PythonQtShell_QHexEdit::actionEvent(QActionEvent* arg__1)
1486 void PythonQtShell_QHexEdit::actionEvent(QActionEvent* arg__1)
1374 {
1487 {
1375 if (_wrapper) {
1488 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1376 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
1489 static PyObject* name = PyString_FromString("actionEvent");
1377 PyErr_Clear();
1490 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1378 if (obj && !PythonQtSlotFunction_Check(obj)) {
1491 if (obj) {
1379 static const char* argumentList[] ={"" , "QActionEvent*"};
1492 static const char* argumentList[] ={"" , "QActionEvent*"};
1380 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1493 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1381 void* args[2] = {NULL, (void*)&arg__1};
1494 void* args[2] = {NULL, (void*)&arg__1};
1382 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1495 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1383 if (result) { Py_DECREF(result); }
1496 if (result) { Py_DECREF(result); }
1384 Py_DECREF(obj);
1497 Py_DECREF(obj);
1385 return;
1498 return;
1499 } else {
1500 PyErr_Clear();
1386 }
1501 }
1387 }
1502 }
1388 QHexEdit::actionEvent(arg__1);
1503 QHexEdit::actionEvent(arg__1);
1389 }
1504 }
1390 void PythonQtShell_QHexEdit::changeEvent(QEvent* arg__1)
1505 void PythonQtShell_QHexEdit::changeEvent(QEvent* arg__1)
1391 {
1506 {
1392 if (_wrapper) {
1507 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1393 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
1508 static PyObject* name = PyString_FromString("changeEvent");
1394 PyErr_Clear();
1509 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1395 if (obj && !PythonQtSlotFunction_Check(obj)) {
1510 if (obj) {
1396 static const char* argumentList[] ={"" , "QEvent*"};
1511 static const char* argumentList[] ={"" , "QEvent*"};
1397 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1512 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1398 void* args[2] = {NULL, (void*)&arg__1};
1513 void* args[2] = {NULL, (void*)&arg__1};
1399 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1514 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1400 if (result) { Py_DECREF(result); }
1515 if (result) { Py_DECREF(result); }
1401 Py_DECREF(obj);
1516 Py_DECREF(obj);
1402 return;
1517 return;
1518 } else {
1519 PyErr_Clear();
1403 }
1520 }
1404 }
1521 }
1405 QHexEdit::changeEvent(arg__1);
1522 QHexEdit::changeEvent(arg__1);
1406 }
1523 }
1407 void PythonQtShell_QHexEdit::childEvent(QChildEvent* arg__1)
1524 void PythonQtShell_QHexEdit::childEvent(QChildEvent* arg__1)
1408 {
1525 {
1409 if (_wrapper) {
1526 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1410 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
1527 static PyObject* name = PyString_FromString("childEvent");
1411 PyErr_Clear();
1528 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1412 if (obj && !PythonQtSlotFunction_Check(obj)) {
1529 if (obj) {
1413 static const char* argumentList[] ={"" , "QChildEvent*"};
1530 static const char* argumentList[] ={"" , "QChildEvent*"};
1414 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1531 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1415 void* args[2] = {NULL, (void*)&arg__1};
1532 void* args[2] = {NULL, (void*)&arg__1};
1416 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1533 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1417 if (result) { Py_DECREF(result); }
1534 if (result) { Py_DECREF(result); }
1418 Py_DECREF(obj);
1535 Py_DECREF(obj);
1419 return;
1536 return;
1537 } else {
1538 PyErr_Clear();
1420 }
1539 }
1421 }
1540 }
1422 QHexEdit::childEvent(arg__1);
1541 QHexEdit::childEvent(arg__1);
1423 }
1542 }
1424 void PythonQtShell_QHexEdit::closeEvent(QCloseEvent* arg__1)
1543 void PythonQtShell_QHexEdit::closeEvent(QCloseEvent* arg__1)
1425 {
1544 {
1426 if (_wrapper) {
1545 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1427 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
1546 static PyObject* name = PyString_FromString("closeEvent");
1428 PyErr_Clear();
1547 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1429 if (obj && !PythonQtSlotFunction_Check(obj)) {
1548 if (obj) {
1430 static const char* argumentList[] ={"" , "QCloseEvent*"};
1549 static const char* argumentList[] ={"" , "QCloseEvent*"};
1431 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1550 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1432 void* args[2] = {NULL, (void*)&arg__1};
1551 void* args[2] = {NULL, (void*)&arg__1};
1433 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1552 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1434 if (result) { Py_DECREF(result); }
1553 if (result) { Py_DECREF(result); }
1435 Py_DECREF(obj);
1554 Py_DECREF(obj);
1436 return;
1555 return;
1556 } else {
1557 PyErr_Clear();
1437 }
1558 }
1438 }
1559 }
1439 QHexEdit::closeEvent(arg__1);
1560 QHexEdit::closeEvent(arg__1);
1440 }
1561 }
1441 void PythonQtShell_QHexEdit::contextMenuEvent(QContextMenuEvent* arg__1)
1562 void PythonQtShell_QHexEdit::contextMenuEvent(QContextMenuEvent* arg__1)
1442 {
1563 {
1443 if (_wrapper) {
1564 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1444 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
1565 static PyObject* name = PyString_FromString("contextMenuEvent");
1445 PyErr_Clear();
1566 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1446 if (obj && !PythonQtSlotFunction_Check(obj)) {
1567 if (obj) {
1447 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
1568 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
1448 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1569 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1449 void* args[2] = {NULL, (void*)&arg__1};
1570 void* args[2] = {NULL, (void*)&arg__1};
1450 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1571 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1451 if (result) { Py_DECREF(result); }
1572 if (result) { Py_DECREF(result); }
1452 Py_DECREF(obj);
1573 Py_DECREF(obj);
1453 return;
1574 return;
1575 } else {
1576 PyErr_Clear();
1454 }
1577 }
1455 }
1578 }
1456 QHexEdit::contextMenuEvent(arg__1);
1579 QHexEdit::contextMenuEvent(arg__1);
1457 }
1580 }
1458 void PythonQtShell_QHexEdit::customEvent(QEvent* arg__1)
1581 void PythonQtShell_QHexEdit::customEvent(QEvent* arg__1)
1459 {
1582 {
1460 if (_wrapper) {
1583 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1461 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
1584 static PyObject* name = PyString_FromString("customEvent");
1462 PyErr_Clear();
1585 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1463 if (obj && !PythonQtSlotFunction_Check(obj)) {
1586 if (obj) {
1464 static const char* argumentList[] ={"" , "QEvent*"};
1587 static const char* argumentList[] ={"" , "QEvent*"};
1465 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1588 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1466 void* args[2] = {NULL, (void*)&arg__1};
1589 void* args[2] = {NULL, (void*)&arg__1};
1467 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1590 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1468 if (result) { Py_DECREF(result); }
1591 if (result) { Py_DECREF(result); }
1469 Py_DECREF(obj);
1592 Py_DECREF(obj);
1470 return;
1593 return;
1594 } else {
1595 PyErr_Clear();
1471 }
1596 }
1472 }
1597 }
1473 QHexEdit::customEvent(arg__1);
1598 QHexEdit::customEvent(arg__1);
1474 }
1599 }
1475 int PythonQtShell_QHexEdit::devType() const
1600 int PythonQtShell_QHexEdit::devType() const
1476 {
1601 {
1477 if (_wrapper) {
1602 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1478 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
1603 static PyObject* name = PyString_FromString("devType");
1479 PyErr_Clear();
1604 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1480 if (obj && !PythonQtSlotFunction_Check(obj)) {
1605 if (obj) {
1481 static const char* argumentList[] ={"int"};
1606 static const char* argumentList[] ={"int"};
1482 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1607 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1483 int returnValue;
1608 int returnValue;
1484 void* args[1] = {NULL};
1609 void* args[1] = {NULL};
1485 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1610 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1486 if (result) {
1611 if (result) {
1487 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);
1488 if (args[0]!=&returnValue) {
1613 if (args[0]!=&returnValue) {
1489 if (args[0]==NULL) {
1614 if (args[0]==NULL) {
1490 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
1615 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
1491 } else {
1616 } else {
1492 returnValue = *((int*)args[0]);
1617 returnValue = *((int*)args[0]);
1493 }
1618 }
1494 }
1619 }
1495 }
1620 }
1496 if (result) { Py_DECREF(result); }
1621 if (result) { Py_DECREF(result); }
1497 Py_DECREF(obj);
1622 Py_DECREF(obj);
1498 return returnValue;
1623 return returnValue;
1624 } else {
1625 PyErr_Clear();
1499 }
1626 }
1500 }
1627 }
1501 return QHexEdit::devType();
1628 return QHexEdit::devType();
1502 }
1629 }
1503 void PythonQtShell_QHexEdit::dragEnterEvent(QDragEnterEvent* arg__1)
1630 void PythonQtShell_QHexEdit::dragEnterEvent(QDragEnterEvent* arg__1)
1504 {
1631 {
1505 if (_wrapper) {
1632 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1506 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
1633 static PyObject* name = PyString_FromString("dragEnterEvent");
1507 PyErr_Clear();
1634 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1508 if (obj && !PythonQtSlotFunction_Check(obj)) {
1635 if (obj) {
1509 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
1636 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
1510 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1637 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1511 void* args[2] = {NULL, (void*)&arg__1};
1638 void* args[2] = {NULL, (void*)&arg__1};
1512 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1639 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1513 if (result) { Py_DECREF(result); }
1640 if (result) { Py_DECREF(result); }
1514 Py_DECREF(obj);
1641 Py_DECREF(obj);
1515 return;
1642 return;
1643 } else {
1644 PyErr_Clear();
1516 }
1645 }
1517 }
1646 }
1518 QHexEdit::dragEnterEvent(arg__1);
1647 QHexEdit::dragEnterEvent(arg__1);
1519 }
1648 }
1520 void PythonQtShell_QHexEdit::dragLeaveEvent(QDragLeaveEvent* arg__1)
1649 void PythonQtShell_QHexEdit::dragLeaveEvent(QDragLeaveEvent* arg__1)
1521 {
1650 {
1522 if (_wrapper) {
1651 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1523 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
1652 static PyObject* name = PyString_FromString("dragLeaveEvent");
1524 PyErr_Clear();
1653 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1525 if (obj && !PythonQtSlotFunction_Check(obj)) {
1654 if (obj) {
1526 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
1655 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
1527 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1656 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1528 void* args[2] = {NULL, (void*)&arg__1};
1657 void* args[2] = {NULL, (void*)&arg__1};
1529 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1658 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1530 if (result) { Py_DECREF(result); }
1659 if (result) { Py_DECREF(result); }
1531 Py_DECREF(obj);
1660 Py_DECREF(obj);
1532 return;
1661 return;
1662 } else {
1663 PyErr_Clear();
1533 }
1664 }
1534 }
1665 }
1535 QHexEdit::dragLeaveEvent(arg__1);
1666 QHexEdit::dragLeaveEvent(arg__1);
1536 }
1667 }
1537 void PythonQtShell_QHexEdit::dragMoveEvent(QDragMoveEvent* arg__1)
1668 void PythonQtShell_QHexEdit::dragMoveEvent(QDragMoveEvent* arg__1)
1538 {
1669 {
1539 if (_wrapper) {
1670 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1540 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
1671 static PyObject* name = PyString_FromString("dragMoveEvent");
1541 PyErr_Clear();
1672 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1542 if (obj && !PythonQtSlotFunction_Check(obj)) {
1673 if (obj) {
1543 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
1674 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
1544 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1675 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1545 void* args[2] = {NULL, (void*)&arg__1};
1676 void* args[2] = {NULL, (void*)&arg__1};
1546 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1677 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1547 if (result) { Py_DECREF(result); }
1678 if (result) { Py_DECREF(result); }
1548 Py_DECREF(obj);
1679 Py_DECREF(obj);
1549 return;
1680 return;
1681 } else {
1682 PyErr_Clear();
1550 }
1683 }
1551 }
1684 }
1552 QHexEdit::dragMoveEvent(arg__1);
1685 QHexEdit::dragMoveEvent(arg__1);
1553 }
1686 }
1554 void PythonQtShell_QHexEdit::dropEvent(QDropEvent* arg__1)
1687 void PythonQtShell_QHexEdit::dropEvent(QDropEvent* arg__1)
1555 {
1688 {
1556 if (_wrapper) {
1689 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1557 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
1690 static PyObject* name = PyString_FromString("dropEvent");
1558 PyErr_Clear();
1691 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1559 if (obj && !PythonQtSlotFunction_Check(obj)) {
1692 if (obj) {
1560 static const char* argumentList[] ={"" , "QDropEvent*"};
1693 static const char* argumentList[] ={"" , "QDropEvent*"};
1561 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1694 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1562 void* args[2] = {NULL, (void*)&arg__1};
1695 void* args[2] = {NULL, (void*)&arg__1};
1563 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1696 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1564 if (result) { Py_DECREF(result); }
1697 if (result) { Py_DECREF(result); }
1565 Py_DECREF(obj);
1698 Py_DECREF(obj);
1566 return;
1699 return;
1700 } else {
1701 PyErr_Clear();
1567 }
1702 }
1568 }
1703 }
1569 QHexEdit::dropEvent(arg__1);
1704 QHexEdit::dropEvent(arg__1);
1570 }
1705 }
1571 void PythonQtShell_QHexEdit::enterEvent(QEvent* arg__1)
1706 void PythonQtShell_QHexEdit::enterEvent(QEvent* arg__1)
1572 {
1707 {
1573 if (_wrapper) {
1708 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1574 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
1709 static PyObject* name = PyString_FromString("enterEvent");
1575 PyErr_Clear();
1710 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1576 if (obj && !PythonQtSlotFunction_Check(obj)) {
1711 if (obj) {
1577 static const char* argumentList[] ={"" , "QEvent*"};
1712 static const char* argumentList[] ={"" , "QEvent*"};
1578 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1713 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1579 void* args[2] = {NULL, (void*)&arg__1};
1714 void* args[2] = {NULL, (void*)&arg__1};
1580 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1715 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1581 if (result) { Py_DECREF(result); }
1716 if (result) { Py_DECREF(result); }
1582 Py_DECREF(obj);
1717 Py_DECREF(obj);
1583 return;
1718 return;
1719 } else {
1720 PyErr_Clear();
1584 }
1721 }
1585 }
1722 }
1586 QHexEdit::enterEvent(arg__1);
1723 QHexEdit::enterEvent(arg__1);
1587 }
1724 }
1588 bool PythonQtShell_QHexEdit::event(QEvent* arg__1)
1725 bool PythonQtShell_QHexEdit::event(QEvent* arg__1)
1589 {
1726 {
1590 if (_wrapper) {
1727 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1591 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
1728 static PyObject* name = PyString_FromString("event");
1592 PyErr_Clear();
1729 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1593 if (obj && !PythonQtSlotFunction_Check(obj)) {
1730 if (obj) {
1594 static const char* argumentList[] ={"bool" , "QEvent*"};
1731 static const char* argumentList[] ={"bool" , "QEvent*"};
1595 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1732 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1596 bool returnValue;
1733 bool returnValue;
1597 void* args[2] = {NULL, (void*)&arg__1};
1734 void* args[2] = {NULL, (void*)&arg__1};
1598 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1735 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1599 if (result) {
1736 if (result) {
1600 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1737 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1601 if (args[0]!=&returnValue) {
1738 if (args[0]!=&returnValue) {
1602 if (args[0]==NULL) {
1739 if (args[0]==NULL) {
1603 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
1740 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
1604 } else {
1741 } else {
1605 returnValue = *((bool*)args[0]);
1742 returnValue = *((bool*)args[0]);
1606 }
1743 }
1607 }
1744 }
1608 }
1745 }
1609 if (result) { Py_DECREF(result); }
1746 if (result) { Py_DECREF(result); }
1610 Py_DECREF(obj);
1747 Py_DECREF(obj);
1611 return returnValue;
1748 return returnValue;
1749 } else {
1750 PyErr_Clear();
1612 }
1751 }
1613 }
1752 }
1614 return QHexEdit::event(arg__1);
1753 return QHexEdit::event(arg__1);
1615 }
1754 }
1616 bool PythonQtShell_QHexEdit::eventFilter(QObject* arg__1, QEvent* arg__2)
1755 bool PythonQtShell_QHexEdit::eventFilter(QObject* arg__1, QEvent* arg__2)
1617 {
1756 {
1618 if (_wrapper) {
1757 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1619 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
1758 static PyObject* name = PyString_FromString("eventFilter");
1620 PyErr_Clear();
1759 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1621 if (obj && !PythonQtSlotFunction_Check(obj)) {
1760 if (obj) {
1622 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
1761 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
1623 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
1762 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
1624 bool returnValue;
1763 bool returnValue;
1625 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
1764 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
1626 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1765 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1627 if (result) {
1766 if (result) {
1628 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1767 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1629 if (args[0]!=&returnValue) {
1768 if (args[0]!=&returnValue) {
1630 if (args[0]==NULL) {
1769 if (args[0]==NULL) {
1631 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
1770 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
1632 } else {
1771 } else {
1633 returnValue = *((bool*)args[0]);
1772 returnValue = *((bool*)args[0]);
1634 }
1773 }
1635 }
1774 }
1636 }
1775 }
1637 if (result) { Py_DECREF(result); }
1776 if (result) { Py_DECREF(result); }
1638 Py_DECREF(obj);
1777 Py_DECREF(obj);
1639 return returnValue;
1778 return returnValue;
1779 } else {
1780 PyErr_Clear();
1640 }
1781 }
1641 }
1782 }
1642 return QHexEdit::eventFilter(arg__1, arg__2);
1783 return QHexEdit::eventFilter(arg__1, arg__2);
1643 }
1784 }
1644 void PythonQtShell_QHexEdit::focusInEvent(QFocusEvent* arg__1)
1785 void PythonQtShell_QHexEdit::focusInEvent(QFocusEvent* arg__1)
1645 {
1786 {
1646 if (_wrapper) {
1787 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1647 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
1788 static PyObject* name = PyString_FromString("focusInEvent");
1648 PyErr_Clear();
1789 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1649 if (obj && !PythonQtSlotFunction_Check(obj)) {
1790 if (obj) {
1650 static const char* argumentList[] ={"" , "QFocusEvent*"};
1791 static const char* argumentList[] ={"" , "QFocusEvent*"};
1651 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1792 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1652 void* args[2] = {NULL, (void*)&arg__1};
1793 void* args[2] = {NULL, (void*)&arg__1};
1653 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1794 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1654 if (result) { Py_DECREF(result); }
1795 if (result) { Py_DECREF(result); }
1655 Py_DECREF(obj);
1796 Py_DECREF(obj);
1656 return;
1797 return;
1798 } else {
1799 PyErr_Clear();
1657 }
1800 }
1658 }
1801 }
1659 QHexEdit::focusInEvent(arg__1);
1802 QHexEdit::focusInEvent(arg__1);
1660 }
1803 }
1661 bool PythonQtShell_QHexEdit::focusNextPrevChild(bool next)
1804 bool PythonQtShell_QHexEdit::focusNextPrevChild(bool next0)
1662 {
1805 {
1663 if (_wrapper) {
1806 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1664 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
1807 static PyObject* name = PyString_FromString("focusNextPrevChild");
1665 PyErr_Clear();
1808 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1666 if (obj && !PythonQtSlotFunction_Check(obj)) {
1809 if (obj) {
1667 static const char* argumentList[] ={"bool" , "bool"};
1810 static const char* argumentList[] ={"bool" , "bool"};
1668 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1811 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1669 bool returnValue;
1812 bool returnValue;
1670 void* args[2] = {NULL, (void*)&next};
1813 void* args[2] = {NULL, (void*)&next0};
1671 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1814 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1672 if (result) {
1815 if (result) {
1673 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1816 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1674 if (args[0]!=&returnValue) {
1817 if (args[0]!=&returnValue) {
1675 if (args[0]==NULL) {
1818 if (args[0]==NULL) {
1676 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
1819 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
1677 } else {
1820 } else {
1678 returnValue = *((bool*)args[0]);
1821 returnValue = *((bool*)args[0]);
1679 }
1822 }
1680 }
1823 }
1681 }
1824 }
1682 if (result) { Py_DECREF(result); }
1825 if (result) { Py_DECREF(result); }
1683 Py_DECREF(obj);
1826 Py_DECREF(obj);
1684 return returnValue;
1827 return returnValue;
1685 }
1828 } else {
1686 }
1829 PyErr_Clear();
1687 return QHexEdit::focusNextPrevChild(next);
1830 }
1831 }
1832 return QHexEdit::focusNextPrevChild(next0);
1688 }
1833 }
1689 void PythonQtShell_QHexEdit::focusOutEvent(QFocusEvent* arg__1)
1834 void PythonQtShell_QHexEdit::focusOutEvent(QFocusEvent* arg__1)
1690 {
1835 {
1691 if (_wrapper) {
1836 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1692 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
1837 static PyObject* name = PyString_FromString("focusOutEvent");
1693 PyErr_Clear();
1838 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1694 if (obj && !PythonQtSlotFunction_Check(obj)) {
1839 if (obj) {
1695 static const char* argumentList[] ={"" , "QFocusEvent*"};
1840 static const char* argumentList[] ={"" , "QFocusEvent*"};
1696 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1841 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1697 void* args[2] = {NULL, (void*)&arg__1};
1842 void* args[2] = {NULL, (void*)&arg__1};
1698 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1843 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1699 if (result) { Py_DECREF(result); }
1844 if (result) { Py_DECREF(result); }
1700 Py_DECREF(obj);
1845 Py_DECREF(obj);
1701 return;
1846 return;
1847 } else {
1848 PyErr_Clear();
1702 }
1849 }
1703 }
1850 }
1704 QHexEdit::focusOutEvent(arg__1);
1851 QHexEdit::focusOutEvent(arg__1);
1705 }
1852 }
1706 bool PythonQtShell_QHexEdit::hasHeightForWidth() const
1853 bool PythonQtShell_QHexEdit::hasHeightForWidth() const
1707 {
1854 {
1708 if (_wrapper) {
1855 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1709 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
1856 static PyObject* name = PyString_FromString("hasHeightForWidth");
1710 PyErr_Clear();
1857 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1711 if (obj && !PythonQtSlotFunction_Check(obj)) {
1858 if (obj) {
1712 static const char* argumentList[] ={"bool"};
1859 static const char* argumentList[] ={"bool"};
1713 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1860 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1714 bool returnValue;
1861 bool returnValue;
1715 void* args[1] = {NULL};
1862 void* args[1] = {NULL};
1716 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1863 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1717 if (result) {
1864 if (result) {
1718 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1865 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1719 if (args[0]!=&returnValue) {
1866 if (args[0]!=&returnValue) {
1720 if (args[0]==NULL) {
1867 if (args[0]==NULL) {
1721 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
1868 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
1722 } else {
1869 } else {
1723 returnValue = *((bool*)args[0]);
1870 returnValue = *((bool*)args[0]);
1724 }
1871 }
1725 }
1872 }
1726 }
1873 }
1727 if (result) { Py_DECREF(result); }
1874 if (result) { Py_DECREF(result); }
1728 Py_DECREF(obj);
1875 Py_DECREF(obj);
1729 return returnValue;
1876 return returnValue;
1877 } else {
1878 PyErr_Clear();
1730 }
1879 }
1731 }
1880 }
1732 return QHexEdit::hasHeightForWidth();
1881 return QHexEdit::hasHeightForWidth();
1733 }
1882 }
1734 int PythonQtShell_QHexEdit::heightForWidth(int arg__1) const
1883 int PythonQtShell_QHexEdit::heightForWidth(int arg__1) const
1735 {
1884 {
1736 if (_wrapper) {
1885 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1737 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
1886 static PyObject* name = PyString_FromString("heightForWidth");
1738 PyErr_Clear();
1887 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1739 if (obj && !PythonQtSlotFunction_Check(obj)) {
1888 if (obj) {
1740 static const char* argumentList[] ={"int" , "int"};
1889 static const char* argumentList[] ={"int" , "int"};
1741 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1890 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1742 int returnValue;
1891 int returnValue;
1743 void* args[2] = {NULL, (void*)&arg__1};
1892 void* args[2] = {NULL, (void*)&arg__1};
1744 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1893 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1745 if (result) {
1894 if (result) {
1746 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1895 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1747 if (args[0]!=&returnValue) {
1896 if (args[0]!=&returnValue) {
1748 if (args[0]==NULL) {
1897 if (args[0]==NULL) {
1749 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
1898 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
1750 } else {
1899 } else {
1751 returnValue = *((int*)args[0]);
1900 returnValue = *((int*)args[0]);
1752 }
1901 }
1753 }
1902 }
1754 }
1903 }
1755 if (result) { Py_DECREF(result); }
1904 if (result) { Py_DECREF(result); }
1756 Py_DECREF(obj);
1905 Py_DECREF(obj);
1757 return returnValue;
1906 return returnValue;
1907 } else {
1908 PyErr_Clear();
1758 }
1909 }
1759 }
1910 }
1760 return QHexEdit::heightForWidth(arg__1);
1911 return QHexEdit::heightForWidth(arg__1);
1761 }
1912 }
1762 void PythonQtShell_QHexEdit::hideEvent(QHideEvent* arg__1)
1913 void PythonQtShell_QHexEdit::hideEvent(QHideEvent* arg__1)
1763 {
1914 {
1764 if (_wrapper) {
1915 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1765 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
1916 static PyObject* name = PyString_FromString("hideEvent");
1766 PyErr_Clear();
1917 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1767 if (obj && !PythonQtSlotFunction_Check(obj)) {
1918 if (obj) {
1768 static const char* argumentList[] ={"" , "QHideEvent*"};
1919 static const char* argumentList[] ={"" , "QHideEvent*"};
1769 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1920 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1770 void* args[2] = {NULL, (void*)&arg__1};
1921 void* args[2] = {NULL, (void*)&arg__1};
1771 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1922 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1772 if (result) { Py_DECREF(result); }
1923 if (result) { Py_DECREF(result); }
1773 Py_DECREF(obj);
1924 Py_DECREF(obj);
1774 return;
1925 return;
1926 } else {
1927 PyErr_Clear();
1775 }
1928 }
1776 }
1929 }
1777 QHexEdit::hideEvent(arg__1);
1930 QHexEdit::hideEvent(arg__1);
1778 }
1931 }
1779 void PythonQtShell_QHexEdit::initPainter(QPainter* painter) const
1932 void PythonQtShell_QHexEdit::initPainter(QPainter* painter0) const
1780 {
1933 {
1781 if (_wrapper) {
1934 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1782 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
1935 static PyObject* name = PyString_FromString("initPainter");
1783 PyErr_Clear();
1936 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1784 if (obj && !PythonQtSlotFunction_Check(obj)) {
1937 if (obj) {
1785 static const char* argumentList[] ={"" , "QPainter*"};
1938 static const char* argumentList[] ={"" , "QPainter*"};
1786 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1939 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1787 void* args[2] = {NULL, (void*)&painter};
1940 void* args[2] = {NULL, (void*)&painter0};
1788 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1941 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1789 if (result) { Py_DECREF(result); }
1942 if (result) { Py_DECREF(result); }
1790 Py_DECREF(obj);
1943 Py_DECREF(obj);
1791 return;
1944 return;
1792 }
1945 } else {
1793 }
1946 PyErr_Clear();
1794 QHexEdit::initPainter(painter);
1947 }
1948 }
1949 QHexEdit::initPainter(painter0);
1795 }
1950 }
1796 void PythonQtShell_QHexEdit::inputMethodEvent(QInputMethodEvent* arg__1)
1951 void PythonQtShell_QHexEdit::inputMethodEvent(QInputMethodEvent* arg__1)
1797 {
1952 {
1798 if (_wrapper) {
1953 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1799 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
1954 static PyObject* name = PyString_FromString("inputMethodEvent");
1800 PyErr_Clear();
1955 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1801 if (obj && !PythonQtSlotFunction_Check(obj)) {
1956 if (obj) {
1802 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
1957 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
1803 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1958 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1804 void* args[2] = {NULL, (void*)&arg__1};
1959 void* args[2] = {NULL, (void*)&arg__1};
1805 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1960 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1806 if (result) { Py_DECREF(result); }
1961 if (result) { Py_DECREF(result); }
1807 Py_DECREF(obj);
1962 Py_DECREF(obj);
1808 return;
1963 return;
1964 } else {
1965 PyErr_Clear();
1809 }
1966 }
1810 }
1967 }
1811 QHexEdit::inputMethodEvent(arg__1);
1968 QHexEdit::inputMethodEvent(arg__1);
1812 }
1969 }
1813 QVariant PythonQtShell_QHexEdit::inputMethodQuery(Qt::InputMethodQuery arg__1) const
1970 QVariant PythonQtShell_QHexEdit::inputMethodQuery(Qt::InputMethodQuery arg__1) const
1814 {
1971 {
1815 if (_wrapper) {
1972 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1816 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
1973 static PyObject* name = PyString_FromString("inputMethodQuery");
1817 PyErr_Clear();
1974 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1818 if (obj && !PythonQtSlotFunction_Check(obj)) {
1975 if (obj) {
1819 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
1976 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
1820 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1977 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1821 QVariant returnValue;
1978 QVariant returnValue;
1822 void* args[2] = {NULL, (void*)&arg__1};
1979 void* args[2] = {NULL, (void*)&arg__1};
1823 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1980 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1824 if (result) {
1981 if (result) {
1825 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1982 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1826 if (args[0]!=&returnValue) {
1983 if (args[0]!=&returnValue) {
1827 if (args[0]==NULL) {
1984 if (args[0]==NULL) {
1828 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
1985 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
1829 } else {
1986 } else {
1830 returnValue = *((QVariant*)args[0]);
1987 returnValue = *((QVariant*)args[0]);
1831 }
1988 }
1832 }
1989 }
1833 }
1990 }
1834 if (result) { Py_DECREF(result); }
1991 if (result) { Py_DECREF(result); }
1835 Py_DECREF(obj);
1992 Py_DECREF(obj);
1836 return returnValue;
1993 return returnValue;
1994 } else {
1995 PyErr_Clear();
1837 }
1996 }
1838 }
1997 }
1839 return QHexEdit::inputMethodQuery(arg__1);
1998 return QHexEdit::inputMethodQuery(arg__1);
1840 }
1999 }
1841 void PythonQtShell_QHexEdit::keyPressEvent(QKeyEvent* arg__1)
2000 void PythonQtShell_QHexEdit::keyPressEvent(QKeyEvent* arg__1)
1842 {
2001 {
1843 if (_wrapper) {
2002 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1844 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
2003 static PyObject* name = PyString_FromString("keyPressEvent");
1845 PyErr_Clear();
2004 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1846 if (obj && !PythonQtSlotFunction_Check(obj)) {
2005 if (obj) {
1847 static const char* argumentList[] ={"" , "QKeyEvent*"};
2006 static const char* argumentList[] ={"" , "QKeyEvent*"};
1848 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2007 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1849 void* args[2] = {NULL, (void*)&arg__1};
2008 void* args[2] = {NULL, (void*)&arg__1};
1850 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2009 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1851 if (result) { Py_DECREF(result); }
2010 if (result) { Py_DECREF(result); }
1852 Py_DECREF(obj);
2011 Py_DECREF(obj);
1853 return;
2012 return;
2013 } else {
2014 PyErr_Clear();
1854 }
2015 }
1855 }
2016 }
1856 QHexEdit::keyPressEvent(arg__1);
2017 QHexEdit::keyPressEvent(arg__1);
1857 }
2018 }
1858 void PythonQtShell_QHexEdit::keyReleaseEvent(QKeyEvent* arg__1)
2019 void PythonQtShell_QHexEdit::keyReleaseEvent(QKeyEvent* arg__1)
1859 {
2020 {
1860 if (_wrapper) {
2021 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1861 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
2022 static PyObject* name = PyString_FromString("keyReleaseEvent");
1862 PyErr_Clear();
2023 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1863 if (obj && !PythonQtSlotFunction_Check(obj)) {
2024 if (obj) {
1864 static const char* argumentList[] ={"" , "QKeyEvent*"};
2025 static const char* argumentList[] ={"" , "QKeyEvent*"};
1865 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2026 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1866 void* args[2] = {NULL, (void*)&arg__1};
2027 void* args[2] = {NULL, (void*)&arg__1};
1867 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2028 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1868 if (result) { Py_DECREF(result); }
2029 if (result) { Py_DECREF(result); }
1869 Py_DECREF(obj);
2030 Py_DECREF(obj);
1870 return;
2031 return;
2032 } else {
2033 PyErr_Clear();
1871 }
2034 }
1872 }
2035 }
1873 QHexEdit::keyReleaseEvent(arg__1);
2036 QHexEdit::keyReleaseEvent(arg__1);
1874 }
2037 }
1875 void PythonQtShell_QHexEdit::leaveEvent(QEvent* arg__1)
2038 void PythonQtShell_QHexEdit::leaveEvent(QEvent* arg__1)
1876 {
2039 {
1877 if (_wrapper) {
2040 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1878 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
2041 static PyObject* name = PyString_FromString("leaveEvent");
1879 PyErr_Clear();
2042 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1880 if (obj && !PythonQtSlotFunction_Check(obj)) {
2043 if (obj) {
1881 static const char* argumentList[] ={"" , "QEvent*"};
2044 static const char* argumentList[] ={"" , "QEvent*"};
1882 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2045 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1883 void* args[2] = {NULL, (void*)&arg__1};
2046 void* args[2] = {NULL, (void*)&arg__1};
1884 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2047 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1885 if (result) { Py_DECREF(result); }
2048 if (result) { Py_DECREF(result); }
1886 Py_DECREF(obj);
2049 Py_DECREF(obj);
1887 return;
2050 return;
2051 } else {
2052 PyErr_Clear();
1888 }
2053 }
1889 }
2054 }
1890 QHexEdit::leaveEvent(arg__1);
2055 QHexEdit::leaveEvent(arg__1);
1891 }
2056 }
1892 int PythonQtShell_QHexEdit::metric(QPaintDevice::PaintDeviceMetric arg__1) const
2057 int PythonQtShell_QHexEdit::metric(QPaintDevice::PaintDeviceMetric arg__1) const
1893 {
2058 {
1894 if (_wrapper) {
2059 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1895 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
2060 static PyObject* name = PyString_FromString("metric");
1896 PyErr_Clear();
2061 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1897 if (obj && !PythonQtSlotFunction_Check(obj)) {
2062 if (obj) {
1898 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
2063 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
1899 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2064 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1900 int returnValue;
2065 int returnValue;
1901 void* args[2] = {NULL, (void*)&arg__1};
2066 void* args[2] = {NULL, (void*)&arg__1};
1902 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2067 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1903 if (result) {
2068 if (result) {
1904 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2069 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1905 if (args[0]!=&returnValue) {
2070 if (args[0]!=&returnValue) {
1906 if (args[0]==NULL) {
2071 if (args[0]==NULL) {
1907 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
2072 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
1908 } else {
2073 } else {
1909 returnValue = *((int*)args[0]);
2074 returnValue = *((int*)args[0]);
1910 }
2075 }
1911 }
2076 }
1912 }
2077 }
1913 if (result) { Py_DECREF(result); }
2078 if (result) { Py_DECREF(result); }
1914 Py_DECREF(obj);
2079 Py_DECREF(obj);
1915 return returnValue;
2080 return returnValue;
2081 } else {
2082 PyErr_Clear();
1916 }
2083 }
1917 }
2084 }
1918 return QHexEdit::metric(arg__1);
2085 return QHexEdit::metric(arg__1);
1919 }
2086 }
1920 void PythonQtShell_QHexEdit::mouseDoubleClickEvent(QMouseEvent* arg__1)
2087 void PythonQtShell_QHexEdit::mouseDoubleClickEvent(QMouseEvent* arg__1)
1921 {
2088 {
1922 if (_wrapper) {
2089 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1923 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
2090 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
1924 PyErr_Clear();
2091 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1925 if (obj && !PythonQtSlotFunction_Check(obj)) {
2092 if (obj) {
1926 static const char* argumentList[] ={"" , "QMouseEvent*"};
2093 static const char* argumentList[] ={"" , "QMouseEvent*"};
1927 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2094 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1928 void* args[2] = {NULL, (void*)&arg__1};
2095 void* args[2] = {NULL, (void*)&arg__1};
1929 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2096 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1930 if (result) { Py_DECREF(result); }
2097 if (result) { Py_DECREF(result); }
1931 Py_DECREF(obj);
2098 Py_DECREF(obj);
1932 return;
2099 return;
2100 } else {
2101 PyErr_Clear();
1933 }
2102 }
1934 }
2103 }
1935 QHexEdit::mouseDoubleClickEvent(arg__1);
2104 QHexEdit::mouseDoubleClickEvent(arg__1);
1936 }
2105 }
1937 void PythonQtShell_QHexEdit::mouseMoveEvent(QMouseEvent* arg__1)
2106 void PythonQtShell_QHexEdit::mouseMoveEvent(QMouseEvent* arg__1)
1938 {
2107 {
1939 if (_wrapper) {
2108 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1940 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
2109 static PyObject* name = PyString_FromString("mouseMoveEvent");
1941 PyErr_Clear();
2110 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1942 if (obj && !PythonQtSlotFunction_Check(obj)) {
2111 if (obj) {
1943 static const char* argumentList[] ={"" , "QMouseEvent*"};
2112 static const char* argumentList[] ={"" , "QMouseEvent*"};
1944 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2113 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1945 void* args[2] = {NULL, (void*)&arg__1};
2114 void* args[2] = {NULL, (void*)&arg__1};
1946 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2115 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1947 if (result) { Py_DECREF(result); }
2116 if (result) { Py_DECREF(result); }
1948 Py_DECREF(obj);
2117 Py_DECREF(obj);
1949 return;
2118 return;
2119 } else {
2120 PyErr_Clear();
1950 }
2121 }
1951 }
2122 }
1952 QHexEdit::mouseMoveEvent(arg__1);
2123 QHexEdit::mouseMoveEvent(arg__1);
1953 }
2124 }
1954 void PythonQtShell_QHexEdit::mousePressEvent(QMouseEvent* arg__1)
2125 void PythonQtShell_QHexEdit::mousePressEvent(QMouseEvent* arg__1)
1955 {
2126 {
1956 if (_wrapper) {
2127 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1957 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
2128 static PyObject* name = PyString_FromString("mousePressEvent");
1958 PyErr_Clear();
2129 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1959 if (obj && !PythonQtSlotFunction_Check(obj)) {
2130 if (obj) {
1960 static const char* argumentList[] ={"" , "QMouseEvent*"};
2131 static const char* argumentList[] ={"" , "QMouseEvent*"};
1961 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2132 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1962 void* args[2] = {NULL, (void*)&arg__1};
2133 void* args[2] = {NULL, (void*)&arg__1};
1963 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2134 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1964 if (result) { Py_DECREF(result); }
2135 if (result) { Py_DECREF(result); }
1965 Py_DECREF(obj);
2136 Py_DECREF(obj);
1966 return;
2137 return;
2138 } else {
2139 PyErr_Clear();
1967 }
2140 }
1968 }
2141 }
1969 QHexEdit::mousePressEvent(arg__1);
2142 QHexEdit::mousePressEvent(arg__1);
1970 }
2143 }
1971 void PythonQtShell_QHexEdit::mouseReleaseEvent(QMouseEvent* arg__1)
2144 void PythonQtShell_QHexEdit::mouseReleaseEvent(QMouseEvent* arg__1)
1972 {
2145 {
1973 if (_wrapper) {
2146 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1974 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
2147 static PyObject* name = PyString_FromString("mouseReleaseEvent");
1975 PyErr_Clear();
2148 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1976 if (obj && !PythonQtSlotFunction_Check(obj)) {
2149 if (obj) {
1977 static const char* argumentList[] ={"" , "QMouseEvent*"};
2150 static const char* argumentList[] ={"" , "QMouseEvent*"};
1978 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2151 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1979 void* args[2] = {NULL, (void*)&arg__1};
2152 void* args[2] = {NULL, (void*)&arg__1};
1980 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2153 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1981 if (result) { Py_DECREF(result); }
2154 if (result) { Py_DECREF(result); }
1982 Py_DECREF(obj);
2155 Py_DECREF(obj);
1983 return;
2156 return;
2157 } else {
2158 PyErr_Clear();
1984 }
2159 }
1985 }
2160 }
1986 QHexEdit::mouseReleaseEvent(arg__1);
2161 QHexEdit::mouseReleaseEvent(arg__1);
1987 }
2162 }
1988 void PythonQtShell_QHexEdit::moveEvent(QMoveEvent* arg__1)
2163 void PythonQtShell_QHexEdit::moveEvent(QMoveEvent* arg__1)
1989 {
2164 {
1990 if (_wrapper) {
2165 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1991 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
2166 static PyObject* name = PyString_FromString("moveEvent");
1992 PyErr_Clear();
2167 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1993 if (obj && !PythonQtSlotFunction_Check(obj)) {
2168 if (obj) {
1994 static const char* argumentList[] ={"" , "QMoveEvent*"};
2169 static const char* argumentList[] ={"" , "QMoveEvent*"};
1995 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2170 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1996 void* args[2] = {NULL, (void*)&arg__1};
2171 void* args[2] = {NULL, (void*)&arg__1};
1997 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2172 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1998 if (result) { Py_DECREF(result); }
2173 if (result) { Py_DECREF(result); }
1999 Py_DECREF(obj);
2174 Py_DECREF(obj);
2000 return;
2175 return;
2176 } else {
2177 PyErr_Clear();
2001 }
2178 }
2002 }
2179 }
2003 QHexEdit::moveEvent(arg__1);
2180 QHexEdit::moveEvent(arg__1);
2004 }
2181 }
2005 bool PythonQtShell_QHexEdit::nativeEvent(const QByteArray& eventType, void* message, long* result)
2182 bool PythonQtShell_QHexEdit::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
2006 {
2183 {
2007 if (_wrapper) {
2184 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2008 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
2185 static PyObject* name = PyString_FromString("nativeEvent");
2009 PyErr_Clear();
2186 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2010 if (obj && !PythonQtSlotFunction_Check(obj)) {
2187 if (obj) {
2011 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
2188 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
2012 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
2189 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
2013 bool returnValue;
2190 bool returnValue;
2014 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
2191 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
2015 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2192 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2016 if (result) {
2193 if (result) {
2017 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2194 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2018 if (args[0]!=&returnValue) {
2195 if (args[0]!=&returnValue) {
2019 if (args[0]==NULL) {
2196 if (args[0]==NULL) {
2020 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
2197 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
2021 } else {
2198 } else {
2022 returnValue = *((bool*)args[0]);
2199 returnValue = *((bool*)args[0]);
2023 }
2200 }
2024 }
2201 }
2025 }
2202 }
2026 if (result) { Py_DECREF(result); }
2203 if (result) { Py_DECREF(result); }
2027 Py_DECREF(obj);
2204 Py_DECREF(obj);
2028 return returnValue;
2205 return returnValue;
2029 }
2206 } else {
2030 }
2207 PyErr_Clear();
2031 return QHexEdit::nativeEvent(eventType, message, result);
2208 }
2209 }
2210 return QHexEdit::nativeEvent(eventType0, message1, result2);
2032 }
2211 }
2033 QPaintEngine* PythonQtShell_QHexEdit::paintEngine() const
2212 QPaintEngine* PythonQtShell_QHexEdit::paintEngine() const
2034 {
2213 {
2035 if (_wrapper) {
2214 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2036 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
2215 static PyObject* name = PyString_FromString("paintEngine");
2037 PyErr_Clear();
2216 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2038 if (obj && !PythonQtSlotFunction_Check(obj)) {
2217 if (obj) {
2039 static const char* argumentList[] ={"QPaintEngine*"};
2218 static const char* argumentList[] ={"QPaintEngine*"};
2040 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2219 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2041 QPaintEngine* returnValue;
2220 QPaintEngine* returnValue;
2042 void* args[1] = {NULL};
2221 void* args[1] = {NULL};
2043 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2222 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2044 if (result) {
2223 if (result) {
2045 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2224 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2046 if (args[0]!=&returnValue) {
2225 if (args[0]!=&returnValue) {
2047 if (args[0]==NULL) {
2226 if (args[0]==NULL) {
2048 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
2227 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
2049 } else {
2228 } else {
2050 returnValue = *((QPaintEngine**)args[0]);
2229 returnValue = *((QPaintEngine**)args[0]);
2051 }
2230 }
2052 }
2231 }
2053 }
2232 }
2054 if (result) { Py_DECREF(result); }
2233 if (result) { Py_DECREF(result); }
2055 Py_DECREF(obj);
2234 Py_DECREF(obj);
2056 return returnValue;
2235 return returnValue;
2236 } else {
2237 PyErr_Clear();
2057 }
2238 }
2058 }
2239 }
2059 return QHexEdit::paintEngine();
2240 return QHexEdit::paintEngine();
2060 }
2241 }
2061 void PythonQtShell_QHexEdit::paintEvent(QPaintEvent* arg__1)
2242 void PythonQtShell_QHexEdit::paintEvent(QPaintEvent* arg__1)
2062 {
2243 {
2063 if (_wrapper) {
2244 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2064 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
2245 static PyObject* name = PyString_FromString("paintEvent");
2065 PyErr_Clear();
2246 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2066 if (obj && !PythonQtSlotFunction_Check(obj)) {
2247 if (obj) {
2067 static const char* argumentList[] ={"" , "QPaintEvent*"};
2248 static const char* argumentList[] ={"" , "QPaintEvent*"};
2068 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2249 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2069 void* args[2] = {NULL, (void*)&arg__1};
2250 void* args[2] = {NULL, (void*)&arg__1};
2070 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2251 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2071 if (result) { Py_DECREF(result); }
2252 if (result) { Py_DECREF(result); }
2072 Py_DECREF(obj);
2253 Py_DECREF(obj);
2073 return;
2254 return;
2255 } else {
2256 PyErr_Clear();
2074 }
2257 }
2075 }
2258 }
2076 QHexEdit::paintEvent(arg__1);
2259 QHexEdit::paintEvent(arg__1);
2077 }
2260 }
2078 QPaintDevice* PythonQtShell_QHexEdit::redirected(QPoint* offset) const
2261 QPaintDevice* PythonQtShell_QHexEdit::redirected(QPoint* offset0) const
2079 {
2262 {
2080 if (_wrapper) {
2263 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2081 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
2264 static PyObject* name = PyString_FromString("redirected");
2082 PyErr_Clear();
2265 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2083 if (obj && !PythonQtSlotFunction_Check(obj)) {
2266 if (obj) {
2084 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
2267 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
2085 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2268 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2086 QPaintDevice* returnValue;
2269 QPaintDevice* returnValue;
2087 void* args[2] = {NULL, (void*)&offset};
2270 void* args[2] = {NULL, (void*)&offset0};
2088 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2271 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2089 if (result) {
2272 if (result) {
2090 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2273 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2091 if (args[0]!=&returnValue) {
2274 if (args[0]!=&returnValue) {
2092 if (args[0]==NULL) {
2275 if (args[0]==NULL) {
2093 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
2276 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
2094 } else {
2277 } else {
2095 returnValue = *((QPaintDevice**)args[0]);
2278 returnValue = *((QPaintDevice**)args[0]);
2096 }
2279 }
2097 }
2280 }
2098 }
2281 }
2099 if (result) { Py_DECREF(result); }
2282 if (result) { Py_DECREF(result); }
2100 Py_DECREF(obj);
2283 Py_DECREF(obj);
2101 return returnValue;
2284 return returnValue;
2102 }
2285 } else {
2103 }
2286 PyErr_Clear();
2104 return QHexEdit::redirected(offset);
2287 }
2288 }
2289 return QHexEdit::redirected(offset0);
2105 }
2290 }
2106 void PythonQtShell_QHexEdit::resizeEvent(QResizeEvent* arg__1)
2291 void PythonQtShell_QHexEdit::resizeEvent(QResizeEvent* arg__1)
2107 {
2292 {
2108 if (_wrapper) {
2293 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2109 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
2294 static PyObject* name = PyString_FromString("resizeEvent");
2110 PyErr_Clear();
2295 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2111 if (obj && !PythonQtSlotFunction_Check(obj)) {
2296 if (obj) {
2112 static const char* argumentList[] ={"" , "QResizeEvent*"};
2297 static const char* argumentList[] ={"" , "QResizeEvent*"};
2113 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2298 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2114 void* args[2] = {NULL, (void*)&arg__1};
2299 void* args[2] = {NULL, (void*)&arg__1};
2115 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2300 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2116 if (result) { Py_DECREF(result); }
2301 if (result) { Py_DECREF(result); }
2117 Py_DECREF(obj);
2302 Py_DECREF(obj);
2118 return;
2303 return;
2304 } else {
2305 PyErr_Clear();
2119 }
2306 }
2120 }
2307 }
2121 QHexEdit::resizeEvent(arg__1);
2308 QHexEdit::resizeEvent(arg__1);
2122 }
2309 }
2123 void PythonQtShell_QHexEdit::scrollContentsBy(int dx, int dy)
2310 void PythonQtShell_QHexEdit::scrollContentsBy(int dx0, int dy1)
2124 {
2311 {
2125 if (_wrapper) {
2312 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2126 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "scrollContentsBy");
2313 static PyObject* name = PyString_FromString("scrollContentsBy");
2127 PyErr_Clear();
2314 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2128 if (obj && !PythonQtSlotFunction_Check(obj)) {
2315 if (obj) {
2129 static const char* argumentList[] ={"" , "int" , "int"};
2316 static const char* argumentList[] ={"" , "int" , "int"};
2130 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2317 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2131 void* args[3] = {NULL, (void*)&dx, (void*)&dy};
2318 void* args[3] = {NULL, (void*)&dx0, (void*)&dy1};
2132 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2319 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2133 if (result) { Py_DECREF(result); }
2320 if (result) { Py_DECREF(result); }
2134 Py_DECREF(obj);
2321 Py_DECREF(obj);
2135 return;
2322 return;
2136 }
2323 } else {
2137 }
2324 PyErr_Clear();
2138 QHexEdit::scrollContentsBy(dx, dy);
2325 }
2139 }
2326 }
2140 void PythonQtShell_QHexEdit::setupViewport(QWidget* viewport)
2327 QHexEdit::scrollContentsBy(dx0, dy1);
2141 {
2328 }
2142 if (_wrapper) {
2329 void PythonQtShell_QHexEdit::setupViewport(QWidget* viewport0)
2143 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setupViewport");
2330 {
2144 PyErr_Clear();
2331 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2145 if (obj && !PythonQtSlotFunction_Check(obj)) {
2332 static PyObject* name = PyString_FromString("setupViewport");
2333 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2334 if (obj) {
2146 static const char* argumentList[] ={"" , "QWidget*"};
2335 static const char* argumentList[] ={"" , "QWidget*"};
2147 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2336 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2148 void* args[2] = {NULL, (void*)&viewport};
2337 void* args[2] = {NULL, (void*)&viewport0};
2149 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2338 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2150 if (result) { Py_DECREF(result); }
2339 if (result) { Py_DECREF(result); }
2151 Py_DECREF(obj);
2340 Py_DECREF(obj);
2152 return;
2341 return;
2153 }
2342 } else {
2154 }
2343 PyErr_Clear();
2155 QHexEdit::setupViewport(viewport);
2344 }
2345 }
2346 QHexEdit::setupViewport(viewport0);
2156 }
2347 }
2157 QPainter* PythonQtShell_QHexEdit::sharedPainter() const
2348 QPainter* PythonQtShell_QHexEdit::sharedPainter() const
2158 {
2349 {
2159 if (_wrapper) {
2350 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2160 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
2351 static PyObject* name = PyString_FromString("sharedPainter");
2161 PyErr_Clear();
2352 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2162 if (obj && !PythonQtSlotFunction_Check(obj)) {
2353 if (obj) {
2163 static const char* argumentList[] ={"QPainter*"};
2354 static const char* argumentList[] ={"QPainter*"};
2164 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2355 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2165 QPainter* returnValue;
2356 QPainter* returnValue;
2166 void* args[1] = {NULL};
2357 void* args[1] = {NULL};
2167 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2358 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2168 if (result) {
2359 if (result) {
2169 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2360 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2170 if (args[0]!=&returnValue) {
2361 if (args[0]!=&returnValue) {
2171 if (args[0]==NULL) {
2362 if (args[0]==NULL) {
2172 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
2363 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
2173 } else {
2364 } else {
2174 returnValue = *((QPainter**)args[0]);
2365 returnValue = *((QPainter**)args[0]);
2175 }
2366 }
2176 }
2367 }
2177 }
2368 }
2178 if (result) { Py_DECREF(result); }
2369 if (result) { Py_DECREF(result); }
2179 Py_DECREF(obj);
2370 Py_DECREF(obj);
2180 return returnValue;
2371 return returnValue;
2372 } else {
2373 PyErr_Clear();
2181 }
2374 }
2182 }
2375 }
2183 return QHexEdit::sharedPainter();
2376 return QHexEdit::sharedPainter();
2184 }
2377 }
2185 void PythonQtShell_QHexEdit::showEvent(QShowEvent* arg__1)
2378 void PythonQtShell_QHexEdit::showEvent(QShowEvent* arg__1)
2186 {
2379 {
2187 if (_wrapper) {
2380 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2188 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
2381 static PyObject* name = PyString_FromString("showEvent");
2189 PyErr_Clear();
2382 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2190 if (obj && !PythonQtSlotFunction_Check(obj)) {
2383 if (obj) {
2191 static const char* argumentList[] ={"" , "QShowEvent*"};
2384 static const char* argumentList[] ={"" , "QShowEvent*"};
2192 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2385 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2193 void* args[2] = {NULL, (void*)&arg__1};
2386 void* args[2] = {NULL, (void*)&arg__1};
2194 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2387 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2195 if (result) { Py_DECREF(result); }
2388 if (result) { Py_DECREF(result); }
2196 Py_DECREF(obj);
2389 Py_DECREF(obj);
2197 return;
2390 return;
2391 } else {
2392 PyErr_Clear();
2198 }
2393 }
2199 }
2394 }
2200 QHexEdit::showEvent(arg__1);
2395 QHexEdit::showEvent(arg__1);
2201 }
2396 }
2202 void PythonQtShell_QHexEdit::tabletEvent(QTabletEvent* arg__1)
2397 void PythonQtShell_QHexEdit::tabletEvent(QTabletEvent* arg__1)
2203 {
2398 {
2204 if (_wrapper) {
2399 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2205 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
2400 static PyObject* name = PyString_FromString("tabletEvent");
2206 PyErr_Clear();
2401 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2207 if (obj && !PythonQtSlotFunction_Check(obj)) {
2402 if (obj) {
2208 static const char* argumentList[] ={"" , "QTabletEvent*"};
2403 static const char* argumentList[] ={"" , "QTabletEvent*"};
2209 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2404 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2210 void* args[2] = {NULL, (void*)&arg__1};
2405 void* args[2] = {NULL, (void*)&arg__1};
2211 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2406 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2212 if (result) { Py_DECREF(result); }
2407 if (result) { Py_DECREF(result); }
2213 Py_DECREF(obj);
2408 Py_DECREF(obj);
2214 return;
2409 return;
2410 } else {
2411 PyErr_Clear();
2215 }
2412 }
2216 }
2413 }
2217 QHexEdit::tabletEvent(arg__1);
2414 QHexEdit::tabletEvent(arg__1);
2218 }
2415 }
2219 void PythonQtShell_QHexEdit::timerEvent(QTimerEvent* arg__1)
2416 void PythonQtShell_QHexEdit::timerEvent(QTimerEvent* arg__1)
2220 {
2417 {
2221 if (_wrapper) {
2418 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2222 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
2419 static PyObject* name = PyString_FromString("timerEvent");
2223 PyErr_Clear();
2420 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2224 if (obj && !PythonQtSlotFunction_Check(obj)) {
2421 if (obj) {
2225 static const char* argumentList[] ={"" , "QTimerEvent*"};
2422 static const char* argumentList[] ={"" , "QTimerEvent*"};
2226 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2423 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2227 void* args[2] = {NULL, (void*)&arg__1};
2424 void* args[2] = {NULL, (void*)&arg__1};
2228 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2425 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2229 if (result) { Py_DECREF(result); }
2426 if (result) { Py_DECREF(result); }
2230 Py_DECREF(obj);
2427 Py_DECREF(obj);
2231 return;
2428 return;
2429 } else {
2430 PyErr_Clear();
2232 }
2431 }
2233 }
2432 }
2234 QHexEdit::timerEvent(arg__1);
2433 QHexEdit::timerEvent(arg__1);
2235 }
2434 }
2236 bool PythonQtShell_QHexEdit::viewportEvent(QEvent* arg__1)
2435 bool PythonQtShell_QHexEdit::viewportEvent(QEvent* arg__1)
2237 {
2436 {
2238 if (_wrapper) {
2437 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2239 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportEvent");
2438 static PyObject* name = PyString_FromString("viewportEvent");
2240 PyErr_Clear();
2439 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2241 if (obj && !PythonQtSlotFunction_Check(obj)) {
2440 if (obj) {
2242 static const char* argumentList[] ={"bool" , "QEvent*"};
2441 static const char* argumentList[] ={"bool" , "QEvent*"};
2243 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2442 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2244 bool returnValue;
2443 bool returnValue;
2245 void* args[2] = {NULL, (void*)&arg__1};
2444 void* args[2] = {NULL, (void*)&arg__1};
2246 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2445 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2247 if (result) {
2446 if (result) {
2248 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2447 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2249 if (args[0]!=&returnValue) {
2448 if (args[0]!=&returnValue) {
2250 if (args[0]==NULL) {
2449 if (args[0]==NULL) {
2251 PythonQt::priv()->handleVirtualOverloadReturnError("viewportEvent", methodInfo, result);
2450 PythonQt::priv()->handleVirtualOverloadReturnError("viewportEvent", methodInfo, result);
2252 } else {
2451 } else {
2253 returnValue = *((bool*)args[0]);
2452 returnValue = *((bool*)args[0]);
2254 }
2453 }
2255 }
2454 }
2256 }
2455 }
2257 if (result) { Py_DECREF(result); }
2456 if (result) { Py_DECREF(result); }
2258 Py_DECREF(obj);
2457 Py_DECREF(obj);
2259 return returnValue;
2458 return returnValue;
2459 } else {
2460 PyErr_Clear();
2260 }
2461 }
2261 }
2462 }
2262 return QHexEdit::viewportEvent(arg__1);
2463 return QHexEdit::viewportEvent(arg__1);
2263 }
2464 }
2264 QSize PythonQtShell_QHexEdit::viewportSizeHint() const
2465 QSize PythonQtShell_QHexEdit::viewportSizeHint() const
2265 {
2466 {
2266 if (_wrapper) {
2467 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2267 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportSizeHint");
2468 static PyObject* name = PyString_FromString("viewportSizeHint");
2268 PyErr_Clear();
2469 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2269 if (obj && !PythonQtSlotFunction_Check(obj)) {
2470 if (obj) {
2270 static const char* argumentList[] ={"QSize"};
2471 static const char* argumentList[] ={"QSize"};
2271 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2472 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2272 QSize returnValue;
2473 QSize returnValue;
2273 void* args[1] = {NULL};
2474 void* args[1] = {NULL};
2274 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2475 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2275 if (result) {
2476 if (result) {
2276 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2477 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2277 if (args[0]!=&returnValue) {
2478 if (args[0]!=&returnValue) {
2278 if (args[0]==NULL) {
2479 if (args[0]==NULL) {
2279 PythonQt::priv()->handleVirtualOverloadReturnError("viewportSizeHint", methodInfo, result);
2480 PythonQt::priv()->handleVirtualOverloadReturnError("viewportSizeHint", methodInfo, result);
2280 } else {
2481 } else {
2281 returnValue = *((QSize*)args[0]);
2482 returnValue = *((QSize*)args[0]);
2282 }
2483 }
2283 }
2484 }
2284 }
2485 }
2285 if (result) { Py_DECREF(result); }
2486 if (result) { Py_DECREF(result); }
2286 Py_DECREF(obj);
2487 Py_DECREF(obj);
2287 return returnValue;
2488 return returnValue;
2489 } else {
2490 PyErr_Clear();
2288 }
2491 }
2289 }
2492 }
2290 return QHexEdit::viewportSizeHint();
2493 return QHexEdit::viewportSizeHint();
2291 }
2494 }
2292 void PythonQtShell_QHexEdit::wheelEvent(QWheelEvent* arg__1)
2495 void PythonQtShell_QHexEdit::wheelEvent(QWheelEvent* arg__1)
2293 {
2496 {
2294 if (_wrapper) {
2497 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2295 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
2498 static PyObject* name = PyString_FromString("wheelEvent");
2296 PyErr_Clear();
2499 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2297 if (obj && !PythonQtSlotFunction_Check(obj)) {
2500 if (obj) {
2298 static const char* argumentList[] ={"" , "QWheelEvent*"};
2501 static const char* argumentList[] ={"" , "QWheelEvent*"};
2299 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2502 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2300 void* args[2] = {NULL, (void*)&arg__1};
2503 void* args[2] = {NULL, (void*)&arg__1};
2301 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2504 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2302 if (result) { Py_DECREF(result); }
2505 if (result) { Py_DECREF(result); }
2303 Py_DECREF(obj);
2506 Py_DECREF(obj);
2304 return;
2507 return;
2508 } else {
2509 PyErr_Clear();
2305 }
2510 }
2306 }
2511 }
2307 QHexEdit::wheelEvent(arg__1);
2512 QHexEdit::wheelEvent(arg__1);
2308 }
2513 }
2309 QHexEdit* PythonQtWrapper_QHexEdit::new_QHexEdit(QWidget* parent)
2514 QHexEdit* PythonQtWrapper_QHexEdit::new_QHexEdit(QWidget* parent)
2310 {
2515 {
2311 return new PythonQtShell_QHexEdit(parent); }
2516 return new PythonQtShell_QHexEdit(parent); }
2312
2517
2313 QColor PythonQtWrapper_QHexEdit::addressAreaColor(QHexEdit* theWrappedObject)
2518 QColor PythonQtWrapper_QHexEdit::addressAreaColor(QHexEdit* theWrappedObject)
2314 {
2519 {
2315 return ( theWrappedObject->addressAreaColor());
2520 return ( theWrappedObject->addressAreaColor());
2316 }
2521 }
2317
2522
2318 int PythonQtWrapper_QHexEdit::addressOffset(QHexEdit* theWrappedObject)
2523 int PythonQtWrapper_QHexEdit::addressOffset(QHexEdit* theWrappedObject)
2319 {
2524 {
2320 return ( theWrappedObject->addressOffset());
2525 return ( theWrappedObject->addressOffset());
2321 }
2526 }
2322
2527
2323 int PythonQtWrapper_QHexEdit::cursorPosition(QHexEdit* theWrappedObject)
2528 int PythonQtWrapper_QHexEdit::cursorPosition(QHexEdit* theWrappedObject)
2324 {
2529 {
2325 return ( theWrappedObject->cursorPosition());
2530 return ( theWrappedObject->cursorPosition());
2326 }
2531 }
2327
2532
2328 QByteArray PythonQtWrapper_QHexEdit::data(QHexEdit* theWrappedObject)
2533 QByteArray PythonQtWrapper_QHexEdit::data(QHexEdit* theWrappedObject)
2329 {
2534 {
2330 return ( theWrappedObject->data());
2535 return ( theWrappedObject->data());
2331 }
2536 }
2332
2537
2333 const QFont* PythonQtWrapper_QHexEdit::font(QHexEdit* theWrappedObject) const
2538 const QFont* PythonQtWrapper_QHexEdit::font(QHexEdit* theWrappedObject) const
2334 {
2539 {
2335 return &( theWrappedObject->font());
2540 return &( theWrappedObject->font());
2336 }
2541 }
2337
2542
2338 int PythonQtWrapper_QHexEdit::getSelectionBegin(QHexEdit* theWrappedObject)
2543 int PythonQtWrapper_QHexEdit::getSelectionBegin(QHexEdit* theWrappedObject)
2339 {
2544 {
2340 return ( theWrappedObject->getSelectionBegin());
2545 return ( theWrappedObject->getSelectionBegin());
2341 }
2546 }
2342
2547
2343 int PythonQtWrapper_QHexEdit::getSelectionEnd(QHexEdit* theWrappedObject)
2548 int PythonQtWrapper_QHexEdit::getSelectionEnd(QHexEdit* theWrappedObject)
2344 {
2549 {
2345 return ( theWrappedObject->getSelectionEnd());
2550 return ( theWrappedObject->getSelectionEnd());
2346 }
2551 }
2347
2552
2348 QColor PythonQtWrapper_QHexEdit::highlightingColor(QHexEdit* theWrappedObject)
2553 QColor PythonQtWrapper_QHexEdit::highlightingColor(QHexEdit* theWrappedObject)
2349 {
2554 {
2350 return ( theWrappedObject->highlightingColor());
2555 return ( theWrappedObject->highlightingColor());
2351 }
2556 }
2352
2557
2353 int PythonQtWrapper_QHexEdit::indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2558 int PythonQtWrapper_QHexEdit::indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2354 {
2559 {
2355 return ( theWrappedObject->indexOf(ba, from));
2560 return ( theWrappedObject->indexOf(ba, from));
2356 }
2561 }
2357
2562
2358 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, char ch)
2563 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, char ch)
2359 {
2564 {
2360 ( theWrappedObject->insert(i, ch));
2565 ( theWrappedObject->insert(i, ch));
2361 }
2566 }
2362
2567
2363 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba)
2568 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba)
2364 {
2569 {
2365 ( theWrappedObject->insert(i, ba));
2570 ( theWrappedObject->insert(i, ba));
2366 }
2571 }
2367
2572
2368 bool PythonQtWrapper_QHexEdit::isReadOnly(QHexEdit* theWrappedObject)
2573 bool PythonQtWrapper_QHexEdit::isReadOnly(QHexEdit* theWrappedObject)
2369 {
2574 {
2370 return ( theWrappedObject->isReadOnly());
2575 return ( theWrappedObject->isReadOnly());
2371 }
2576 }
2372
2577
2373 int PythonQtWrapper_QHexEdit::lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2578 int PythonQtWrapper_QHexEdit::lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2374 {
2579 {
2375 return ( theWrappedObject->lastIndexOf(ba, from));
2580 return ( theWrappedObject->lastIndexOf(ba, from));
2376 }
2581 }
2377
2582
2378 bool PythonQtWrapper_QHexEdit::overwriteMode(QHexEdit* theWrappedObject)
2583 bool PythonQtWrapper_QHexEdit::overwriteMode(QHexEdit* theWrappedObject)
2379 {
2584 {
2380 return ( theWrappedObject->overwriteMode());
2585 return ( theWrappedObject->overwriteMode());
2381 }
2586 }
2382
2587
2383 void PythonQtWrapper_QHexEdit::remove(QHexEdit* theWrappedObject, int pos, int len)
2588 void PythonQtWrapper_QHexEdit::remove(QHexEdit* theWrappedObject, int pos, int len)
2384 {
2589 {
2385 ( theWrappedObject->remove(pos, len));
2590 ( theWrappedObject->remove(pos, len));
2386 }
2591 }
2387
2592
2388 void PythonQtWrapper_QHexEdit::replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after)
2593 void PythonQtWrapper_QHexEdit::replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after)
2389 {
2594 {
2390 ( theWrappedObject->replace(pos, len, after));
2595 ( theWrappedObject->replace(pos, len, after));
2391 }
2596 }
2392
2597
2393 void PythonQtWrapper_QHexEdit::resetSelection(QHexEdit* theWrappedObject)
2598 void PythonQtWrapper_QHexEdit::resetSelection(QHexEdit* theWrappedObject)
2394 {
2599 {
2395 ( theWrappedObject->resetSelection());
2600 ( theWrappedObject->resetSelection());
2396 }
2601 }
2397
2602
2398 void PythonQtWrapper_QHexEdit::resetSelection(QHexEdit* theWrappedObject, int pos)
2603 void PythonQtWrapper_QHexEdit::resetSelection(QHexEdit* theWrappedObject, int pos)
2399 {
2604 {
2400 ( theWrappedObject->resetSelection(pos));
2605 ( theWrappedObject->resetSelection(pos));
2401 }
2606 }
2402
2607
2403 QColor PythonQtWrapper_QHexEdit::selectionColor(QHexEdit* theWrappedObject)
2608 QColor PythonQtWrapper_QHexEdit::selectionColor(QHexEdit* theWrappedObject)
2404 {
2609 {
2405 return ( theWrappedObject->selectionColor());
2610 return ( theWrappedObject->selectionColor());
2406 }
2611 }
2407
2612
2408 QString PythonQtWrapper_QHexEdit::selectionToReadableString(QHexEdit* theWrappedObject)
2613 QString PythonQtWrapper_QHexEdit::selectionToReadableString(QHexEdit* theWrappedObject)
2409 {
2614 {
2410 return ( theWrappedObject->selectionToReadableString());
2615 return ( theWrappedObject->selectionToReadableString());
2411 }
2616 }
2412
2617
2413 void PythonQtWrapper_QHexEdit::setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color)
2618 void PythonQtWrapper_QHexEdit::setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color)
2414 {
2619 {
2415 ( theWrappedObject->setAddressAreaColor(color));
2620 ( theWrappedObject->setAddressAreaColor(color));
2416 }
2621 }
2417
2622
2418 void PythonQtWrapper_QHexEdit::setAddressOffset(QHexEdit* theWrappedObject, int offset)
2623 void PythonQtWrapper_QHexEdit::setAddressOffset(QHexEdit* theWrappedObject, int offset)
2419 {
2624 {
2420 ( theWrappedObject->setAddressOffset(offset));
2625 ( theWrappedObject->setAddressOffset(offset));
2421 }
2626 }
2422
2627
2423 void PythonQtWrapper_QHexEdit::setCursorPosition(QHexEdit* theWrappedObject, int cusorPos)
2628 void PythonQtWrapper_QHexEdit::setCursorPosition(QHexEdit* theWrappedObject, int cusorPos)
2424 {
2629 {
2425 ( theWrappedObject->setCursorPosition(cusorPos));
2630 ( theWrappedObject->setCursorPosition(cusorPos));
2426 }
2631 }
2427
2632
2428 void PythonQtWrapper_QHexEdit::setData(QHexEdit* theWrappedObject, const QByteArray& data)
2633 void PythonQtWrapper_QHexEdit::setData(QHexEdit* theWrappedObject, const QByteArray& data)
2429 {
2634 {
2430 ( theWrappedObject->setData(data));
2635 ( theWrappedObject->setData(data));
2431 }
2636 }
2432
2637
2433 void PythonQtWrapper_QHexEdit::setFont(QHexEdit* theWrappedObject, const QFont& arg__1)
2638 void PythonQtWrapper_QHexEdit::setFont(QHexEdit* theWrappedObject, const QFont& arg__1)
2434 {
2639 {
2435 ( theWrappedObject->setFont(arg__1));
2640 ( theWrappedObject->setFont(arg__1));
2436 }
2641 }
2437
2642
2438 void PythonQtWrapper_QHexEdit::setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color)
2643 void PythonQtWrapper_QHexEdit::setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color)
2439 {
2644 {
2440 ( theWrappedObject->setHighlightingColor(color));
2645 ( theWrappedObject->setHighlightingColor(color));
2441 }
2646 }
2442
2647
2443 void PythonQtWrapper_QHexEdit::setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1)
2648 void PythonQtWrapper_QHexEdit::setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1)
2444 {
2649 {
2445 ( theWrappedObject->setOverwriteMode(arg__1));
2650 ( theWrappedObject->setOverwriteMode(arg__1));
2446 }
2651 }
2447
2652
2448 void PythonQtWrapper_QHexEdit::setReadOnly(QHexEdit* theWrappedObject, bool arg__1)
2653 void PythonQtWrapper_QHexEdit::setReadOnly(QHexEdit* theWrappedObject, bool arg__1)
2449 {
2654 {
2450 ( theWrappedObject->setReadOnly(arg__1));
2655 ( theWrappedObject->setReadOnly(arg__1));
2451 }
2656 }
2452
2657
2453 void PythonQtWrapper_QHexEdit::setSelection(QHexEdit* theWrappedObject, int pos)
2658 void PythonQtWrapper_QHexEdit::setSelection(QHexEdit* theWrappedObject, int pos)
2454 {
2659 {
2455 ( theWrappedObject->setSelection(pos));
2660 ( theWrappedObject->setSelection(pos));
2456 }
2661 }
2457
2662
2458 void PythonQtWrapper_QHexEdit::setSelectionColor(QHexEdit* theWrappedObject, const QColor& color)
2663 void PythonQtWrapper_QHexEdit::setSelectionColor(QHexEdit* theWrappedObject, const QColor& color)
2459 {
2664 {
2460 ( theWrappedObject->setSelectionColor(color));
2665 ( theWrappedObject->setSelectionColor(color));
2461 }
2666 }
2462
2667
2463 QString PythonQtWrapper_QHexEdit::toReadableString(QHexEdit* theWrappedObject)
2668 QString PythonQtWrapper_QHexEdit::toReadableString(QHexEdit* theWrappedObject)
2464 {
2669 {
2465 return ( theWrappedObject->toReadableString());
2670 return ( theWrappedObject->toReadableString());
2466 }
2671 }
2467
2672
2468
2673
2469
2674
2470 PythonQtShell_QHexSpinBox::~PythonQtShell_QHexSpinBox() {
2675 PythonQtShell_QHexSpinBox::~PythonQtShell_QHexSpinBox() {
2471 PythonQtPrivate* priv = PythonQt::priv();
2676 PythonQtPrivate* priv = PythonQt::priv();
2472 if (priv) { priv->shellClassDeleted(this); }
2677 if (priv) { priv->shellClassDeleted(this); }
2473 }
2678 }
2474 void PythonQtShell_QHexSpinBox::actionEvent(QActionEvent* arg__1)
2679 void PythonQtShell_QHexSpinBox::actionEvent(QActionEvent* arg__1)
2475 {
2680 {
2476 if (_wrapper) {
2681 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2477 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
2682 static PyObject* name = PyString_FromString("actionEvent");
2478 PyErr_Clear();
2683 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2479 if (obj && !PythonQtSlotFunction_Check(obj)) {
2684 if (obj) {
2480 static const char* argumentList[] ={"" , "QActionEvent*"};
2685 static const char* argumentList[] ={"" , "QActionEvent*"};
2481 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2686 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2482 void* args[2] = {NULL, (void*)&arg__1};
2687 void* args[2] = {NULL, (void*)&arg__1};
2483 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2688 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2484 if (result) { Py_DECREF(result); }
2689 if (result) { Py_DECREF(result); }
2485 Py_DECREF(obj);
2690 Py_DECREF(obj);
2486 return;
2691 return;
2692 } else {
2693 PyErr_Clear();
2487 }
2694 }
2488 }
2695 }
2489 QHexSpinBox::actionEvent(arg__1);
2696 QHexSpinBox::actionEvent(arg__1);
2490 }
2697 }
2491 void PythonQtShell_QHexSpinBox::changeEvent(QEvent* event)
2698 void PythonQtShell_QHexSpinBox::changeEvent(QEvent* event0)
2492 {
2699 {
2493 if (_wrapper) {
2700 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2494 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
2701 static PyObject* name = PyString_FromString("changeEvent");
2495 PyErr_Clear();
2702 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2496 if (obj && !PythonQtSlotFunction_Check(obj)) {
2703 if (obj) {
2497 static const char* argumentList[] ={"" , "QEvent*"};
2704 static const char* argumentList[] ={"" , "QEvent*"};
2498 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2705 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2499 void* args[2] = {NULL, (void*)&event};
2706 void* args[2] = {NULL, (void*)&event0};
2500 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2707 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2501 if (result) { Py_DECREF(result); }
2708 if (result) { Py_DECREF(result); }
2502 Py_DECREF(obj);
2709 Py_DECREF(obj);
2503 return;
2710 return;
2504 }
2711 } else {
2505 }
2712 PyErr_Clear();
2506 QHexSpinBox::changeEvent(event);
2713 }
2714 }
2715 QHexSpinBox::changeEvent(event0);
2507 }
2716 }
2508 void PythonQtShell_QHexSpinBox::childEvent(QChildEvent* arg__1)
2717 void PythonQtShell_QHexSpinBox::childEvent(QChildEvent* arg__1)
2509 {
2718 {
2510 if (_wrapper) {
2719 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2511 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
2720 static PyObject* name = PyString_FromString("childEvent");
2512 PyErr_Clear();
2721 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2513 if (obj && !PythonQtSlotFunction_Check(obj)) {
2722 if (obj) {
2514 static const char* argumentList[] ={"" , "QChildEvent*"};
2723 static const char* argumentList[] ={"" , "QChildEvent*"};
2515 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2724 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2516 void* args[2] = {NULL, (void*)&arg__1};
2725 void* args[2] = {NULL, (void*)&arg__1};
2517 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2726 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2518 if (result) { Py_DECREF(result); }
2727 if (result) { Py_DECREF(result); }
2519 Py_DECREF(obj);
2728 Py_DECREF(obj);
2520 return;
2729 return;
2730 } else {
2731 PyErr_Clear();
2521 }
2732 }
2522 }
2733 }
2523 QHexSpinBox::childEvent(arg__1);
2734 QHexSpinBox::childEvent(arg__1);
2524 }
2735 }
2525 void PythonQtShell_QHexSpinBox::clear()
2736 void PythonQtShell_QHexSpinBox::clear()
2526 {
2737 {
2527 if (_wrapper) {
2738 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2528 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "clear");
2739 static PyObject* name = PyString_FromString("clear");
2529 PyErr_Clear();
2740 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2530 if (obj && !PythonQtSlotFunction_Check(obj)) {
2741 if (obj) {
2531 static const char* argumentList[] ={""};
2742 static const char* argumentList[] ={""};
2532 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2743 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2533 void* args[1] = {NULL};
2744 void* args[1] = {NULL};
2534 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2745 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2535 if (result) { Py_DECREF(result); }
2746 if (result) { Py_DECREF(result); }
2536 Py_DECREF(obj);
2747 Py_DECREF(obj);
2537 return;
2748 return;
2749 } else {
2750 PyErr_Clear();
2538 }
2751 }
2539 }
2752 }
2540 QHexSpinBox::clear();
2753 QHexSpinBox::clear();
2541 }
2754 }
2542 void PythonQtShell_QHexSpinBox::closeEvent(QCloseEvent* event)
2755 void PythonQtShell_QHexSpinBox::closeEvent(QCloseEvent* event0)
2543 {
2756 {
2544 if (_wrapper) {
2757 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2545 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
2758 static PyObject* name = PyString_FromString("closeEvent");
2546 PyErr_Clear();
2759 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2547 if (obj && !PythonQtSlotFunction_Check(obj)) {
2760 if (obj) {
2548 static const char* argumentList[] ={"" , "QCloseEvent*"};
2761 static const char* argumentList[] ={"" , "QCloseEvent*"};
2549 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2762 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2550 void* args[2] = {NULL, (void*)&event};
2763 void* args[2] = {NULL, (void*)&event0};
2551 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2764 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2552 if (result) { Py_DECREF(result); }
2765 if (result) { Py_DECREF(result); }
2553 Py_DECREF(obj);
2766 Py_DECREF(obj);
2554 return;
2767 return;
2555 }
2768 } else {
2556 }
2769 PyErr_Clear();
2557 QHexSpinBox::closeEvent(event);
2770 }
2558 }
2771 }
2559 void PythonQtShell_QHexSpinBox::contextMenuEvent(QContextMenuEvent* event)
2772 QHexSpinBox::closeEvent(event0);
2560 {
2773 }
2561 if (_wrapper) {
2774 void PythonQtShell_QHexSpinBox::contextMenuEvent(QContextMenuEvent* event0)
2562 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
2775 {
2563 PyErr_Clear();
2776 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2564 if (obj && !PythonQtSlotFunction_Check(obj)) {
2777 static PyObject* name = PyString_FromString("contextMenuEvent");
2778 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2779 if (obj) {
2565 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
2780 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
2566 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2781 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2567 void* args[2] = {NULL, (void*)&event};
2782 void* args[2] = {NULL, (void*)&event0};
2568 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2783 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2569 if (result) { Py_DECREF(result); }
2784 if (result) { Py_DECREF(result); }
2570 Py_DECREF(obj);
2785 Py_DECREF(obj);
2571 return;
2786 return;
2572 }
2787 } else {
2573 }
2788 PyErr_Clear();
2574 QHexSpinBox::contextMenuEvent(event);
2789 }
2790 }
2791 QHexSpinBox::contextMenuEvent(event0);
2575 }
2792 }
2576 void PythonQtShell_QHexSpinBox::customEvent(QEvent* arg__1)
2793 void PythonQtShell_QHexSpinBox::customEvent(QEvent* arg__1)
2577 {
2794 {
2578 if (_wrapper) {
2795 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2579 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
2796 static PyObject* name = PyString_FromString("customEvent");
2580 PyErr_Clear();
2797 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2581 if (obj && !PythonQtSlotFunction_Check(obj)) {
2798 if (obj) {
2582 static const char* argumentList[] ={"" , "QEvent*"};
2799 static const char* argumentList[] ={"" , "QEvent*"};
2583 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2800 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2584 void* args[2] = {NULL, (void*)&arg__1};
2801 void* args[2] = {NULL, (void*)&arg__1};
2585 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2802 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2586 if (result) { Py_DECREF(result); }
2803 if (result) { Py_DECREF(result); }
2587 Py_DECREF(obj);
2804 Py_DECREF(obj);
2588 return;
2805 return;
2806 } else {
2807 PyErr_Clear();
2589 }
2808 }
2590 }
2809 }
2591 QHexSpinBox::customEvent(arg__1);
2810 QHexSpinBox::customEvent(arg__1);
2592 }
2811 }
2593 int PythonQtShell_QHexSpinBox::devType() const
2812 int PythonQtShell_QHexSpinBox::devType() const
2594 {
2813 {
2595 if (_wrapper) {
2814 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2596 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
2815 static PyObject* name = PyString_FromString("devType");
2597 PyErr_Clear();
2816 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2598 if (obj && !PythonQtSlotFunction_Check(obj)) {
2817 if (obj) {
2599 static const char* argumentList[] ={"int"};
2818 static const char* argumentList[] ={"int"};
2600 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2819 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2601 int returnValue;
2820 int returnValue;
2602 void* args[1] = {NULL};
2821 void* args[1] = {NULL};
2603 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2822 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2604 if (result) {
2823 if (result) {
2605 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2824 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2606 if (args[0]!=&returnValue) {
2825 if (args[0]!=&returnValue) {
2607 if (args[0]==NULL) {
2826 if (args[0]==NULL) {
2608 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
2827 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
2609 } else {
2828 } else {
2610 returnValue = *((int*)args[0]);
2829 returnValue = *((int*)args[0]);
2611 }
2830 }
2612 }
2831 }
2613 }
2832 }
2614 if (result) { Py_DECREF(result); }
2833 if (result) { Py_DECREF(result); }
2615 Py_DECREF(obj);
2834 Py_DECREF(obj);
2616 return returnValue;
2835 return returnValue;
2836 } else {
2837 PyErr_Clear();
2617 }
2838 }
2618 }
2839 }
2619 return QHexSpinBox::devType();
2840 return QHexSpinBox::devType();
2620 }
2841 }
2621 void PythonQtShell_QHexSpinBox::dragEnterEvent(QDragEnterEvent* arg__1)
2842 void PythonQtShell_QHexSpinBox::dragEnterEvent(QDragEnterEvent* arg__1)
2622 {
2843 {
2623 if (_wrapper) {
2844 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2624 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
2845 static PyObject* name = PyString_FromString("dragEnterEvent");
2625 PyErr_Clear();
2846 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2626 if (obj && !PythonQtSlotFunction_Check(obj)) {
2847 if (obj) {
2627 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
2848 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
2628 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2849 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2629 void* args[2] = {NULL, (void*)&arg__1};
2850 void* args[2] = {NULL, (void*)&arg__1};
2630 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2851 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2631 if (result) { Py_DECREF(result); }
2852 if (result) { Py_DECREF(result); }
2632 Py_DECREF(obj);
2853 Py_DECREF(obj);
2633 return;
2854 return;
2855 } else {
2856 PyErr_Clear();
2634 }
2857 }
2635 }
2858 }
2636 QHexSpinBox::dragEnterEvent(arg__1);
2859 QHexSpinBox::dragEnterEvent(arg__1);
2637 }
2860 }
2638 void PythonQtShell_QHexSpinBox::dragLeaveEvent(QDragLeaveEvent* arg__1)
2861 void PythonQtShell_QHexSpinBox::dragLeaveEvent(QDragLeaveEvent* arg__1)
2639 {
2862 {
2640 if (_wrapper) {
2863 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2641 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
2864 static PyObject* name = PyString_FromString("dragLeaveEvent");
2642 PyErr_Clear();
2865 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2643 if (obj && !PythonQtSlotFunction_Check(obj)) {
2866 if (obj) {
2644 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
2867 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
2645 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2868 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2646 void* args[2] = {NULL, (void*)&arg__1};
2869 void* args[2] = {NULL, (void*)&arg__1};
2647 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2870 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2648 if (result) { Py_DECREF(result); }
2871 if (result) { Py_DECREF(result); }
2649 Py_DECREF(obj);
2872 Py_DECREF(obj);
2650 return;
2873 return;
2874 } else {
2875 PyErr_Clear();
2651 }
2876 }
2652 }
2877 }
2653 QHexSpinBox::dragLeaveEvent(arg__1);
2878 QHexSpinBox::dragLeaveEvent(arg__1);
2654 }
2879 }
2655 void PythonQtShell_QHexSpinBox::dragMoveEvent(QDragMoveEvent* arg__1)
2880 void PythonQtShell_QHexSpinBox::dragMoveEvent(QDragMoveEvent* arg__1)
2656 {
2881 {
2657 if (_wrapper) {
2882 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2658 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
2883 static PyObject* name = PyString_FromString("dragMoveEvent");
2659 PyErr_Clear();
2884 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2660 if (obj && !PythonQtSlotFunction_Check(obj)) {
2885 if (obj) {
2661 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
2886 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
2662 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2887 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2663 void* args[2] = {NULL, (void*)&arg__1};
2888 void* args[2] = {NULL, (void*)&arg__1};
2664 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2889 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2665 if (result) { Py_DECREF(result); }
2890 if (result) { Py_DECREF(result); }
2666 Py_DECREF(obj);
2891 Py_DECREF(obj);
2667 return;
2892 return;
2893 } else {
2894 PyErr_Clear();
2668 }
2895 }
2669 }
2896 }
2670 QHexSpinBox::dragMoveEvent(arg__1);
2897 QHexSpinBox::dragMoveEvent(arg__1);
2671 }
2898 }
2672 void PythonQtShell_QHexSpinBox::dropEvent(QDropEvent* arg__1)
2899 void PythonQtShell_QHexSpinBox::dropEvent(QDropEvent* arg__1)
2673 {
2900 {
2674 if (_wrapper) {
2901 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2675 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
2902 static PyObject* name = PyString_FromString("dropEvent");
2676 PyErr_Clear();
2903 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2677 if (obj && !PythonQtSlotFunction_Check(obj)) {
2904 if (obj) {
2678 static const char* argumentList[] ={"" , "QDropEvent*"};
2905 static const char* argumentList[] ={"" , "QDropEvent*"};
2679 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2906 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2680 void* args[2] = {NULL, (void*)&arg__1};
2907 void* args[2] = {NULL, (void*)&arg__1};
2681 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2908 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2682 if (result) { Py_DECREF(result); }
2909 if (result) { Py_DECREF(result); }
2683 Py_DECREF(obj);
2910 Py_DECREF(obj);
2684 return;
2911 return;
2912 } else {
2913 PyErr_Clear();
2685 }
2914 }
2686 }
2915 }
2687 QHexSpinBox::dropEvent(arg__1);
2916 QHexSpinBox::dropEvent(arg__1);
2688 }
2917 }
2689 void PythonQtShell_QHexSpinBox::enterEvent(QEvent* arg__1)
2918 void PythonQtShell_QHexSpinBox::enterEvent(QEvent* arg__1)
2690 {
2919 {
2691 if (_wrapper) {
2920 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2692 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
2921 static PyObject* name = PyString_FromString("enterEvent");
2693 PyErr_Clear();
2922 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2694 if (obj && !PythonQtSlotFunction_Check(obj)) {
2923 if (obj) {
2695 static const char* argumentList[] ={"" , "QEvent*"};
2924 static const char* argumentList[] ={"" , "QEvent*"};
2696 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2925 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2697 void* args[2] = {NULL, (void*)&arg__1};
2926 void* args[2] = {NULL, (void*)&arg__1};
2698 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2927 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2699 if (result) { Py_DECREF(result); }
2928 if (result) { Py_DECREF(result); }
2700 Py_DECREF(obj);
2929 Py_DECREF(obj);
2701 return;
2930 return;
2931 } else {
2932 PyErr_Clear();
2702 }
2933 }
2703 }
2934 }
2704 QHexSpinBox::enterEvent(arg__1);
2935 QHexSpinBox::enterEvent(arg__1);
2705 }
2936 }
2706 bool PythonQtShell_QHexSpinBox::event(QEvent* event)
2937 bool PythonQtShell_QHexSpinBox::event(QEvent* event0)
2707 {
2938 {
2708 if (_wrapper) {
2939 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2709 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
2940 static PyObject* name = PyString_FromString("event");
2710 PyErr_Clear();
2941 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2711 if (obj && !PythonQtSlotFunction_Check(obj)) {
2942 if (obj) {
2712 static const char* argumentList[] ={"bool" , "QEvent*"};
2943 static const char* argumentList[] ={"bool" , "QEvent*"};
2713 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2944 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2714 bool returnValue;
2945 bool returnValue;
2715 void* args[2] = {NULL, (void*)&event};
2946 void* args[2] = {NULL, (void*)&event0};
2716 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2947 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2717 if (result) {
2948 if (result) {
2718 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2949 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2719 if (args[0]!=&returnValue) {
2950 if (args[0]!=&returnValue) {
2720 if (args[0]==NULL) {
2951 if (args[0]==NULL) {
2721 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
2952 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
2722 } else {
2953 } else {
2723 returnValue = *((bool*)args[0]);
2954 returnValue = *((bool*)args[0]);
2724 }
2955 }
2725 }
2956 }
2726 }
2957 }
2727 if (result) { Py_DECREF(result); }
2958 if (result) { Py_DECREF(result); }
2728 Py_DECREF(obj);
2959 Py_DECREF(obj);
2729 return returnValue;
2960 return returnValue;
2730 }
2961 } else {
2731 }
2962 PyErr_Clear();
2732 return QHexSpinBox::event(event);
2963 }
2964 }
2965 return QHexSpinBox::event(event0);
2733 }
2966 }
2734 bool PythonQtShell_QHexSpinBox::eventFilter(QObject* arg__1, QEvent* arg__2)
2967 bool PythonQtShell_QHexSpinBox::eventFilter(QObject* arg__1, QEvent* arg__2)
2735 {
2968 {
2736 if (_wrapper) {
2969 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2737 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
2970 static PyObject* name = PyString_FromString("eventFilter");
2738 PyErr_Clear();
2971 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2739 if (obj && !PythonQtSlotFunction_Check(obj)) {
2972 if (obj) {
2740 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
2973 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
2741 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2974 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2742 bool returnValue;
2975 bool returnValue;
2743 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
2976 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
2744 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2977 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2745 if (result) {
2978 if (result) {
2746 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2979 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2747 if (args[0]!=&returnValue) {
2980 if (args[0]!=&returnValue) {
2748 if (args[0]==NULL) {
2981 if (args[0]==NULL) {
2749 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
2982 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
2750 } else {
2983 } else {
2751 returnValue = *((bool*)args[0]);
2984 returnValue = *((bool*)args[0]);
2752 }
2985 }
2753 }
2986 }
2754 }
2987 }
2755 if (result) { Py_DECREF(result); }
2988 if (result) { Py_DECREF(result); }
2756 Py_DECREF(obj);
2989 Py_DECREF(obj);
2757 return returnValue;
2990 return returnValue;
2991 } else {
2992 PyErr_Clear();
2758 }
2993 }
2759 }
2994 }
2760 return QHexSpinBox::eventFilter(arg__1, arg__2);
2995 return QHexSpinBox::eventFilter(arg__1, arg__2);
2761 }
2996 }
2762 void PythonQtShell_QHexSpinBox::fixup(QString& str) const
2997 void PythonQtShell_QHexSpinBox::fixup(QString& str0) const
2763 {
2998 {
2764 if (_wrapper) {
2999 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2765 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "fixup");
3000 static PyObject* name = PyString_FromString("fixup");
2766 PyErr_Clear();
3001 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2767 if (obj && !PythonQtSlotFunction_Check(obj)) {
3002 if (obj) {
2768 static const char* argumentList[] ={"" , "QString&"};
3003 static const char* argumentList[] ={"" , "QString&"};
2769 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3004 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2770 void* args[2] = {NULL, (void*)&str};
3005 void* args[2] = {NULL, (void*)&str0};
2771 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3006 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2772 if (result) { Py_DECREF(result); }
3007 if (result) { Py_DECREF(result); }
2773 Py_DECREF(obj);
3008 Py_DECREF(obj);
2774 return;
3009 return;
2775 }
3010 } else {
2776 }
3011 PyErr_Clear();
2777 QHexSpinBox::fixup(str);
3012 }
2778 }
3013 }
2779 void PythonQtShell_QHexSpinBox::focusInEvent(QFocusEvent* event)
3014 QHexSpinBox::fixup(str0);
2780 {
3015 }
2781 if (_wrapper) {
3016 void PythonQtShell_QHexSpinBox::focusInEvent(QFocusEvent* event0)
2782 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
3017 {
2783 PyErr_Clear();
3018 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2784 if (obj && !PythonQtSlotFunction_Check(obj)) {
3019 static PyObject* name = PyString_FromString("focusInEvent");
3020 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3021 if (obj) {
2785 static const char* argumentList[] ={"" , "QFocusEvent*"};
3022 static const char* argumentList[] ={"" , "QFocusEvent*"};
2786 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3023 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2787 void* args[2] = {NULL, (void*)&event};
3024 void* args[2] = {NULL, (void*)&event0};
2788 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3025 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2789 if (result) { Py_DECREF(result); }
3026 if (result) { Py_DECREF(result); }
2790 Py_DECREF(obj);
3027 Py_DECREF(obj);
2791 return;
3028 return;
2792 }
3029 } else {
2793 }
3030 PyErr_Clear();
2794 QHexSpinBox::focusInEvent(event);
3031 }
2795 }
3032 }
2796 bool PythonQtShell_QHexSpinBox::focusNextPrevChild(bool next)
3033 QHexSpinBox::focusInEvent(event0);
2797 {
3034 }
2798 if (_wrapper) {
3035 bool PythonQtShell_QHexSpinBox::focusNextPrevChild(bool next0)
2799 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
3036 {
2800 PyErr_Clear();
3037 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2801 if (obj && !PythonQtSlotFunction_Check(obj)) {
3038 static PyObject* name = PyString_FromString("focusNextPrevChild");
3039 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3040 if (obj) {
2802 static const char* argumentList[] ={"bool" , "bool"};
3041 static const char* argumentList[] ={"bool" , "bool"};
2803 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3042 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2804 bool returnValue;
3043 bool returnValue;
2805 void* args[2] = {NULL, (void*)&next};
3044 void* args[2] = {NULL, (void*)&next0};
2806 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3045 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2807 if (result) {
3046 if (result) {
2808 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3047 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2809 if (args[0]!=&returnValue) {
3048 if (args[0]!=&returnValue) {
2810 if (args[0]==NULL) {
3049 if (args[0]==NULL) {
2811 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
3050 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
2812 } else {
3051 } else {
2813 returnValue = *((bool*)args[0]);
3052 returnValue = *((bool*)args[0]);
2814 }
3053 }
2815 }
3054 }
2816 }
3055 }
2817 if (result) { Py_DECREF(result); }
3056 if (result) { Py_DECREF(result); }
2818 Py_DECREF(obj);
3057 Py_DECREF(obj);
2819 return returnValue;
3058 return returnValue;
2820 }
3059 } else {
2821 }
3060 PyErr_Clear();
2822 return QHexSpinBox::focusNextPrevChild(next);
3061 }
2823 }
3062 }
2824 void PythonQtShell_QHexSpinBox::focusOutEvent(QFocusEvent* event)
3063 return QHexSpinBox::focusNextPrevChild(next0);
2825 {
3064 }
2826 if (_wrapper) {
3065 void PythonQtShell_QHexSpinBox::focusOutEvent(QFocusEvent* event0)
2827 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
3066 {
2828 PyErr_Clear();
3067 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2829 if (obj && !PythonQtSlotFunction_Check(obj)) {
3068 static PyObject* name = PyString_FromString("focusOutEvent");
3069 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3070 if (obj) {
2830 static const char* argumentList[] ={"" , "QFocusEvent*"};
3071 static const char* argumentList[] ={"" , "QFocusEvent*"};
2831 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3072 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2832 void* args[2] = {NULL, (void*)&event};
3073 void* args[2] = {NULL, (void*)&event0};
2833 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3074 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2834 if (result) { Py_DECREF(result); }
3075 if (result) { Py_DECREF(result); }
2835 Py_DECREF(obj);
3076 Py_DECREF(obj);
2836 return;
3077 return;
2837 }
3078 } else {
2838 }
3079 PyErr_Clear();
2839 QHexSpinBox::focusOutEvent(event);
3080 }
3081 }
3082 QHexSpinBox::focusOutEvent(event0);
2840 }
3083 }
2841 bool PythonQtShell_QHexSpinBox::hasHeightForWidth() const
3084 bool PythonQtShell_QHexSpinBox::hasHeightForWidth() const
2842 {
3085 {
2843 if (_wrapper) {
3086 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2844 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
3087 static PyObject* name = PyString_FromString("hasHeightForWidth");
2845 PyErr_Clear();
3088 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2846 if (obj && !PythonQtSlotFunction_Check(obj)) {
3089 if (obj) {
2847 static const char* argumentList[] ={"bool"};
3090 static const char* argumentList[] ={"bool"};
2848 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3091 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2849 bool returnValue;
3092 bool returnValue;
2850 void* args[1] = {NULL};
3093 void* args[1] = {NULL};
2851 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3094 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2852 if (result) {
3095 if (result) {
2853 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3096 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2854 if (args[0]!=&returnValue) {
3097 if (args[0]!=&returnValue) {
2855 if (args[0]==NULL) {
3098 if (args[0]==NULL) {
2856 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
3099 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
2857 } else {
3100 } else {
2858 returnValue = *((bool*)args[0]);
3101 returnValue = *((bool*)args[0]);
2859 }
3102 }
2860 }
3103 }
2861 }
3104 }
2862 if (result) { Py_DECREF(result); }
3105 if (result) { Py_DECREF(result); }
2863 Py_DECREF(obj);
3106 Py_DECREF(obj);
2864 return returnValue;
3107 return returnValue;
3108 } else {
3109 PyErr_Clear();
2865 }
3110 }
2866 }
3111 }
2867 return QHexSpinBox::hasHeightForWidth();
3112 return QHexSpinBox::hasHeightForWidth();
2868 }
3113 }
2869 int PythonQtShell_QHexSpinBox::heightForWidth(int arg__1) const
3114 int PythonQtShell_QHexSpinBox::heightForWidth(int arg__1) const
2870 {
3115 {
2871 if (_wrapper) {
3116 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2872 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
3117 static PyObject* name = PyString_FromString("heightForWidth");
2873 PyErr_Clear();
3118 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2874 if (obj && !PythonQtSlotFunction_Check(obj)) {
3119 if (obj) {
2875 static const char* argumentList[] ={"int" , "int"};
3120 static const char* argumentList[] ={"int" , "int"};
2876 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3121 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2877 int returnValue;
3122 int returnValue;
2878 void* args[2] = {NULL, (void*)&arg__1};
3123 void* args[2] = {NULL, (void*)&arg__1};
2879 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3124 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2880 if (result) {
3125 if (result) {
2881 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3126 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2882 if (args[0]!=&returnValue) {
3127 if (args[0]!=&returnValue) {
2883 if (args[0]==NULL) {
3128 if (args[0]==NULL) {
2884 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
3129 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
2885 } else {
3130 } else {
2886 returnValue = *((int*)args[0]);
3131 returnValue = *((int*)args[0]);
2887 }
3132 }
2888 }
3133 }
2889 }
3134 }
2890 if (result) { Py_DECREF(result); }
3135 if (result) { Py_DECREF(result); }
2891 Py_DECREF(obj);
3136 Py_DECREF(obj);
2892 return returnValue;
3137 return returnValue;
3138 } else {
3139 PyErr_Clear();
2893 }
3140 }
2894 }
3141 }
2895 return QHexSpinBox::heightForWidth(arg__1);
3142 return QHexSpinBox::heightForWidth(arg__1);
2896 }
3143 }
2897 void PythonQtShell_QHexSpinBox::hideEvent(QHideEvent* event)
3144 void PythonQtShell_QHexSpinBox::hideEvent(QHideEvent* event0)
2898 {
3145 {
2899 if (_wrapper) {
3146 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2900 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
3147 static PyObject* name = PyString_FromString("hideEvent");
2901 PyErr_Clear();
3148 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2902 if (obj && !PythonQtSlotFunction_Check(obj)) {
3149 if (obj) {
2903 static const char* argumentList[] ={"" , "QHideEvent*"};
3150 static const char* argumentList[] ={"" , "QHideEvent*"};
2904 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3151 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2905 void* args[2] = {NULL, (void*)&event};
3152 void* args[2] = {NULL, (void*)&event0};
2906 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3153 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2907 if (result) { Py_DECREF(result); }
3154 if (result) { Py_DECREF(result); }
2908 Py_DECREF(obj);
3155 Py_DECREF(obj);
2909 return;
3156 return;
2910 }
3157 } else {
2911 }
3158 PyErr_Clear();
2912 QHexSpinBox::hideEvent(event);
3159 }
2913 }
3160 }
2914 void PythonQtShell_QHexSpinBox::initPainter(QPainter* painter) const
3161 QHexSpinBox::hideEvent(event0);
2915 {
3162 }
2916 if (_wrapper) {
3163 void PythonQtShell_QHexSpinBox::initPainter(QPainter* painter0) const
2917 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
3164 {
2918 PyErr_Clear();
3165 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2919 if (obj && !PythonQtSlotFunction_Check(obj)) {
3166 static PyObject* name = PyString_FromString("initPainter");
3167 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3168 if (obj) {
2920 static const char* argumentList[] ={"" , "QPainter*"};
3169 static const char* argumentList[] ={"" , "QPainter*"};
2921 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3170 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2922 void* args[2] = {NULL, (void*)&painter};
3171 void* args[2] = {NULL, (void*)&painter0};
2923 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3172 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2924 if (result) { Py_DECREF(result); }
3173 if (result) { Py_DECREF(result); }
2925 Py_DECREF(obj);
3174 Py_DECREF(obj);
2926 return;
3175 return;
2927 }
3176 } else {
2928 }
3177 PyErr_Clear();
2929 QHexSpinBox::initPainter(painter);
3178 }
3179 }
3180 QHexSpinBox::initPainter(painter0);
2930 }
3181 }
2931 void PythonQtShell_QHexSpinBox::inputMethodEvent(QInputMethodEvent* arg__1)
3182 void PythonQtShell_QHexSpinBox::inputMethodEvent(QInputMethodEvent* arg__1)
2932 {
3183 {
2933 if (_wrapper) {
3184 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2934 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
3185 static PyObject* name = PyString_FromString("inputMethodEvent");
2935 PyErr_Clear();
3186 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2936 if (obj && !PythonQtSlotFunction_Check(obj)) {
3187 if (obj) {
2937 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
3188 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
2938 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3189 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2939 void* args[2] = {NULL, (void*)&arg__1};
3190 void* args[2] = {NULL, (void*)&arg__1};
2940 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3191 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2941 if (result) { Py_DECREF(result); }
3192 if (result) { Py_DECREF(result); }
2942 Py_DECREF(obj);
3193 Py_DECREF(obj);
2943 return;
3194 return;
3195 } else {
3196 PyErr_Clear();
2944 }
3197 }
2945 }
3198 }
2946 QHexSpinBox::inputMethodEvent(arg__1);
3199 QHexSpinBox::inputMethodEvent(arg__1);
2947 }
3200 }
2948 QVariant PythonQtShell_QHexSpinBox::inputMethodQuery(Qt::InputMethodQuery arg__1) const
3201 QVariant PythonQtShell_QHexSpinBox::inputMethodQuery(Qt::InputMethodQuery arg__1) const
2949 {
3202 {
2950 if (_wrapper) {
3203 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2951 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
3204 static PyObject* name = PyString_FromString("inputMethodQuery");
2952 PyErr_Clear();
3205 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2953 if (obj && !PythonQtSlotFunction_Check(obj)) {
3206 if (obj) {
2954 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
3207 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
2955 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3208 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2956 QVariant returnValue;
3209 QVariant returnValue;
2957 void* args[2] = {NULL, (void*)&arg__1};
3210 void* args[2] = {NULL, (void*)&arg__1};
2958 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3211 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2959 if (result) {
3212 if (result) {
2960 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3213 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2961 if (args[0]!=&returnValue) {
3214 if (args[0]!=&returnValue) {
2962 if (args[0]==NULL) {
3215 if (args[0]==NULL) {
2963 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
3216 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
2964 } else {
3217 } else {
2965 returnValue = *((QVariant*)args[0]);
3218 returnValue = *((QVariant*)args[0]);
2966 }
3219 }
2967 }
3220 }
2968 }
3221 }
2969 if (result) { Py_DECREF(result); }
3222 if (result) { Py_DECREF(result); }
2970 Py_DECREF(obj);
3223 Py_DECREF(obj);
2971 return returnValue;
3224 return returnValue;
3225 } else {
3226 PyErr_Clear();
2972 }
3227 }
2973 }
3228 }
2974 return QHexSpinBox::inputMethodQuery(arg__1);
3229 return QHexSpinBox::inputMethodQuery(arg__1);
2975 }
3230 }
2976 void PythonQtShell_QHexSpinBox::keyPressEvent(QKeyEvent* event)
3231 void PythonQtShell_QHexSpinBox::keyPressEvent(QKeyEvent* event0)
2977 {
3232 {
2978 if (_wrapper) {
3233 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2979 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
3234 static PyObject* name = PyString_FromString("keyPressEvent");
2980 PyErr_Clear();
3235 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2981 if (obj && !PythonQtSlotFunction_Check(obj)) {
3236 if (obj) {
2982 static const char* argumentList[] ={"" , "QKeyEvent*"};
3237 static const char* argumentList[] ={"" , "QKeyEvent*"};
2983 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3238 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2984 void* args[2] = {NULL, (void*)&event};
3239 void* args[2] = {NULL, (void*)&event0};
2985 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3240 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2986 if (result) { Py_DECREF(result); }
3241 if (result) { Py_DECREF(result); }
2987 Py_DECREF(obj);
3242 Py_DECREF(obj);
2988 return;
3243 return;
2989 }
3244 } else {
2990 }
3245 PyErr_Clear();
2991 QHexSpinBox::keyPressEvent(event);
3246 }
2992 }
3247 }
2993 void PythonQtShell_QHexSpinBox::keyReleaseEvent(QKeyEvent* event)
3248 QHexSpinBox::keyPressEvent(event0);
2994 {
3249 }
2995 if (_wrapper) {
3250 void PythonQtShell_QHexSpinBox::keyReleaseEvent(QKeyEvent* event0)
2996 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
3251 {
2997 PyErr_Clear();
3252 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2998 if (obj && !PythonQtSlotFunction_Check(obj)) {
3253 static PyObject* name = PyString_FromString("keyReleaseEvent");
3254 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3255 if (obj) {
2999 static const char* argumentList[] ={"" , "QKeyEvent*"};
3256 static const char* argumentList[] ={"" , "QKeyEvent*"};
3000 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3257 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3001 void* args[2] = {NULL, (void*)&event};
3258 void* args[2] = {NULL, (void*)&event0};
3002 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3259 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3003 if (result) { Py_DECREF(result); }
3260 if (result) { Py_DECREF(result); }
3004 Py_DECREF(obj);
3261 Py_DECREF(obj);
3005 return;
3262 return;
3006 }
3263 } else {
3007 }
3264 PyErr_Clear();
3008 QHexSpinBox::keyReleaseEvent(event);
3265 }
3266 }
3267 QHexSpinBox::keyReleaseEvent(event0);
3009 }
3268 }
3010 void PythonQtShell_QHexSpinBox::leaveEvent(QEvent* arg__1)
3269 void PythonQtShell_QHexSpinBox::leaveEvent(QEvent* arg__1)
3011 {
3270 {
3012 if (_wrapper) {
3271 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3013 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
3272 static PyObject* name = PyString_FromString("leaveEvent");
3014 PyErr_Clear();
3273 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3015 if (obj && !PythonQtSlotFunction_Check(obj)) {
3274 if (obj) {
3016 static const char* argumentList[] ={"" , "QEvent*"};
3275 static const char* argumentList[] ={"" , "QEvent*"};
3017 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3276 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3018 void* args[2] = {NULL, (void*)&arg__1};
3277 void* args[2] = {NULL, (void*)&arg__1};
3019 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3278 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3020 if (result) { Py_DECREF(result); }
3279 if (result) { Py_DECREF(result); }
3021 Py_DECREF(obj);
3280 Py_DECREF(obj);
3022 return;
3281 return;
3282 } else {
3283 PyErr_Clear();
3023 }
3284 }
3024 }
3285 }
3025 QHexSpinBox::leaveEvent(arg__1);
3286 QHexSpinBox::leaveEvent(arg__1);
3026 }
3287 }
3027 int PythonQtShell_QHexSpinBox::metric(QPaintDevice::PaintDeviceMetric arg__1) const
3288 int PythonQtShell_QHexSpinBox::metric(QPaintDevice::PaintDeviceMetric arg__1) const
3028 {
3289 {
3029 if (_wrapper) {
3290 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3030 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
3291 static PyObject* name = PyString_FromString("metric");
3031 PyErr_Clear();
3292 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3032 if (obj && !PythonQtSlotFunction_Check(obj)) {
3293 if (obj) {
3033 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
3294 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
3034 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3295 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3035 int returnValue;
3296 int returnValue;
3036 void* args[2] = {NULL, (void*)&arg__1};
3297 void* args[2] = {NULL, (void*)&arg__1};
3037 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3298 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3038 if (result) {
3299 if (result) {
3039 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3300 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3040 if (args[0]!=&returnValue) {
3301 if (args[0]!=&returnValue) {
3041 if (args[0]==NULL) {
3302 if (args[0]==NULL) {
3042 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
3303 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
3043 } else {
3304 } else {
3044 returnValue = *((int*)args[0]);
3305 returnValue = *((int*)args[0]);
3045 }
3306 }
3046 }
3307 }
3047 }
3308 }
3048 if (result) { Py_DECREF(result); }
3309 if (result) { Py_DECREF(result); }
3049 Py_DECREF(obj);
3310 Py_DECREF(obj);
3050 return returnValue;
3311 return returnValue;
3312 } else {
3313 PyErr_Clear();
3051 }
3314 }
3052 }
3315 }
3053 return QHexSpinBox::metric(arg__1);
3316 return QHexSpinBox::metric(arg__1);
3054 }
3317 }
3055 void PythonQtShell_QHexSpinBox::mouseDoubleClickEvent(QMouseEvent* arg__1)
3318 void PythonQtShell_QHexSpinBox::mouseDoubleClickEvent(QMouseEvent* arg__1)
3056 {
3319 {
3057 if (_wrapper) {
3320 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3058 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
3321 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
3059 PyErr_Clear();
3322 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3060 if (obj && !PythonQtSlotFunction_Check(obj)) {
3323 if (obj) {
3061 static const char* argumentList[] ={"" , "QMouseEvent*"};
3324 static const char* argumentList[] ={"" , "QMouseEvent*"};
3062 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3325 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3063 void* args[2] = {NULL, (void*)&arg__1};
3326 void* args[2] = {NULL, (void*)&arg__1};
3064 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3327 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3065 if (result) { Py_DECREF(result); }
3328 if (result) { Py_DECREF(result); }
3066 Py_DECREF(obj);
3329 Py_DECREF(obj);
3067 return;
3330 return;
3331 } else {
3332 PyErr_Clear();
3068 }
3333 }
3069 }
3334 }
3070 QHexSpinBox::mouseDoubleClickEvent(arg__1);
3335 QHexSpinBox::mouseDoubleClickEvent(arg__1);
3071 }
3336 }
3072 void PythonQtShell_QHexSpinBox::mouseMoveEvent(QMouseEvent* event)
3337 void PythonQtShell_QHexSpinBox::mouseMoveEvent(QMouseEvent* event0)
3073 {
3338 {
3074 if (_wrapper) {
3339 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3075 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
3340 static PyObject* name = PyString_FromString("mouseMoveEvent");
3076 PyErr_Clear();
3341 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3077 if (obj && !PythonQtSlotFunction_Check(obj)) {
3342 if (obj) {
3078 static const char* argumentList[] ={"" , "QMouseEvent*"};
3343 static const char* argumentList[] ={"" , "QMouseEvent*"};
3079 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3344 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3080 void* args[2] = {NULL, (void*)&event};
3345 void* args[2] = {NULL, (void*)&event0};
3081 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3346 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3082 if (result) { Py_DECREF(result); }
3347 if (result) { Py_DECREF(result); }
3083 Py_DECREF(obj);
3348 Py_DECREF(obj);
3084 return;
3349 return;
3085 }
3350 } else {
3086 }
3351 PyErr_Clear();
3087 QHexSpinBox::mouseMoveEvent(event);
3352 }
3088 }
3353 }
3089 void PythonQtShell_QHexSpinBox::mousePressEvent(QMouseEvent* event)
3354 QHexSpinBox::mouseMoveEvent(event0);
3090 {
3355 }
3091 if (_wrapper) {
3356 void PythonQtShell_QHexSpinBox::mousePressEvent(QMouseEvent* event0)
3092 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
3357 {
3093 PyErr_Clear();
3358 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3094 if (obj && !PythonQtSlotFunction_Check(obj)) {
3359 static PyObject* name = PyString_FromString("mousePressEvent");
3360 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3361 if (obj) {
3095 static const char* argumentList[] ={"" , "QMouseEvent*"};
3362 static const char* argumentList[] ={"" , "QMouseEvent*"};
3096 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3363 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3097 void* args[2] = {NULL, (void*)&event};
3364 void* args[2] = {NULL, (void*)&event0};
3098 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3365 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3099 if (result) { Py_DECREF(result); }
3366 if (result) { Py_DECREF(result); }
3100 Py_DECREF(obj);
3367 Py_DECREF(obj);
3101 return;
3368 return;
3102 }
3369 } else {
3103 }
3370 PyErr_Clear();
3104 QHexSpinBox::mousePressEvent(event);
3371 }
3105 }
3372 }
3106 void PythonQtShell_QHexSpinBox::mouseReleaseEvent(QMouseEvent* event)
3373 QHexSpinBox::mousePressEvent(event0);
3107 {
3374 }
3108 if (_wrapper) {
3375 void PythonQtShell_QHexSpinBox::mouseReleaseEvent(QMouseEvent* event0)
3109 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
3376 {
3110 PyErr_Clear();
3377 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3111 if (obj && !PythonQtSlotFunction_Check(obj)) {
3378 static PyObject* name = PyString_FromString("mouseReleaseEvent");
3379 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3380 if (obj) {
3112 static const char* argumentList[] ={"" , "QMouseEvent*"};
3381 static const char* argumentList[] ={"" , "QMouseEvent*"};
3113 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3382 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3114 void* args[2] = {NULL, (void*)&event};
3383 void* args[2] = {NULL, (void*)&event0};
3115 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3384 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3116 if (result) { Py_DECREF(result); }
3385 if (result) { Py_DECREF(result); }
3117 Py_DECREF(obj);
3386 Py_DECREF(obj);
3118 return;
3387 return;
3119 }
3388 } else {
3120 }
3389 PyErr_Clear();
3121 QHexSpinBox::mouseReleaseEvent(event);
3390 }
3391 }
3392 QHexSpinBox::mouseReleaseEvent(event0);
3122 }
3393 }
3123 void PythonQtShell_QHexSpinBox::moveEvent(QMoveEvent* arg__1)
3394 void PythonQtShell_QHexSpinBox::moveEvent(QMoveEvent* arg__1)
3124 {
3395 {
3125 if (_wrapper) {
3396 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3126 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
3397 static PyObject* name = PyString_FromString("moveEvent");
3127 PyErr_Clear();
3398 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3128 if (obj && !PythonQtSlotFunction_Check(obj)) {
3399 if (obj) {
3129 static const char* argumentList[] ={"" , "QMoveEvent*"};
3400 static const char* argumentList[] ={"" , "QMoveEvent*"};
3130 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3401 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3131 void* args[2] = {NULL, (void*)&arg__1};
3402 void* args[2] = {NULL, (void*)&arg__1};
3132 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3403 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3133 if (result) { Py_DECREF(result); }
3404 if (result) { Py_DECREF(result); }
3134 Py_DECREF(obj);
3405 Py_DECREF(obj);
3135 return;
3406 return;
3407 } else {
3408 PyErr_Clear();
3136 }
3409 }
3137 }
3410 }
3138 QHexSpinBox::moveEvent(arg__1);
3411 QHexSpinBox::moveEvent(arg__1);
3139 }
3412 }
3140 bool PythonQtShell_QHexSpinBox::nativeEvent(const QByteArray& eventType, void* message, long* result)
3413 bool PythonQtShell_QHexSpinBox::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
3141 {
3414 {
3142 if (_wrapper) {
3415 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3143 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
3416 static PyObject* name = PyString_FromString("nativeEvent");
3144 PyErr_Clear();
3417 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3145 if (obj && !PythonQtSlotFunction_Check(obj)) {
3418 if (obj) {
3146 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
3419 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
3147 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
3420 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
3148 bool returnValue;
3421 bool returnValue;
3149 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
3422 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
3150 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3423 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3151 if (result) {
3424 if (result) {
3152 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3425 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3153 if (args[0]!=&returnValue) {
3426 if (args[0]!=&returnValue) {
3154 if (args[0]==NULL) {
3427 if (args[0]==NULL) {
3155 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
3428 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
3156 } else {
3429 } else {
3157 returnValue = *((bool*)args[0]);
3430 returnValue = *((bool*)args[0]);
3158 }
3431 }
3159 }
3432 }
3160 }
3433 }
3161 if (result) { Py_DECREF(result); }
3434 if (result) { Py_DECREF(result); }
3162 Py_DECREF(obj);
3435 Py_DECREF(obj);
3163 return returnValue;
3436 return returnValue;
3164 }
3437 } else {
3165 }
3438 PyErr_Clear();
3166 return QHexSpinBox::nativeEvent(eventType, message, result);
3439 }
3440 }
3441 return QHexSpinBox::nativeEvent(eventType0, message1, result2);
3167 }
3442 }
3168 QPaintEngine* PythonQtShell_QHexSpinBox::paintEngine() const
3443 QPaintEngine* PythonQtShell_QHexSpinBox::paintEngine() const
3169 {
3444 {
3170 if (_wrapper) {
3445 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3171 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
3446 static PyObject* name = PyString_FromString("paintEngine");
3172 PyErr_Clear();
3447 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3173 if (obj && !PythonQtSlotFunction_Check(obj)) {
3448 if (obj) {
3174 static const char* argumentList[] ={"QPaintEngine*"};
3449 static const char* argumentList[] ={"QPaintEngine*"};
3175 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3450 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3176 QPaintEngine* returnValue;
3451 QPaintEngine* returnValue;
3177 void* args[1] = {NULL};
3452 void* args[1] = {NULL};
3178 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3453 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3179 if (result) {
3454 if (result) {
3180 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3455 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3181 if (args[0]!=&returnValue) {
3456 if (args[0]!=&returnValue) {
3182 if (args[0]==NULL) {
3457 if (args[0]==NULL) {
3183 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
3458 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
3184 } else {
3459 } else {
3185 returnValue = *((QPaintEngine**)args[0]);
3460 returnValue = *((QPaintEngine**)args[0]);
3186 }
3461 }
3187 }
3462 }
3188 }
3463 }
3189 if (result) { Py_DECREF(result); }
3464 if (result) { Py_DECREF(result); }
3190 Py_DECREF(obj);
3465 Py_DECREF(obj);
3191 return returnValue;
3466 return returnValue;
3467 } else {
3468 PyErr_Clear();
3192 }
3469 }
3193 }
3470 }
3194 return QHexSpinBox::paintEngine();
3471 return QHexSpinBox::paintEngine();
3195 }
3472 }
3196 void PythonQtShell_QHexSpinBox::paintEvent(QPaintEvent* event)
3473 void PythonQtShell_QHexSpinBox::paintEvent(QPaintEvent* event0)
3197 {
3474 {
3198 if (_wrapper) {
3475 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3199 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
3476 static PyObject* name = PyString_FromString("paintEvent");
3200 PyErr_Clear();
3477 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3201 if (obj && !PythonQtSlotFunction_Check(obj)) {
3478 if (obj) {
3202 static const char* argumentList[] ={"" , "QPaintEvent*"};
3479 static const char* argumentList[] ={"" , "QPaintEvent*"};
3203 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3480 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3204 void* args[2] = {NULL, (void*)&event};
3481 void* args[2] = {NULL, (void*)&event0};
3205 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3482 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3206 if (result) { Py_DECREF(result); }
3483 if (result) { Py_DECREF(result); }
3207 Py_DECREF(obj);
3484 Py_DECREF(obj);
3208 return;
3485 return;
3209 }
3486 } else {
3210 }
3487 PyErr_Clear();
3211 QHexSpinBox::paintEvent(event);
3488 }
3212 }
3489 }
3213 QPaintDevice* PythonQtShell_QHexSpinBox::redirected(QPoint* offset) const
3490 QHexSpinBox::paintEvent(event0);
3214 {
3491 }
3215 if (_wrapper) {
3492 QPaintDevice* PythonQtShell_QHexSpinBox::redirected(QPoint* offset0) const
3216 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
3493 {
3217 PyErr_Clear();
3494 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3218 if (obj && !PythonQtSlotFunction_Check(obj)) {
3495 static PyObject* name = PyString_FromString("redirected");
3496 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3497 if (obj) {
3219 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
3498 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
3220 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3499 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3221 QPaintDevice* returnValue;
3500 QPaintDevice* returnValue;
3222 void* args[2] = {NULL, (void*)&offset};
3501 void* args[2] = {NULL, (void*)&offset0};
3223 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3502 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3224 if (result) {
3503 if (result) {
3225 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3504 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3226 if (args[0]!=&returnValue) {
3505 if (args[0]!=&returnValue) {
3227 if (args[0]==NULL) {
3506 if (args[0]==NULL) {
3228 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
3507 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
3229 } else {
3508 } else {
3230 returnValue = *((QPaintDevice**)args[0]);
3509 returnValue = *((QPaintDevice**)args[0]);
3231 }
3510 }
3232 }
3511 }
3233 }
3512 }
3234 if (result) { Py_DECREF(result); }
3513 if (result) { Py_DECREF(result); }
3235 Py_DECREF(obj);
3514 Py_DECREF(obj);
3236 return returnValue;
3515 return returnValue;
3237 }
3516 } else {
3238 }
3517 PyErr_Clear();
3239 return QHexSpinBox::redirected(offset);
3518 }
3240 }
3519 }
3241 void PythonQtShell_QHexSpinBox::resizeEvent(QResizeEvent* event)
3520 return QHexSpinBox::redirected(offset0);
3242 {
3521 }
3243 if (_wrapper) {
3522 void PythonQtShell_QHexSpinBox::resizeEvent(QResizeEvent* event0)
3244 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
3523 {
3245 PyErr_Clear();
3524 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3246 if (obj && !PythonQtSlotFunction_Check(obj)) {
3525 static PyObject* name = PyString_FromString("resizeEvent");
3526 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3527 if (obj) {
3247 static const char* argumentList[] ={"" , "QResizeEvent*"};
3528 static const char* argumentList[] ={"" , "QResizeEvent*"};
3248 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3529 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3249 void* args[2] = {NULL, (void*)&event};
3530 void* args[2] = {NULL, (void*)&event0};
3250 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3531 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3251 if (result) { Py_DECREF(result); }
3532 if (result) { Py_DECREF(result); }
3252 Py_DECREF(obj);
3533 Py_DECREF(obj);
3253 return;
3534 return;
3254 }
3535 } else {
3255 }
3536 PyErr_Clear();
3256 QHexSpinBox::resizeEvent(event);
3537 }
3538 }
3539 QHexSpinBox::resizeEvent(event0);
3257 }
3540 }
3258 QPainter* PythonQtShell_QHexSpinBox::sharedPainter() const
3541 QPainter* PythonQtShell_QHexSpinBox::sharedPainter() const
3259 {
3542 {
3260 if (_wrapper) {
3543 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3261 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
3544 static PyObject* name = PyString_FromString("sharedPainter");
3262 PyErr_Clear();
3545 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3263 if (obj && !PythonQtSlotFunction_Check(obj)) {
3546 if (obj) {
3264 static const char* argumentList[] ={"QPainter*"};
3547 static const char* argumentList[] ={"QPainter*"};
3265 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3548 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3266 QPainter* returnValue;
3549 QPainter* returnValue;
3267 void* args[1] = {NULL};
3550 void* args[1] = {NULL};
3268 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3551 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3269 if (result) {
3552 if (result) {
3270 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3553 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3271 if (args[0]!=&returnValue) {
3554 if (args[0]!=&returnValue) {
3272 if (args[0]==NULL) {
3555 if (args[0]==NULL) {
3273 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
3556 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
3274 } else {
3557 } else {
3275 returnValue = *((QPainter**)args[0]);
3558 returnValue = *((QPainter**)args[0]);
3276 }
3559 }
3277 }
3560 }
3278 }
3561 }
3279 if (result) { Py_DECREF(result); }
3562 if (result) { Py_DECREF(result); }
3280 Py_DECREF(obj);
3563 Py_DECREF(obj);
3281 return returnValue;
3564 return returnValue;
3565 } else {
3566 PyErr_Clear();
3282 }
3567 }
3283 }
3568 }
3284 return QHexSpinBox::sharedPainter();
3569 return QHexSpinBox::sharedPainter();
3285 }
3570 }
3286 void PythonQtShell_QHexSpinBox::showEvent(QShowEvent* event)
3571 void PythonQtShell_QHexSpinBox::showEvent(QShowEvent* event0)
3287 {
3572 {
3288 if (_wrapper) {
3573 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3289 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
3574 static PyObject* name = PyString_FromString("showEvent");
3290 PyErr_Clear();
3575 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3291 if (obj && !PythonQtSlotFunction_Check(obj)) {
3576 if (obj) {
3292 static const char* argumentList[] ={"" , "QShowEvent*"};
3577 static const char* argumentList[] ={"" , "QShowEvent*"};
3293 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3578 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3294 void* args[2] = {NULL, (void*)&event};
3579 void* args[2] = {NULL, (void*)&event0};
3295 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3580 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3296 if (result) { Py_DECREF(result); }
3581 if (result) { Py_DECREF(result); }
3297 Py_DECREF(obj);
3582 Py_DECREF(obj);
3298 return;
3583 return;
3299 }
3584 } else {
3300 }
3585 PyErr_Clear();
3301 QHexSpinBox::showEvent(event);
3586 }
3302 }
3587 }
3303 void PythonQtShell_QHexSpinBox::stepBy(int steps)
3588 QHexSpinBox::showEvent(event0);
3304 {
3589 }
3305 if (_wrapper) {
3590 void PythonQtShell_QHexSpinBox::stepBy(int steps0)
3306 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepBy");
3591 {
3307 PyErr_Clear();
3592 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3308 if (obj && !PythonQtSlotFunction_Check(obj)) {
3593 static PyObject* name = PyString_FromString("stepBy");
3594 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3595 if (obj) {
3309 static const char* argumentList[] ={"" , "int"};
3596 static const char* argumentList[] ={"" , "int"};
3310 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3597 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3311 void* args[2] = {NULL, (void*)&steps};
3598 void* args[2] = {NULL, (void*)&steps0};
3312 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3599 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3313 if (result) { Py_DECREF(result); }
3600 if (result) { Py_DECREF(result); }
3314 Py_DECREF(obj);
3601 Py_DECREF(obj);
3315 return;
3602 return;
3316 }
3603 } else {
3317 }
3604 PyErr_Clear();
3318 QHexSpinBox::stepBy(steps);
3605 }
3606 }
3607 QHexSpinBox::stepBy(steps0);
3319 }
3608 }
3320 QAbstractSpinBox::StepEnabled PythonQtShell_QHexSpinBox::stepEnabled() const
3609 QAbstractSpinBox::StepEnabled PythonQtShell_QHexSpinBox::stepEnabled() const
3321 {
3610 {
3322 if (_wrapper) {
3611 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3323 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepEnabled");
3612 static PyObject* name = PyString_FromString("stepEnabled");
3324 PyErr_Clear();
3613 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3325 if (obj && !PythonQtSlotFunction_Check(obj)) {
3614 if (obj) {
3326 static const char* argumentList[] ={"QAbstractSpinBox::StepEnabled"};
3615 static const char* argumentList[] ={"QAbstractSpinBox::StepEnabled"};
3327 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3616 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3328 QAbstractSpinBox::StepEnabled returnValue;
3617 QAbstractSpinBox::StepEnabled returnValue;
3329 void* args[1] = {NULL};
3618 void* args[1] = {NULL};
3330 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3619 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3331 if (result) {
3620 if (result) {
3332 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3621 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3333 if (args[0]!=&returnValue) {
3622 if (args[0]!=&returnValue) {
3334 if (args[0]==NULL) {
3623 if (args[0]==NULL) {
3335 PythonQt::priv()->handleVirtualOverloadReturnError("stepEnabled", methodInfo, result);
3624 PythonQt::priv()->handleVirtualOverloadReturnError("stepEnabled", methodInfo, result);
3336 } else {
3625 } else {
3337 returnValue = *((QAbstractSpinBox::StepEnabled*)args[0]);
3626 returnValue = *((QAbstractSpinBox::StepEnabled*)args[0]);
3338 }
3627 }
3339 }
3628 }
3340 }
3629 }
3341 if (result) { Py_DECREF(result); }
3630 if (result) { Py_DECREF(result); }
3342 Py_DECREF(obj);
3631 Py_DECREF(obj);
3343 return returnValue;
3632 return returnValue;
3633 } else {
3634 PyErr_Clear();
3344 }
3635 }
3345 }
3636 }
3346 return QHexSpinBox::stepEnabled();
3637 return QHexSpinBox::stepEnabled();
3347 }
3638 }
3348 void PythonQtShell_QHexSpinBox::tabletEvent(QTabletEvent* arg__1)
3639 void PythonQtShell_QHexSpinBox::tabletEvent(QTabletEvent* arg__1)
3349 {
3640 {
3350 if (_wrapper) {
3641 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3351 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
3642 static PyObject* name = PyString_FromString("tabletEvent");
3352 PyErr_Clear();
3643 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3353 if (obj && !PythonQtSlotFunction_Check(obj)) {
3644 if (obj) {
3354 static const char* argumentList[] ={"" , "QTabletEvent*"};
3645 static const char* argumentList[] ={"" , "QTabletEvent*"};
3355 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3646 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3356 void* args[2] = {NULL, (void*)&arg__1};
3647 void* args[2] = {NULL, (void*)&arg__1};
3357 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3648 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3358 if (result) { Py_DECREF(result); }
3649 if (result) { Py_DECREF(result); }
3359 Py_DECREF(obj);
3650 Py_DECREF(obj);
3360 return;
3651 return;
3652 } else {
3653 PyErr_Clear();
3361 }
3654 }
3362 }
3655 }
3363 QHexSpinBox::tabletEvent(arg__1);
3656 QHexSpinBox::tabletEvent(arg__1);
3364 }
3657 }
3365 QString PythonQtShell_QHexSpinBox::textFromValue(int value) const
3658 QString PythonQtShell_QHexSpinBox::textFromValue(int value0) const
3366 {
3659 {
3367 if (_wrapper) {
3660 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3368 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "textFromValue");
3661 static PyObject* name = PyString_FromString("textFromValue");
3369 PyErr_Clear();
3662 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3370 if (obj && !PythonQtSlotFunction_Check(obj)) {
3663 if (obj) {
3371 static const char* argumentList[] ={"QString" , "int"};
3664 static const char* argumentList[] ={"QString" , "int"};
3372 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3665 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3373 QString returnValue;
3666 QString returnValue;
3374 void* args[2] = {NULL, (void*)&value};
3667 void* args[2] = {NULL, (void*)&value0};
3375 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3668 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3376 if (result) {
3669 if (result) {
3377 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3670 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3378 if (args[0]!=&returnValue) {
3671 if (args[0]!=&returnValue) {
3379 if (args[0]==NULL) {
3672 if (args[0]==NULL) {
3380 PythonQt::priv()->handleVirtualOverloadReturnError("textFromValue", methodInfo, result);
3673 PythonQt::priv()->handleVirtualOverloadReturnError("textFromValue", methodInfo, result);
3381 } else {
3674 } else {
3382 returnValue = *((QString*)args[0]);
3675 returnValue = *((QString*)args[0]);
3383 }
3676 }
3384 }
3677 }
3385 }
3678 }
3386 if (result) { Py_DECREF(result); }
3679 if (result) { Py_DECREF(result); }
3387 Py_DECREF(obj);
3680 Py_DECREF(obj);
3388 return returnValue;
3681 return returnValue;
3389 }
3682 } else {
3390 }
3683 PyErr_Clear();
3391 return QHexSpinBox::textFromValue(value);
3684 }
3392 }
3685 }
3393 void PythonQtShell_QHexSpinBox::timerEvent(QTimerEvent* event)
3686 return QHexSpinBox::textFromValue(value0);
3394 {
3687 }
3395 if (_wrapper) {
3688 void PythonQtShell_QHexSpinBox::timerEvent(QTimerEvent* event0)
3396 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
3689 {
3397 PyErr_Clear();
3690 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3398 if (obj && !PythonQtSlotFunction_Check(obj)) {
3691 static PyObject* name = PyString_FromString("timerEvent");
3692 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3693 if (obj) {
3399 static const char* argumentList[] ={"" , "QTimerEvent*"};
3694 static const char* argumentList[] ={"" , "QTimerEvent*"};
3400 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3695 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3401 void* args[2] = {NULL, (void*)&event};
3696 void* args[2] = {NULL, (void*)&event0};
3402 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3697 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3403 if (result) { Py_DECREF(result); }
3698 if (result) { Py_DECREF(result); }
3404 Py_DECREF(obj);
3699 Py_DECREF(obj);
3405 return;
3700 return;
3406 }
3701 } else {
3407 }
3702 PyErr_Clear();
3408 QHexSpinBox::timerEvent(event);
3703 }
3409 }
3704 }
3410 QValidator::State PythonQtShell_QHexSpinBox::validate(QString& input, int& pos) const
3705 QHexSpinBox::timerEvent(event0);
3411 {
3706 }
3412 if (_wrapper) {
3707 QValidator::State PythonQtShell_QHexSpinBox::validate(QString& input0, int& pos1) const
3413 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "validate");
3708 {
3414 PyErr_Clear();
3709 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3415 if (obj && !PythonQtSlotFunction_Check(obj)) {
3710 static PyObject* name = PyString_FromString("validate");
3711 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3712 if (obj) {
3416 static const char* argumentList[] ={"QValidator::State" , "QString&" , "int&"};
3713 static const char* argumentList[] ={"QValidator::State" , "QString&" , "int&"};
3417 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3714 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3418 QValidator::State returnValue;
3715 QValidator::State returnValue;
3419 void* args[3] = {NULL, (void*)&input, (void*)&pos};
3716 void* args[3] = {NULL, (void*)&input0, (void*)&pos1};
3420 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3717 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3421 if (result) {
3718 if (result) {
3422 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3719 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3423 if (args[0]!=&returnValue) {
3720 if (args[0]!=&returnValue) {
3424 if (args[0]==NULL) {
3721 if (args[0]==NULL) {
3425 PythonQt::priv()->handleVirtualOverloadReturnError("validate", methodInfo, result);
3722 PythonQt::priv()->handleVirtualOverloadReturnError("validate", methodInfo, result);
3426 } else {
3723 } else {
3427 returnValue = *((QValidator::State*)args[0]);
3724 returnValue = *((QValidator::State*)args[0]);
3428 }
3725 }
3429 }
3726 }
3430 }
3727 }
3431 if (result) { Py_DECREF(result); }
3728 if (result) { Py_DECREF(result); }
3432 Py_DECREF(obj);
3729 Py_DECREF(obj);
3433 return returnValue;
3730 return returnValue;
3434 }
3731 } else {
3435 }
3732 PyErr_Clear();
3436 return QHexSpinBox::validate(input, pos);
3733 }
3437 }
3734 }
3438 int PythonQtShell_QHexSpinBox::valueFromText(const QString& text) const
3735 return QHexSpinBox::validate(input0, pos1);
3439 {
3736 }
3440 if (_wrapper) {
3737 int PythonQtShell_QHexSpinBox::valueFromText(const QString& text0) const
3441 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "valueFromText");
3738 {
3442 PyErr_Clear();
3739 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3443 if (obj && !PythonQtSlotFunction_Check(obj)) {
3740 static PyObject* name = PyString_FromString("valueFromText");
3741 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3742 if (obj) {
3444 static const char* argumentList[] ={"int" , "const QString&"};
3743 static const char* argumentList[] ={"int" , "const QString&"};
3445 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3744 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3446 int returnValue;
3745 int returnValue;
3447 void* args[2] = {NULL, (void*)&text};
3746 void* args[2] = {NULL, (void*)&text0};
3448 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3747 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3449 if (result) {
3748 if (result) {
3450 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3749 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3451 if (args[0]!=&returnValue) {
3750 if (args[0]!=&returnValue) {
3452 if (args[0]==NULL) {
3751 if (args[0]==NULL) {
3453 PythonQt::priv()->handleVirtualOverloadReturnError("valueFromText", methodInfo, result);
3752 PythonQt::priv()->handleVirtualOverloadReturnError("valueFromText", methodInfo, result);
3454 } else {
3753 } else {
3455 returnValue = *((int*)args[0]);
3754 returnValue = *((int*)args[0]);
3456 }
3755 }
3457 }
3756 }
3458 }
3757 }
3459 if (result) { Py_DECREF(result); }
3758 if (result) { Py_DECREF(result); }
3460 Py_DECREF(obj);
3759 Py_DECREF(obj);
3461 return returnValue;
3760 return returnValue;
3462 }
3761 } else {
3463 }
3762 PyErr_Clear();
3464 return QHexSpinBox::valueFromText(text);
3763 }
3465 }
3764 }
3466 void PythonQtShell_QHexSpinBox::wheelEvent(QWheelEvent* event)
3765 return QHexSpinBox::valueFromText(text0);
3467 {
3766 }
3468 if (_wrapper) {
3767 void PythonQtShell_QHexSpinBox::wheelEvent(QWheelEvent* event0)
3469 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
3768 {
3470 PyErr_Clear();
3769 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3471 if (obj && !PythonQtSlotFunction_Check(obj)) {
3770 static PyObject* name = PyString_FromString("wheelEvent");
3771 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3772 if (obj) {
3472 static const char* argumentList[] ={"" , "QWheelEvent*"};
3773 static const char* argumentList[] ={"" , "QWheelEvent*"};
3473 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3774 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3474 void* args[2] = {NULL, (void*)&event};
3775 void* args[2] = {NULL, (void*)&event0};
3475 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3776 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3476 if (result) { Py_DECREF(result); }
3777 if (result) { Py_DECREF(result); }
3477 Py_DECREF(obj);
3778 Py_DECREF(obj);
3478 return;
3779 return;
3479 }
3780 } else {
3480 }
3781 PyErr_Clear();
3481 QHexSpinBox::wheelEvent(event);
3782 }
3783 }
3784 QHexSpinBox::wheelEvent(event0);
3482 }
3785 }
3483 QHexSpinBox* PythonQtWrapper_QHexSpinBox::new_QHexSpinBox(QWidget* parent)
3786 QHexSpinBox* PythonQtWrapper_QHexSpinBox::new_QHexSpinBox(QWidget* parent)
3484 {
3787 {
3485 return new PythonQtShell_QHexSpinBox(parent); }
3788 return new PythonQtShell_QHexSpinBox(parent); }
3486
3789
3487 void PythonQtWrapper_QHexSpinBox::show(QHexSpinBox* theWrappedObject)
3790 void PythonQtWrapper_QHexSpinBox::show(QHexSpinBox* theWrappedObject)
3488 {
3791 {
3489 ( theWrappedObject->show());
3792 ( theWrappedObject->show());
3490 }
3793 }
3491
3794
3492 QString PythonQtWrapper_QHexSpinBox::textFromValue(QHexSpinBox* theWrappedObject, int value) const
3795 QString PythonQtWrapper_QHexSpinBox::textFromValue(QHexSpinBox* theWrappedObject, int value) const
3493 {
3796 {
3494 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_textFromValue(value));
3797 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_textFromValue(value));
3495 }
3798 }
3496
3799
3497 QValidator::State PythonQtWrapper_QHexSpinBox::validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const
3800 QValidator::State PythonQtWrapper_QHexSpinBox::validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const
3498 {
3801 {
3499 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_validate(input, pos));
3802 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_validate(input, pos));
3500 }
3803 }
3501
3804
3502 int PythonQtWrapper_QHexSpinBox::valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const
3805 int PythonQtWrapper_QHexSpinBox::valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const
3503 {
3806 {
3504 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_valueFromText(text));
3807 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_valueFromText(text));
3505 }
3808 }
3506
3809
3507
3810
3508
3811
3509 PythonQtShell_SocExplorerPlot::~PythonQtShell_SocExplorerPlot() {
3812 PythonQtShell_SocExplorerPlot::~PythonQtShell_SocExplorerPlot() {
3510 PythonQtPrivate* priv = PythonQt::priv();
3813 PythonQtPrivate* priv = PythonQt::priv();
3511 if (priv) { priv->shellClassDeleted(this); }
3814 if (priv) { priv->shellClassDeleted(this); }
3512 }
3815 }
3513 void PythonQtShell_SocExplorerPlot::actionEvent(QActionEvent* arg__1)
3816 void PythonQtShell_SocExplorerPlot::actionEvent(QActionEvent* arg__1)
3514 {
3817 {
3515 if (_wrapper) {
3818 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3516 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
3819 static PyObject* name = PyString_FromString("actionEvent");
3517 PyErr_Clear();
3820 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3518 if (obj && !PythonQtSlotFunction_Check(obj)) {
3821 if (obj) {
3519 static const char* argumentList[] ={"" , "QActionEvent*"};
3822 static const char* argumentList[] ={"" , "QActionEvent*"};
3520 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3823 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3521 void* args[2] = {NULL, (void*)&arg__1};
3824 void* args[2] = {NULL, (void*)&arg__1};
3522 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3825 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3523 if (result) { Py_DECREF(result); }
3826 if (result) { Py_DECREF(result); }
3524 Py_DECREF(obj);
3827 Py_DECREF(obj);
3525 return;
3828 return;
3829 } else {
3830 PyErr_Clear();
3526 }
3831 }
3527 }
3832 }
3528 SocExplorerPlot::actionEvent(arg__1);
3833 SocExplorerPlot::actionEvent(arg__1);
3529 }
3834 }
3530 void PythonQtShell_SocExplorerPlot::changeEvent(QEvent* arg__1)
3835 void PythonQtShell_SocExplorerPlot::changeEvent(QEvent* arg__1)
3531 {
3836 {
3532 if (_wrapper) {
3837 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3533 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
3838 static PyObject* name = PyString_FromString("changeEvent");
3534 PyErr_Clear();
3839 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3535 if (obj && !PythonQtSlotFunction_Check(obj)) {
3840 if (obj) {
3536 static const char* argumentList[] ={"" , "QEvent*"};
3841 static const char* argumentList[] ={"" , "QEvent*"};
3537 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3842 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3538 void* args[2] = {NULL, (void*)&arg__1};
3843 void* args[2] = {NULL, (void*)&arg__1};
3539 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3844 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3540 if (result) { Py_DECREF(result); }
3845 if (result) { Py_DECREF(result); }
3541 Py_DECREF(obj);
3846 Py_DECREF(obj);
3542 return;
3847 return;
3848 } else {
3849 PyErr_Clear();
3543 }
3850 }
3544 }
3851 }
3545 SocExplorerPlot::changeEvent(arg__1);
3852 SocExplorerPlot::changeEvent(arg__1);
3546 }
3853 }
3547 void PythonQtShell_SocExplorerPlot::childEvent(QChildEvent* arg__1)
3854 void PythonQtShell_SocExplorerPlot::childEvent(QChildEvent* arg__1)
3548 {
3855 {
3549 if (_wrapper) {
3856 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3550 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
3857 static PyObject* name = PyString_FromString("childEvent");
3551 PyErr_Clear();
3858 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3552 if (obj && !PythonQtSlotFunction_Check(obj)) {
3859 if (obj) {
3553 static const char* argumentList[] ={"" , "QChildEvent*"};
3860 static const char* argumentList[] ={"" , "QChildEvent*"};
3554 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3861 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3555 void* args[2] = {NULL, (void*)&arg__1};
3862 void* args[2] = {NULL, (void*)&arg__1};
3556 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3863 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3557 if (result) { Py_DECREF(result); }
3864 if (result) { Py_DECREF(result); }
3558 Py_DECREF(obj);
3865 Py_DECREF(obj);
3559 return;
3866 return;
3867 } else {
3868 PyErr_Clear();
3560 }
3869 }
3561 }
3870 }
3562 SocExplorerPlot::childEvent(arg__1);
3871 SocExplorerPlot::childEvent(arg__1);
3563 }
3872 }
3564 void PythonQtShell_SocExplorerPlot::closeEvent(QCloseEvent* arg__1)
3873 void PythonQtShell_SocExplorerPlot::closeEvent(QCloseEvent* arg__1)
3565 {
3874 {
3566 if (_wrapper) {
3875 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3567 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
3876 static PyObject* name = PyString_FromString("closeEvent");
3568 PyErr_Clear();
3877 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3569 if (obj && !PythonQtSlotFunction_Check(obj)) {
3878 if (obj) {
3570 static const char* argumentList[] ={"" , "QCloseEvent*"};
3879 static const char* argumentList[] ={"" , "QCloseEvent*"};
3571 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3880 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3572 void* args[2] = {NULL, (void*)&arg__1};
3881 void* args[2] = {NULL, (void*)&arg__1};
3573 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3882 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3574 if (result) { Py_DECREF(result); }
3883 if (result) { Py_DECREF(result); }
3575 Py_DECREF(obj);
3884 Py_DECREF(obj);
3576 return;
3885 return;
3886 } else {
3887 PyErr_Clear();
3577 }
3888 }
3578 }
3889 }
3579 SocExplorerPlot::closeEvent(arg__1);
3890 SocExplorerPlot::closeEvent(arg__1);
3580 }
3891 }
3581 void PythonQtShell_SocExplorerPlot::contextMenuEvent(QContextMenuEvent* arg__1)
3892 void PythonQtShell_SocExplorerPlot::contextMenuEvent(QContextMenuEvent* arg__1)
3582 {
3893 {
3583 if (_wrapper) {
3894 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3584 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
3895 static PyObject* name = PyString_FromString("contextMenuEvent");
3585 PyErr_Clear();
3896 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3586 if (obj && !PythonQtSlotFunction_Check(obj)) {
3897 if (obj) {
3587 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
3898 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
3588 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3899 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3589 void* args[2] = {NULL, (void*)&arg__1};
3900 void* args[2] = {NULL, (void*)&arg__1};
3590 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3901 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3591 if (result) { Py_DECREF(result); }
3902 if (result) { Py_DECREF(result); }
3592 Py_DECREF(obj);
3903 Py_DECREF(obj);
3593 return;
3904 return;
3905 } else {
3906 PyErr_Clear();
3594 }
3907 }
3595 }
3908 }
3596 SocExplorerPlot::contextMenuEvent(arg__1);
3909 SocExplorerPlot::contextMenuEvent(arg__1);
3597 }
3910 }
3598 void PythonQtShell_SocExplorerPlot::customEvent(QEvent* arg__1)
3911 void PythonQtShell_SocExplorerPlot::customEvent(QEvent* arg__1)
3599 {
3912 {
3600 if (_wrapper) {
3913 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3601 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
3914 static PyObject* name = PyString_FromString("customEvent");
3602 PyErr_Clear();
3915 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3603 if (obj && !PythonQtSlotFunction_Check(obj)) {
3916 if (obj) {
3604 static const char* argumentList[] ={"" , "QEvent*"};
3917 static const char* argumentList[] ={"" , "QEvent*"};
3605 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3918 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3606 void* args[2] = {NULL, (void*)&arg__1};
3919 void* args[2] = {NULL, (void*)&arg__1};
3607 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3920 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3608 if (result) { Py_DECREF(result); }
3921 if (result) { Py_DECREF(result); }
3609 Py_DECREF(obj);
3922 Py_DECREF(obj);
3610 return;
3923 return;
3924 } else {
3925 PyErr_Clear();
3611 }
3926 }
3612 }
3927 }
3613 SocExplorerPlot::customEvent(arg__1);
3928 SocExplorerPlot::customEvent(arg__1);
3614 }
3929 }
3615 int PythonQtShell_SocExplorerPlot::devType() const
3930 int PythonQtShell_SocExplorerPlot::devType() const
3616 {
3931 {
3617 if (_wrapper) {
3932 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3618 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
3933 static PyObject* name = PyString_FromString("devType");
3619 PyErr_Clear();
3934 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3620 if (obj && !PythonQtSlotFunction_Check(obj)) {
3935 if (obj) {
3621 static const char* argumentList[] ={"int"};
3936 static const char* argumentList[] ={"int"};
3622 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3937 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3623 int returnValue;
3938 int returnValue;
3624 void* args[1] = {NULL};
3939 void* args[1] = {NULL};
3625 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3940 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3626 if (result) {
3941 if (result) {
3627 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3942 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3628 if (args[0]!=&returnValue) {
3943 if (args[0]!=&returnValue) {
3629 if (args[0]==NULL) {
3944 if (args[0]==NULL) {
3630 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
3945 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
3631 } else {
3946 } else {
3632 returnValue = *((int*)args[0]);
3947 returnValue = *((int*)args[0]);
3633 }
3948 }
3634 }
3949 }
3635 }
3950 }
3636 if (result) { Py_DECREF(result); }
3951 if (result) { Py_DECREF(result); }
3637 Py_DECREF(obj);
3952 Py_DECREF(obj);
3638 return returnValue;
3953 return returnValue;
3954 } else {
3955 PyErr_Clear();
3639 }
3956 }
3640 }
3957 }
3641 return SocExplorerPlot::devType();
3958 return SocExplorerPlot::devType();
3642 }
3959 }
3643 void PythonQtShell_SocExplorerPlot::dragEnterEvent(QDragEnterEvent* arg__1)
3960 void PythonQtShell_SocExplorerPlot::dragEnterEvent(QDragEnterEvent* arg__1)
3644 {
3961 {
3645 if (_wrapper) {
3962 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3646 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
3963 static PyObject* name = PyString_FromString("dragEnterEvent");
3647 PyErr_Clear();
3964 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3648 if (obj && !PythonQtSlotFunction_Check(obj)) {
3965 if (obj) {
3649 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
3966 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
3650 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3967 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3651 void* args[2] = {NULL, (void*)&arg__1};
3968 void* args[2] = {NULL, (void*)&arg__1};
3652 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3969 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3653 if (result) { Py_DECREF(result); }
3970 if (result) { Py_DECREF(result); }
3654 Py_DECREF(obj);
3971 Py_DECREF(obj);
3655 return;
3972 return;
3973 } else {
3974 PyErr_Clear();
3656 }
3975 }
3657 }
3976 }
3658 SocExplorerPlot::dragEnterEvent(arg__1);
3977 SocExplorerPlot::dragEnterEvent(arg__1);
3659 }
3978 }
3660 void PythonQtShell_SocExplorerPlot::dragLeaveEvent(QDragLeaveEvent* arg__1)
3979 void PythonQtShell_SocExplorerPlot::dragLeaveEvent(QDragLeaveEvent* arg__1)
3661 {
3980 {
3662 if (_wrapper) {
3981 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3663 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
3982 static PyObject* name = PyString_FromString("dragLeaveEvent");
3664 PyErr_Clear();
3983 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3665 if (obj && !PythonQtSlotFunction_Check(obj)) {
3984 if (obj) {
3666 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
3985 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
3667 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3986 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3668 void* args[2] = {NULL, (void*)&arg__1};
3987 void* args[2] = {NULL, (void*)&arg__1};
3669 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3988 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3670 if (result) { Py_DECREF(result); }
3989 if (result) { Py_DECREF(result); }
3671 Py_DECREF(obj);
3990 Py_DECREF(obj);
3672 return;
3991 return;
3992 } else {
3993 PyErr_Clear();
3673 }
3994 }
3674 }
3995 }
3675 SocExplorerPlot::dragLeaveEvent(arg__1);
3996 SocExplorerPlot::dragLeaveEvent(arg__1);
3676 }
3997 }
3677 void PythonQtShell_SocExplorerPlot::dragMoveEvent(QDragMoveEvent* arg__1)
3998 void PythonQtShell_SocExplorerPlot::dragMoveEvent(QDragMoveEvent* arg__1)
3678 {
3999 {
3679 if (_wrapper) {
4000 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3680 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
4001 static PyObject* name = PyString_FromString("dragMoveEvent");
3681 PyErr_Clear();
4002 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3682 if (obj && !PythonQtSlotFunction_Check(obj)) {
4003 if (obj) {
3683 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
4004 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
3684 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4005 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3685 void* args[2] = {NULL, (void*)&arg__1};
4006 void* args[2] = {NULL, (void*)&arg__1};
3686 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4007 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3687 if (result) { Py_DECREF(result); }
4008 if (result) { Py_DECREF(result); }
3688 Py_DECREF(obj);
4009 Py_DECREF(obj);
3689 return;
4010 return;
4011 } else {
4012 PyErr_Clear();
3690 }
4013 }
3691 }
4014 }
3692 SocExplorerPlot::dragMoveEvent(arg__1);
4015 SocExplorerPlot::dragMoveEvent(arg__1);
3693 }
4016 }
3694 void PythonQtShell_SocExplorerPlot::dropEvent(QDropEvent* arg__1)
4017 void PythonQtShell_SocExplorerPlot::dropEvent(QDropEvent* arg__1)
3695 {
4018 {
3696 if (_wrapper) {
4019 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3697 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
4020 static PyObject* name = PyString_FromString("dropEvent");
3698 PyErr_Clear();
4021 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3699 if (obj && !PythonQtSlotFunction_Check(obj)) {
4022 if (obj) {
3700 static const char* argumentList[] ={"" , "QDropEvent*"};
4023 static const char* argumentList[] ={"" , "QDropEvent*"};
3701 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4024 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3702 void* args[2] = {NULL, (void*)&arg__1};
4025 void* args[2] = {NULL, (void*)&arg__1};
3703 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4026 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3704 if (result) { Py_DECREF(result); }
4027 if (result) { Py_DECREF(result); }
3705 Py_DECREF(obj);
4028 Py_DECREF(obj);
3706 return;
4029 return;
4030 } else {
4031 PyErr_Clear();
3707 }
4032 }
3708 }
4033 }
3709 SocExplorerPlot::dropEvent(arg__1);
4034 SocExplorerPlot::dropEvent(arg__1);
3710 }
4035 }
3711 void PythonQtShell_SocExplorerPlot::enterEvent(QEvent* arg__1)
4036 void PythonQtShell_SocExplorerPlot::enterEvent(QEvent* arg__1)
3712 {
4037 {
3713 if (_wrapper) {
4038 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3714 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
4039 static PyObject* name = PyString_FromString("enterEvent");
3715 PyErr_Clear();
4040 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3716 if (obj && !PythonQtSlotFunction_Check(obj)) {
4041 if (obj) {
3717 static const char* argumentList[] ={"" , "QEvent*"};
4042 static const char* argumentList[] ={"" , "QEvent*"};
3718 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4043 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3719 void* args[2] = {NULL, (void*)&arg__1};
4044 void* args[2] = {NULL, (void*)&arg__1};
3720 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4045 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3721 if (result) { Py_DECREF(result); }
4046 if (result) { Py_DECREF(result); }
3722 Py_DECREF(obj);
4047 Py_DECREF(obj);
3723 return;
4048 return;
4049 } else {
4050 PyErr_Clear();
3724 }
4051 }
3725 }
4052 }
3726 SocExplorerPlot::enterEvent(arg__1);
4053 SocExplorerPlot::enterEvent(arg__1);
3727 }
4054 }
3728 bool PythonQtShell_SocExplorerPlot::event(QEvent* arg__1)
4055 bool PythonQtShell_SocExplorerPlot::event(QEvent* arg__1)
3729 {
4056 {
3730 if (_wrapper) {
4057 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3731 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
4058 static PyObject* name = PyString_FromString("event");
3732 PyErr_Clear();
4059 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3733 if (obj && !PythonQtSlotFunction_Check(obj)) {
4060 if (obj) {
3734 static const char* argumentList[] ={"bool" , "QEvent*"};
4061 static const char* argumentList[] ={"bool" , "QEvent*"};
3735 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4062 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3736 bool returnValue;
4063 bool returnValue;
3737 void* args[2] = {NULL, (void*)&arg__1};
4064 void* args[2] = {NULL, (void*)&arg__1};
3738 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4065 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3739 if (result) {
4066 if (result) {
3740 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4067 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3741 if (args[0]!=&returnValue) {
4068 if (args[0]!=&returnValue) {
3742 if (args[0]==NULL) {
4069 if (args[0]==NULL) {
3743 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
4070 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
3744 } else {
4071 } else {
3745 returnValue = *((bool*)args[0]);
4072 returnValue = *((bool*)args[0]);
3746 }
4073 }
3747 }
4074 }
3748 }
4075 }
3749 if (result) { Py_DECREF(result); }
4076 if (result) { Py_DECREF(result); }
3750 Py_DECREF(obj);
4077 Py_DECREF(obj);
3751 return returnValue;
4078 return returnValue;
4079 } else {
4080 PyErr_Clear();
3752 }
4081 }
3753 }
4082 }
3754 return SocExplorerPlot::event(arg__1);
4083 return SocExplorerPlot::event(arg__1);
3755 }
4084 }
3756 bool PythonQtShell_SocExplorerPlot::eventFilter(QObject* arg__1, QEvent* arg__2)
4085 bool PythonQtShell_SocExplorerPlot::eventFilter(QObject* arg__1, QEvent* arg__2)
3757 {
4086 {
3758 if (_wrapper) {
4087 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3759 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
4088 static PyObject* name = PyString_FromString("eventFilter");
3760 PyErr_Clear();
4089 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3761 if (obj && !PythonQtSlotFunction_Check(obj)) {
4090 if (obj) {
3762 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4091 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
3763 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4092 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3764 bool returnValue;
4093 bool returnValue;
3765 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
4094 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
3766 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4095 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3767 if (result) {
4096 if (result) {
3768 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4097 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3769 if (args[0]!=&returnValue) {
4098 if (args[0]!=&returnValue) {
3770 if (args[0]==NULL) {
4099 if (args[0]==NULL) {
3771 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
4100 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
3772 } else {
4101 } else {
3773 returnValue = *((bool*)args[0]);
4102 returnValue = *((bool*)args[0]);
3774 }
4103 }
3775 }
4104 }
3776 }
4105 }
3777 if (result) { Py_DECREF(result); }
4106 if (result) { Py_DECREF(result); }
3778 Py_DECREF(obj);
4107 Py_DECREF(obj);
3779 return returnValue;
4108 return returnValue;
4109 } else {
4110 PyErr_Clear();
3780 }
4111 }
3781 }
4112 }
3782 return SocExplorerPlot::eventFilter(arg__1, arg__2);
4113 return SocExplorerPlot::eventFilter(arg__1, arg__2);
3783 }
4114 }
3784 void PythonQtShell_SocExplorerPlot::focusInEvent(QFocusEvent* arg__1)
4115 void PythonQtShell_SocExplorerPlot::focusInEvent(QFocusEvent* arg__1)
3785 {
4116 {
3786 if (_wrapper) {
4117 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3787 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
4118 static PyObject* name = PyString_FromString("focusInEvent");
3788 PyErr_Clear();
4119 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3789 if (obj && !PythonQtSlotFunction_Check(obj)) {
4120 if (obj) {
3790 static const char* argumentList[] ={"" , "QFocusEvent*"};
4121 static const char* argumentList[] ={"" , "QFocusEvent*"};
3791 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4122 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3792 void* args[2] = {NULL, (void*)&arg__1};
4123 void* args[2] = {NULL, (void*)&arg__1};
3793 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4124 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3794 if (result) { Py_DECREF(result); }
4125 if (result) { Py_DECREF(result); }
3795 Py_DECREF(obj);
4126 Py_DECREF(obj);
3796 return;
4127 return;
4128 } else {
4129 PyErr_Clear();
3797 }
4130 }
3798 }
4131 }
3799 SocExplorerPlot::focusInEvent(arg__1);
4132 SocExplorerPlot::focusInEvent(arg__1);
3800 }
4133 }
3801 bool PythonQtShell_SocExplorerPlot::focusNextPrevChild(bool next)
4134 bool PythonQtShell_SocExplorerPlot::focusNextPrevChild(bool next0)
3802 {
4135 {
3803 if (_wrapper) {
4136 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3804 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
4137 static PyObject* name = PyString_FromString("focusNextPrevChild");
3805 PyErr_Clear();
4138 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3806 if (obj && !PythonQtSlotFunction_Check(obj)) {
4139 if (obj) {
3807 static const char* argumentList[] ={"bool" , "bool"};
4140 static const char* argumentList[] ={"bool" , "bool"};
3808 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4141 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3809 bool returnValue;
4142 bool returnValue;
3810 void* args[2] = {NULL, (void*)&next};
4143 void* args[2] = {NULL, (void*)&next0};
3811 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4144 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3812 if (result) {
4145 if (result) {
3813 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4146 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3814 if (args[0]!=&returnValue) {
4147 if (args[0]!=&returnValue) {
3815 if (args[0]==NULL) {
4148 if (args[0]==NULL) {
3816 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
4149 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
3817 } else {
4150 } else {
3818 returnValue = *((bool*)args[0]);
4151 returnValue = *((bool*)args[0]);
3819 }
4152 }
3820 }
4153 }
3821 }
4154 }
3822 if (result) { Py_DECREF(result); }
4155 if (result) { Py_DECREF(result); }
3823 Py_DECREF(obj);
4156 Py_DECREF(obj);
3824 return returnValue;
4157 return returnValue;
3825 }
4158 } else {
3826 }
4159 PyErr_Clear();
3827 return SocExplorerPlot::focusNextPrevChild(next);
4160 }
4161 }
4162 return SocExplorerPlot::focusNextPrevChild(next0);
3828 }
4163 }
3829 void PythonQtShell_SocExplorerPlot::focusOutEvent(QFocusEvent* arg__1)
4164 void PythonQtShell_SocExplorerPlot::focusOutEvent(QFocusEvent* arg__1)
3830 {
4165 {
3831 if (_wrapper) {
4166 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3832 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
4167 static PyObject* name = PyString_FromString("focusOutEvent");
3833 PyErr_Clear();
4168 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3834 if (obj && !PythonQtSlotFunction_Check(obj)) {
4169 if (obj) {
3835 static const char* argumentList[] ={"" , "QFocusEvent*"};
4170 static const char* argumentList[] ={"" , "QFocusEvent*"};
3836 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4171 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3837 void* args[2] = {NULL, (void*)&arg__1};
4172 void* args[2] = {NULL, (void*)&arg__1};
3838 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4173 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3839 if (result) { Py_DECREF(result); }
4174 if (result) { Py_DECREF(result); }
3840 Py_DECREF(obj);
4175 Py_DECREF(obj);
3841 return;
4176 return;
4177 } else {
4178 PyErr_Clear();
3842 }
4179 }
3843 }
4180 }
3844 SocExplorerPlot::focusOutEvent(arg__1);
4181 SocExplorerPlot::focusOutEvent(arg__1);
3845 }
4182 }
3846 bool PythonQtShell_SocExplorerPlot::hasHeightForWidth() const
4183 bool PythonQtShell_SocExplorerPlot::hasHeightForWidth() const
3847 {
4184 {
3848 if (_wrapper) {
4185 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3849 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
4186 static PyObject* name = PyString_FromString("hasHeightForWidth");
3850 PyErr_Clear();
4187 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3851 if (obj && !PythonQtSlotFunction_Check(obj)) {
4188 if (obj) {
3852 static const char* argumentList[] ={"bool"};
4189 static const char* argumentList[] ={"bool"};
3853 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4190 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3854 bool returnValue;
4191 bool returnValue;
3855 void* args[1] = {NULL};
4192 void* args[1] = {NULL};
3856 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4193 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3857 if (result) {
4194 if (result) {
3858 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4195 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3859 if (args[0]!=&returnValue) {
4196 if (args[0]!=&returnValue) {
3860 if (args[0]==NULL) {
4197 if (args[0]==NULL) {
3861 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
4198 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
3862 } else {
4199 } else {
3863 returnValue = *((bool*)args[0]);
4200 returnValue = *((bool*)args[0]);
3864 }
4201 }
3865 }
4202 }
3866 }
4203 }
3867 if (result) { Py_DECREF(result); }
4204 if (result) { Py_DECREF(result); }
3868 Py_DECREF(obj);
4205 Py_DECREF(obj);
3869 return returnValue;
4206 return returnValue;
4207 } else {
4208 PyErr_Clear();
3870 }
4209 }
3871 }
4210 }
3872 return SocExplorerPlot::hasHeightForWidth();
4211 return SocExplorerPlot::hasHeightForWidth();
3873 }
4212 }
3874 int PythonQtShell_SocExplorerPlot::heightForWidth(int arg__1) const
4213 int PythonQtShell_SocExplorerPlot::heightForWidth(int arg__1) const
3875 {
4214 {
3876 if (_wrapper) {
4215 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3877 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
4216 static PyObject* name = PyString_FromString("heightForWidth");
3878 PyErr_Clear();
4217 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3879 if (obj && !PythonQtSlotFunction_Check(obj)) {
4218 if (obj) {
3880 static const char* argumentList[] ={"int" , "int"};
4219 static const char* argumentList[] ={"int" , "int"};
3881 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4220 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3882 int returnValue;
4221 int returnValue;
3883 void* args[2] = {NULL, (void*)&arg__1};
4222 void* args[2] = {NULL, (void*)&arg__1};
3884 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4223 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3885 if (result) {
4224 if (result) {
3886 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4225 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3887 if (args[0]!=&returnValue) {
4226 if (args[0]!=&returnValue) {
3888 if (args[0]==NULL) {
4227 if (args[0]==NULL) {
3889 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
4228 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
3890 } else {
4229 } else {
3891 returnValue = *((int*)args[0]);
4230 returnValue = *((int*)args[0]);
3892 }
4231 }
3893 }
4232 }
3894 }
4233 }
3895 if (result) { Py_DECREF(result); }
4234 if (result) { Py_DECREF(result); }
3896 Py_DECREF(obj);
4235 Py_DECREF(obj);
3897 return returnValue;
4236 return returnValue;
4237 } else {
4238 PyErr_Clear();
3898 }
4239 }
3899 }
4240 }
3900 return SocExplorerPlot::heightForWidth(arg__1);
4241 return SocExplorerPlot::heightForWidth(arg__1);
3901 }
4242 }
3902 void PythonQtShell_SocExplorerPlot::hideEvent(QHideEvent* arg__1)
4243 void PythonQtShell_SocExplorerPlot::hideEvent(QHideEvent* arg__1)
3903 {
4244 {
3904 if (_wrapper) {
4245 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3905 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
4246 static PyObject* name = PyString_FromString("hideEvent");
3906 PyErr_Clear();
4247 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3907 if (obj && !PythonQtSlotFunction_Check(obj)) {
4248 if (obj) {
3908 static const char* argumentList[] ={"" , "QHideEvent*"};
4249 static const char* argumentList[] ={"" , "QHideEvent*"};
3909 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4250 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3910 void* args[2] = {NULL, (void*)&arg__1};
4251 void* args[2] = {NULL, (void*)&arg__1};
3911 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4252 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3912 if (result) { Py_DECREF(result); }
4253 if (result) { Py_DECREF(result); }
3913 Py_DECREF(obj);
4254 Py_DECREF(obj);
3914 return;
4255 return;
4256 } else {
4257 PyErr_Clear();
3915 }
4258 }
3916 }
4259 }
3917 SocExplorerPlot::hideEvent(arg__1);
4260 SocExplorerPlot::hideEvent(arg__1);
3918 }
4261 }
3919 void PythonQtShell_SocExplorerPlot::initPainter(QPainter* painter) const
4262 void PythonQtShell_SocExplorerPlot::initPainter(QPainter* painter0) const
3920 {
4263 {
3921 if (_wrapper) {
4264 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3922 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
4265 static PyObject* name = PyString_FromString("initPainter");
3923 PyErr_Clear();
4266 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3924 if (obj && !PythonQtSlotFunction_Check(obj)) {
4267 if (obj) {
3925 static const char* argumentList[] ={"" , "QPainter*"};
4268 static const char* argumentList[] ={"" , "QPainter*"};
3926 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4269 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3927 void* args[2] = {NULL, (void*)&painter};
4270 void* args[2] = {NULL, (void*)&painter0};
3928 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4271 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3929 if (result) { Py_DECREF(result); }
4272 if (result) { Py_DECREF(result); }
3930 Py_DECREF(obj);
4273 Py_DECREF(obj);
3931 return;
4274 return;
3932 }
4275 } else {
3933 }
4276 PyErr_Clear();
3934 SocExplorerPlot::initPainter(painter);
4277 }
4278 }
4279 SocExplorerPlot::initPainter(painter0);
3935 }
4280 }
3936 void PythonQtShell_SocExplorerPlot::inputMethodEvent(QInputMethodEvent* arg__1)
4281 void PythonQtShell_SocExplorerPlot::inputMethodEvent(QInputMethodEvent* arg__1)
3937 {
4282 {
3938 if (_wrapper) {
4283 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3939 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
4284 static PyObject* name = PyString_FromString("inputMethodEvent");
3940 PyErr_Clear();
4285 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3941 if (obj && !PythonQtSlotFunction_Check(obj)) {
4286 if (obj) {
3942 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
4287 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
3943 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4288 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3944 void* args[2] = {NULL, (void*)&arg__1};
4289 void* args[2] = {NULL, (void*)&arg__1};
3945 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4290 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3946 if (result) { Py_DECREF(result); }
4291 if (result) { Py_DECREF(result); }
3947 Py_DECREF(obj);
4292 Py_DECREF(obj);
3948 return;
4293 return;
4294 } else {
4295 PyErr_Clear();
3949 }
4296 }
3950 }
4297 }
3951 SocExplorerPlot::inputMethodEvent(arg__1);
4298 SocExplorerPlot::inputMethodEvent(arg__1);
3952 }
4299 }
3953 QVariant PythonQtShell_SocExplorerPlot::inputMethodQuery(Qt::InputMethodQuery arg__1) const
4300 QVariant PythonQtShell_SocExplorerPlot::inputMethodQuery(Qt::InputMethodQuery arg__1) const
3954 {
4301 {
3955 if (_wrapper) {
4302 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3956 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
4303 static PyObject* name = PyString_FromString("inputMethodQuery");
3957 PyErr_Clear();
4304 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3958 if (obj && !PythonQtSlotFunction_Check(obj)) {
4305 if (obj) {
3959 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
4306 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
3960 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4307 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3961 QVariant returnValue;
4308 QVariant returnValue;
3962 void* args[2] = {NULL, (void*)&arg__1};
4309 void* args[2] = {NULL, (void*)&arg__1};
3963 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4310 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3964 if (result) {
4311 if (result) {
3965 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4312 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3966 if (args[0]!=&returnValue) {
4313 if (args[0]!=&returnValue) {
3967 if (args[0]==NULL) {
4314 if (args[0]==NULL) {
3968 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
4315 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
3969 } else {
4316 } else {
3970 returnValue = *((QVariant*)args[0]);
4317 returnValue = *((QVariant*)args[0]);
3971 }
4318 }
3972 }
4319 }
3973 }
4320 }
3974 if (result) { Py_DECREF(result); }
4321 if (result) { Py_DECREF(result); }
3975 Py_DECREF(obj);
4322 Py_DECREF(obj);
3976 return returnValue;
4323 return returnValue;
4324 } else {
4325 PyErr_Clear();
3977 }
4326 }
3978 }
4327 }
3979 return SocExplorerPlot::inputMethodQuery(arg__1);
4328 return SocExplorerPlot::inputMethodQuery(arg__1);
3980 }
4329 }
3981 void PythonQtShell_SocExplorerPlot::keyPressEvent(QKeyEvent* arg__1)
4330 void PythonQtShell_SocExplorerPlot::keyPressEvent(QKeyEvent* arg__1)
3982 {
4331 {
3983 if (_wrapper) {
4332 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3984 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
4333 static PyObject* name = PyString_FromString("keyPressEvent");
3985 PyErr_Clear();
4334 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3986 if (obj && !PythonQtSlotFunction_Check(obj)) {
4335 if (obj) {
3987 static const char* argumentList[] ={"" , "QKeyEvent*"};
4336 static const char* argumentList[] ={"" , "QKeyEvent*"};
3988 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4337 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3989 void* args[2] = {NULL, (void*)&arg__1};
4338 void* args[2] = {NULL, (void*)&arg__1};
3990 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4339 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3991 if (result) { Py_DECREF(result); }
4340 if (result) { Py_DECREF(result); }
3992 Py_DECREF(obj);
4341 Py_DECREF(obj);
3993 return;
4342 return;
4343 } else {
4344 PyErr_Clear();
3994 }
4345 }
3995 }
4346 }
3996 SocExplorerPlot::keyPressEvent(arg__1);
4347 SocExplorerPlot::keyPressEvent(arg__1);
3997 }
4348 }
3998 void PythonQtShell_SocExplorerPlot::keyReleaseEvent(QKeyEvent* arg__1)
4349 void PythonQtShell_SocExplorerPlot::keyReleaseEvent(QKeyEvent* arg__1)
3999 {
4350 {
4000 if (_wrapper) {
4351 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4001 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
4352 static PyObject* name = PyString_FromString("keyReleaseEvent");
4002 PyErr_Clear();
4353 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4003 if (obj && !PythonQtSlotFunction_Check(obj)) {
4354 if (obj) {
4004 static const char* argumentList[] ={"" , "QKeyEvent*"};
4355 static const char* argumentList[] ={"" , "QKeyEvent*"};
4005 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4356 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4006 void* args[2] = {NULL, (void*)&arg__1};
4357 void* args[2] = {NULL, (void*)&arg__1};
4007 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4358 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4008 if (result) { Py_DECREF(result); }
4359 if (result) { Py_DECREF(result); }
4009 Py_DECREF(obj);
4360 Py_DECREF(obj);
4010 return;
4361 return;
4362 } else {
4363 PyErr_Clear();
4011 }
4364 }
4012 }
4365 }
4013 SocExplorerPlot::keyReleaseEvent(arg__1);
4366 SocExplorerPlot::keyReleaseEvent(arg__1);
4014 }
4367 }
4015 void PythonQtShell_SocExplorerPlot::leaveEvent(QEvent* arg__1)
4368 void PythonQtShell_SocExplorerPlot::leaveEvent(QEvent* arg__1)
4016 {
4369 {
4017 if (_wrapper) {
4370 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4018 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
4371 static PyObject* name = PyString_FromString("leaveEvent");
4019 PyErr_Clear();
4372 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4020 if (obj && !PythonQtSlotFunction_Check(obj)) {
4373 if (obj) {
4021 static const char* argumentList[] ={"" , "QEvent*"};
4374 static const char* argumentList[] ={"" , "QEvent*"};
4022 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4375 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4023 void* args[2] = {NULL, (void*)&arg__1};
4376 void* args[2] = {NULL, (void*)&arg__1};
4024 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4377 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4025 if (result) { Py_DECREF(result); }
4378 if (result) { Py_DECREF(result); }
4026 Py_DECREF(obj);
4379 Py_DECREF(obj);
4027 return;
4380 return;
4381 } else {
4382 PyErr_Clear();
4028 }
4383 }
4029 }
4384 }
4030 SocExplorerPlot::leaveEvent(arg__1);
4385 SocExplorerPlot::leaveEvent(arg__1);
4031 }
4386 }
4032 int PythonQtShell_SocExplorerPlot::metric(QPaintDevice::PaintDeviceMetric arg__1) const
4387 int PythonQtShell_SocExplorerPlot::metric(QPaintDevice::PaintDeviceMetric arg__1) const
4033 {
4388 {
4034 if (_wrapper) {
4389 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4035 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
4390 static PyObject* name = PyString_FromString("metric");
4036 PyErr_Clear();
4391 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4037 if (obj && !PythonQtSlotFunction_Check(obj)) {
4392 if (obj) {
4038 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
4393 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
4039 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4394 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4040 int returnValue;
4395 int returnValue;
4041 void* args[2] = {NULL, (void*)&arg__1};
4396 void* args[2] = {NULL, (void*)&arg__1};
4042 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4397 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4043 if (result) {
4398 if (result) {
4044 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4399 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4045 if (args[0]!=&returnValue) {
4400 if (args[0]!=&returnValue) {
4046 if (args[0]==NULL) {
4401 if (args[0]==NULL) {
4047 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
4402 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
4048 } else {
4403 } else {
4049 returnValue = *((int*)args[0]);
4404 returnValue = *((int*)args[0]);
4050 }
4405 }
4051 }
4406 }
4052 }
4407 }
4053 if (result) { Py_DECREF(result); }
4408 if (result) { Py_DECREF(result); }
4054 Py_DECREF(obj);
4409 Py_DECREF(obj);
4055 return returnValue;
4410 return returnValue;
4411 } else {
4412 PyErr_Clear();
4056 }
4413 }
4057 }
4414 }
4058 return SocExplorerPlot::metric(arg__1);
4415 return SocExplorerPlot::metric(arg__1);
4059 }
4416 }
4060 QSize PythonQtShell_SocExplorerPlot::minimumSizeHint() const
4417 QSize PythonQtShell_SocExplorerPlot::minimumSizeHint() const
4061 {
4418 {
4062 if (_wrapper) {
4419 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4063 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
4420 static PyObject* name = PyString_FromString("getMinimumSizeHint");
4064 PyErr_Clear();
4421 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4065 if (obj && !PythonQtSlotFunction_Check(obj)) {
4422 if (obj) {
4066 static const char* argumentList[] ={"QSize"};
4423 static const char* argumentList[] ={"QSize"};
4067 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4424 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4068 QSize returnValue;
4425 QSize returnValue;
4069 void* args[1] = {NULL};
4426 void* args[1] = {NULL};
4070 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4427 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4071 if (result) {
4428 if (result) {
4072 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4429 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4073 if (args[0]!=&returnValue) {
4430 if (args[0]!=&returnValue) {
4074 if (args[0]==NULL) {
4431 if (args[0]==NULL) {
4075 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
4432 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
4076 } else {
4433 } else {
4077 returnValue = *((QSize*)args[0]);
4434 returnValue = *((QSize*)args[0]);
4078 }
4435 }
4079 }
4436 }
4080 }
4437 }
4081 if (result) { Py_DECREF(result); }
4438 if (result) { Py_DECREF(result); }
4082 Py_DECREF(obj);
4439 Py_DECREF(obj);
4083 return returnValue;
4440 return returnValue;
4441 } else {
4442 PyErr_Clear();
4084 }
4443 }
4085 }
4444 }
4086 return SocExplorerPlot::minimumSizeHint();
4445 return SocExplorerPlot::minimumSizeHint();
4087 }
4446 }
4088 void PythonQtShell_SocExplorerPlot::mouseDoubleClickEvent(QMouseEvent* arg__1)
4447 void PythonQtShell_SocExplorerPlot::mouseDoubleClickEvent(QMouseEvent* arg__1)
4089 {
4448 {
4090 if (_wrapper) {
4449 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4091 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
4450 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
4092 PyErr_Clear();
4451 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4093 if (obj && !PythonQtSlotFunction_Check(obj)) {
4452 if (obj) {
4094 static const char* argumentList[] ={"" , "QMouseEvent*"};
4453 static const char* argumentList[] ={"" , "QMouseEvent*"};
4095 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4454 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4096 void* args[2] = {NULL, (void*)&arg__1};
4455 void* args[2] = {NULL, (void*)&arg__1};
4097 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4456 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4098 if (result) { Py_DECREF(result); }
4457 if (result) { Py_DECREF(result); }
4099 Py_DECREF(obj);
4458 Py_DECREF(obj);
4100 return;
4459 return;
4460 } else {
4461 PyErr_Clear();
4101 }
4462 }
4102 }
4463 }
4103 SocExplorerPlot::mouseDoubleClickEvent(arg__1);
4464 SocExplorerPlot::mouseDoubleClickEvent(arg__1);
4104 }
4465 }
4105 void PythonQtShell_SocExplorerPlot::mouseMoveEvent(QMouseEvent* arg__1)
4466 void PythonQtShell_SocExplorerPlot::mouseMoveEvent(QMouseEvent* arg__1)
4106 {
4467 {
4107 if (_wrapper) {
4468 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4108 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
4469 static PyObject* name = PyString_FromString("mouseMoveEvent");
4109 PyErr_Clear();
4470 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4110 if (obj && !PythonQtSlotFunction_Check(obj)) {
4471 if (obj) {
4111 static const char* argumentList[] ={"" , "QMouseEvent*"};
4472 static const char* argumentList[] ={"" , "QMouseEvent*"};
4112 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4473 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4113 void* args[2] = {NULL, (void*)&arg__1};
4474 void* args[2] = {NULL, (void*)&arg__1};
4114 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4475 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4115 if (result) { Py_DECREF(result); }
4476 if (result) { Py_DECREF(result); }
4116 Py_DECREF(obj);
4477 Py_DECREF(obj);
4117 return;
4478 return;
4479 } else {
4480 PyErr_Clear();
4118 }
4481 }
4119 }
4482 }
4120 SocExplorerPlot::mouseMoveEvent(arg__1);
4483 SocExplorerPlot::mouseMoveEvent(arg__1);
4121 }
4484 }
4122 void PythonQtShell_SocExplorerPlot::mousePressEvent(QMouseEvent* arg__1)
4485 void PythonQtShell_SocExplorerPlot::mousePressEvent(QMouseEvent* arg__1)
4123 {
4486 {
4124 if (_wrapper) {
4487 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4125 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
4488 static PyObject* name = PyString_FromString("mousePressEvent");
4126 PyErr_Clear();
4489 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4127 if (obj && !PythonQtSlotFunction_Check(obj)) {
4490 if (obj) {
4128 static const char* argumentList[] ={"" , "QMouseEvent*"};
4491 static const char* argumentList[] ={"" , "QMouseEvent*"};
4129 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4492 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4130 void* args[2] = {NULL, (void*)&arg__1};
4493 void* args[2] = {NULL, (void*)&arg__1};
4131 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4494 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4132 if (result) { Py_DECREF(result); }
4495 if (result) { Py_DECREF(result); }
4133 Py_DECREF(obj);
4496 Py_DECREF(obj);
4134 return;
4497 return;
4498 } else {
4499 PyErr_Clear();
4135 }
4500 }
4136 }
4501 }
4137 SocExplorerPlot::mousePressEvent(arg__1);
4502 SocExplorerPlot::mousePressEvent(arg__1);
4138 }
4503 }
4139 void PythonQtShell_SocExplorerPlot::mouseReleaseEvent(QMouseEvent* arg__1)
4504 void PythonQtShell_SocExplorerPlot::mouseReleaseEvent(QMouseEvent* arg__1)
4140 {
4505 {
4141 if (_wrapper) {
4506 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4142 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
4507 static PyObject* name = PyString_FromString("mouseReleaseEvent");
4143 PyErr_Clear();
4508 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4144 if (obj && !PythonQtSlotFunction_Check(obj)) {
4509 if (obj) {
4145 static const char* argumentList[] ={"" , "QMouseEvent*"};
4510 static const char* argumentList[] ={"" , "QMouseEvent*"};
4146 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4511 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4147 void* args[2] = {NULL, (void*)&arg__1};
4512 void* args[2] = {NULL, (void*)&arg__1};
4148 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4513 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4149 if (result) { Py_DECREF(result); }
4514 if (result) { Py_DECREF(result); }
4150 Py_DECREF(obj);
4515 Py_DECREF(obj);
4151 return;
4516 return;
4517 } else {
4518 PyErr_Clear();
4152 }
4519 }
4153 }
4520 }
4154 SocExplorerPlot::mouseReleaseEvent(arg__1);
4521 SocExplorerPlot::mouseReleaseEvent(arg__1);
4155 }
4522 }
4156 void PythonQtShell_SocExplorerPlot::moveEvent(QMoveEvent* arg__1)
4523 void PythonQtShell_SocExplorerPlot::moveEvent(QMoveEvent* arg__1)
4157 {
4524 {
4158 if (_wrapper) {
4525 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4159 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
4526 static PyObject* name = PyString_FromString("moveEvent");
4160 PyErr_Clear();
4527 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4161 if (obj && !PythonQtSlotFunction_Check(obj)) {
4528 if (obj) {
4162 static const char* argumentList[] ={"" , "QMoveEvent*"};
4529 static const char* argumentList[] ={"" , "QMoveEvent*"};
4163 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4530 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4164 void* args[2] = {NULL, (void*)&arg__1};
4531 void* args[2] = {NULL, (void*)&arg__1};
4165 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4532 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4166 if (result) { Py_DECREF(result); }
4533 if (result) { Py_DECREF(result); }
4167 Py_DECREF(obj);
4534 Py_DECREF(obj);
4168 return;
4535 return;
4536 } else {
4537 PyErr_Clear();
4169 }
4538 }
4170 }
4539 }
4171 SocExplorerPlot::moveEvent(arg__1);
4540 SocExplorerPlot::moveEvent(arg__1);
4172 }
4541 }
4173 bool PythonQtShell_SocExplorerPlot::nativeEvent(const QByteArray& eventType, void* message, long* result)
4542 bool PythonQtShell_SocExplorerPlot::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
4174 {
4543 {
4175 if (_wrapper) {
4544 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4176 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
4545 static PyObject* name = PyString_FromString("nativeEvent");
4177 PyErr_Clear();
4546 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4178 if (obj && !PythonQtSlotFunction_Check(obj)) {
4547 if (obj) {
4179 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
4548 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
4180 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
4549 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
4181 bool returnValue;
4550 bool returnValue;
4182 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
4551 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
4183 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4552 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4184 if (result) {
4553 if (result) {
4185 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4554 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4186 if (args[0]!=&returnValue) {
4555 if (args[0]!=&returnValue) {
4187 if (args[0]==NULL) {
4556 if (args[0]==NULL) {
4188 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
4557 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
4189 } else {
4558 } else {
4190 returnValue = *((bool*)args[0]);
4559 returnValue = *((bool*)args[0]);
4191 }
4560 }
4192 }
4561 }
4193 }
4562 }
4194 if (result) { Py_DECREF(result); }
4563 if (result) { Py_DECREF(result); }
4195 Py_DECREF(obj);
4564 Py_DECREF(obj);
4196 return returnValue;
4565 return returnValue;
4197 }
4566 } else {
4198 }
4567 PyErr_Clear();
4199 return SocExplorerPlot::nativeEvent(eventType, message, result);
4568 }
4569 }
4570 return SocExplorerPlot::nativeEvent(eventType0, message1, result2);
4200 }
4571 }
4201 QPaintEngine* PythonQtShell_SocExplorerPlot::paintEngine() const
4572 QPaintEngine* PythonQtShell_SocExplorerPlot::paintEngine() const
4202 {
4573 {
4203 if (_wrapper) {
4574 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4204 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
4575 static PyObject* name = PyString_FromString("paintEngine");
4205 PyErr_Clear();
4576 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4206 if (obj && !PythonQtSlotFunction_Check(obj)) {
4577 if (obj) {
4207 static const char* argumentList[] ={"QPaintEngine*"};
4578 static const char* argumentList[] ={"QPaintEngine*"};
4208 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4579 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4209 QPaintEngine* returnValue;
4580 QPaintEngine* returnValue;
4210 void* args[1] = {NULL};
4581 void* args[1] = {NULL};
4211 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4582 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4212 if (result) {
4583 if (result) {
4213 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4584 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4214 if (args[0]!=&returnValue) {
4585 if (args[0]!=&returnValue) {
4215 if (args[0]==NULL) {
4586 if (args[0]==NULL) {
4216 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
4587 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
4217 } else {
4588 } else {
4218 returnValue = *((QPaintEngine**)args[0]);
4589 returnValue = *((QPaintEngine**)args[0]);
4219 }
4590 }
4220 }
4591 }
4221 }
4592 }
4222 if (result) { Py_DECREF(result); }
4593 if (result) { Py_DECREF(result); }
4223 Py_DECREF(obj);
4594 Py_DECREF(obj);
4224 return returnValue;
4595 return returnValue;
4596 } else {
4597 PyErr_Clear();
4225 }
4598 }
4226 }
4599 }
4227 return SocExplorerPlot::paintEngine();
4600 return SocExplorerPlot::paintEngine();
4228 }
4601 }
4229 void PythonQtShell_SocExplorerPlot::paintEvent(QPaintEvent* arg__1)
4602 void PythonQtShell_SocExplorerPlot::paintEvent(QPaintEvent* arg__1)
4230 {
4603 {
4231 if (_wrapper) {
4604 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4232 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
4605 static PyObject* name = PyString_FromString("paintEvent");
4233 PyErr_Clear();
4606 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4234 if (obj && !PythonQtSlotFunction_Check(obj)) {
4607 if (obj) {
4235 static const char* argumentList[] ={"" , "QPaintEvent*"};
4608 static const char* argumentList[] ={"" , "QPaintEvent*"};
4236 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4609 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4237 void* args[2] = {NULL, (void*)&arg__1};
4610 void* args[2] = {NULL, (void*)&arg__1};
4238 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4611 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4239 if (result) { Py_DECREF(result); }
4612 if (result) { Py_DECREF(result); }
4240 Py_DECREF(obj);
4613 Py_DECREF(obj);
4241 return;
4614 return;
4615 } else {
4616 PyErr_Clear();
4242 }
4617 }
4243 }
4618 }
4244 SocExplorerPlot::paintEvent(arg__1);
4619 SocExplorerPlot::paintEvent(arg__1);
4245 }
4620 }
4246 QPaintDevice* PythonQtShell_SocExplorerPlot::redirected(QPoint* offset) const
4621 QPaintDevice* PythonQtShell_SocExplorerPlot::redirected(QPoint* offset0) const
4247 {
4622 {
4248 if (_wrapper) {
4623 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4249 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
4624 static PyObject* name = PyString_FromString("redirected");
4250 PyErr_Clear();
4625 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4251 if (obj && !PythonQtSlotFunction_Check(obj)) {
4626 if (obj) {
4252 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
4627 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
4253 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4628 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4254 QPaintDevice* returnValue;
4629 QPaintDevice* returnValue;
4255 void* args[2] = {NULL, (void*)&offset};
4630 void* args[2] = {NULL, (void*)&offset0};
4256 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4631 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4257 if (result) {
4632 if (result) {
4258 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4633 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4259 if (args[0]!=&returnValue) {
4634 if (args[0]!=&returnValue) {
4260 if (args[0]==NULL) {
4635 if (args[0]==NULL) {
4261 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
4636 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
4262 } else {
4637 } else {
4263 returnValue = *((QPaintDevice**)args[0]);
4638 returnValue = *((QPaintDevice**)args[0]);
4264 }
4639 }
4265 }
4640 }
4266 }
4641 }
4267 if (result) { Py_DECREF(result); }
4642 if (result) { Py_DECREF(result); }
4268 Py_DECREF(obj);
4643 Py_DECREF(obj);
4269 return returnValue;
4644 return returnValue;
4270 }
4645 } else {
4271 }
4646 PyErr_Clear();
4272 return SocExplorerPlot::redirected(offset);
4647 }
4648 }
4649 return SocExplorerPlot::redirected(offset0);
4273 }
4650 }
4274 void PythonQtShell_SocExplorerPlot::resizeEvent(QResizeEvent* arg__1)
4651 void PythonQtShell_SocExplorerPlot::resizeEvent(QResizeEvent* arg__1)
4275 {
4652 {
4276 if (_wrapper) {
4653 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4277 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
4654 static PyObject* name = PyString_FromString("resizeEvent");
4278 PyErr_Clear();
4655 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4279 if (obj && !PythonQtSlotFunction_Check(obj)) {
4656 if (obj) {
4280 static const char* argumentList[] ={"" , "QResizeEvent*"};
4657 static const char* argumentList[] ={"" , "QResizeEvent*"};
4281 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4658 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4282 void* args[2] = {NULL, (void*)&arg__1};
4659 void* args[2] = {NULL, (void*)&arg__1};
4283 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4660 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4284 if (result) { Py_DECREF(result); }
4661 if (result) { Py_DECREF(result); }
4285 Py_DECREF(obj);
4662 Py_DECREF(obj);
4286 return;
4663 return;
4664 } else {
4665 PyErr_Clear();
4287 }
4666 }
4288 }
4667 }
4289 SocExplorerPlot::resizeEvent(arg__1);
4668 SocExplorerPlot::resizeEvent(arg__1);
4290 }
4669 }
4291 QPainter* PythonQtShell_SocExplorerPlot::sharedPainter() const
4670 QPainter* PythonQtShell_SocExplorerPlot::sharedPainter() const
4292 {
4671 {
4293 if (_wrapper) {
4672 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4294 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
4673 static PyObject* name = PyString_FromString("sharedPainter");
4295 PyErr_Clear();
4674 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4296 if (obj && !PythonQtSlotFunction_Check(obj)) {
4675 if (obj) {
4297 static const char* argumentList[] ={"QPainter*"};
4676 static const char* argumentList[] ={"QPainter*"};
4298 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4677 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4299 QPainter* returnValue;
4678 QPainter* returnValue;
4300 void* args[1] = {NULL};
4679 void* args[1] = {NULL};
4301 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4680 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4302 if (result) {
4681 if (result) {
4303 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4682 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4304 if (args[0]!=&returnValue) {
4683 if (args[0]!=&returnValue) {
4305 if (args[0]==NULL) {
4684 if (args[0]==NULL) {
4306 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
4685 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
4307 } else {
4686 } else {
4308 returnValue = *((QPainter**)args[0]);
4687 returnValue = *((QPainter**)args[0]);
4309 }
4688 }
4310 }
4689 }
4311 }
4690 }
4312 if (result) { Py_DECREF(result); }
4691 if (result) { Py_DECREF(result); }
4313 Py_DECREF(obj);
4692 Py_DECREF(obj);
4314 return returnValue;
4693 return returnValue;
4694 } else {
4695 PyErr_Clear();
4315 }
4696 }
4316 }
4697 }
4317 return SocExplorerPlot::sharedPainter();
4698 return SocExplorerPlot::sharedPainter();
4318 }
4699 }
4319 void PythonQtShell_SocExplorerPlot::showEvent(QShowEvent* arg__1)
4700 void PythonQtShell_SocExplorerPlot::showEvent(QShowEvent* arg__1)
4320 {
4701 {
4321 if (_wrapper) {
4702 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4322 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
4703 static PyObject* name = PyString_FromString("showEvent");
4323 PyErr_Clear();
4704 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4324 if (obj && !PythonQtSlotFunction_Check(obj)) {
4705 if (obj) {
4325 static const char* argumentList[] ={"" , "QShowEvent*"};
4706 static const char* argumentList[] ={"" , "QShowEvent*"};
4326 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4707 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4327 void* args[2] = {NULL, (void*)&arg__1};
4708 void* args[2] = {NULL, (void*)&arg__1};
4328 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4709 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4329 if (result) { Py_DECREF(result); }
4710 if (result) { Py_DECREF(result); }
4330 Py_DECREF(obj);
4711 Py_DECREF(obj);
4331 return;
4712 return;
4713 } else {
4714 PyErr_Clear();
4332 }
4715 }
4333 }
4716 }
4334 SocExplorerPlot::showEvent(arg__1);
4717 SocExplorerPlot::showEvent(arg__1);
4335 }
4718 }
4336 QSize PythonQtShell_SocExplorerPlot::sizeHint() const
4719 QSize PythonQtShell_SocExplorerPlot::sizeHint() const
4337 {
4720 {
4338 if (_wrapper) {
4721 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4339 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
4722 static PyObject* name = PyString_FromString("getSizeHint");
4340 PyErr_Clear();
4723 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4341 if (obj && !PythonQtSlotFunction_Check(obj)) {
4724 if (obj) {
4342 static const char* argumentList[] ={"QSize"};
4725 static const char* argumentList[] ={"QSize"};
4343 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4726 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4344 QSize returnValue;
4727 QSize returnValue;
4345 void* args[1] = {NULL};
4728 void* args[1] = {NULL};
4346 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4729 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4347 if (result) {
4730 if (result) {
4348 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4731 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4349 if (args[0]!=&returnValue) {
4732 if (args[0]!=&returnValue) {
4350 if (args[0]==NULL) {
4733 if (args[0]==NULL) {
4351 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
4734 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
4352 } else {
4735 } else {
4353 returnValue = *((QSize*)args[0]);
4736 returnValue = *((QSize*)args[0]);
4354 }
4737 }
4355 }
4738 }
4356 }
4739 }
4357 if (result) { Py_DECREF(result); }
4740 if (result) { Py_DECREF(result); }
4358 Py_DECREF(obj);
4741 Py_DECREF(obj);
4359 return returnValue;
4742 return returnValue;
4743 } else {
4744 PyErr_Clear();
4360 }
4745 }
4361 }
4746 }
4362 return SocExplorerPlot::sizeHint();
4747 return SocExplorerPlot::sizeHint();
4363 }
4748 }
4364 void PythonQtShell_SocExplorerPlot::tabletEvent(QTabletEvent* arg__1)
4749 void PythonQtShell_SocExplorerPlot::tabletEvent(QTabletEvent* arg__1)
4365 {
4750 {
4366 if (_wrapper) {
4751 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4367 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
4752 static PyObject* name = PyString_FromString("tabletEvent");
4368 PyErr_Clear();
4753 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4369 if (obj && !PythonQtSlotFunction_Check(obj)) {
4754 if (obj) {
4370 static const char* argumentList[] ={"" , "QTabletEvent*"};
4755 static const char* argumentList[] ={"" , "QTabletEvent*"};
4371 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4756 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4372 void* args[2] = {NULL, (void*)&arg__1};
4757 void* args[2] = {NULL, (void*)&arg__1};
4373 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4758 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4374 if (result) { Py_DECREF(result); }
4759 if (result) { Py_DECREF(result); }
4375 Py_DECREF(obj);
4760 Py_DECREF(obj);
4376 return;
4761 return;
4762 } else {
4763 PyErr_Clear();
4377 }
4764 }
4378 }
4765 }
4379 SocExplorerPlot::tabletEvent(arg__1);
4766 SocExplorerPlot::tabletEvent(arg__1);
4380 }
4767 }
4381 void PythonQtShell_SocExplorerPlot::timerEvent(QTimerEvent* arg__1)
4768 void PythonQtShell_SocExplorerPlot::timerEvent(QTimerEvent* arg__1)
4382 {
4769 {
4383 if (_wrapper) {
4770 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4384 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
4771 static PyObject* name = PyString_FromString("timerEvent");
4385 PyErr_Clear();
4772 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4386 if (obj && !PythonQtSlotFunction_Check(obj)) {
4773 if (obj) {
4387 static const char* argumentList[] ={"" , "QTimerEvent*"};
4774 static const char* argumentList[] ={"" , "QTimerEvent*"};
4388 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4775 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4389 void* args[2] = {NULL, (void*)&arg__1};
4776 void* args[2] = {NULL, (void*)&arg__1};
4390 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4777 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4391 if (result) { Py_DECREF(result); }
4778 if (result) { Py_DECREF(result); }
4392 Py_DECREF(obj);
4779 Py_DECREF(obj);
4393 return;
4780 return;
4781 } else {
4782 PyErr_Clear();
4394 }
4783 }
4395 }
4784 }
4396 SocExplorerPlot::timerEvent(arg__1);
4785 SocExplorerPlot::timerEvent(arg__1);
4397 }
4786 }
4398 void PythonQtShell_SocExplorerPlot::wheelEvent(QWheelEvent* arg__1)
4787 void PythonQtShell_SocExplorerPlot::wheelEvent(QWheelEvent* arg__1)
4399 {
4788 {
4400 if (_wrapper) {
4789 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4401 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
4790 static PyObject* name = PyString_FromString("wheelEvent");
4402 PyErr_Clear();
4791 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4403 if (obj && !PythonQtSlotFunction_Check(obj)) {
4792 if (obj) {
4404 static const char* argumentList[] ={"" , "QWheelEvent*"};
4793 static const char* argumentList[] ={"" , "QWheelEvent*"};
4405 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4794 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4406 void* args[2] = {NULL, (void*)&arg__1};
4795 void* args[2] = {NULL, (void*)&arg__1};
4407 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4796 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4408 if (result) { Py_DECREF(result); }
4797 if (result) { Py_DECREF(result); }
4409 Py_DECREF(obj);
4798 Py_DECREF(obj);
4410 return;
4799 return;
4800 } else {
4801 PyErr_Clear();
4411 }
4802 }
4412 }
4803 }
4413 SocExplorerPlot::wheelEvent(arg__1);
4804 SocExplorerPlot::wheelEvent(arg__1);
4414 }
4805 }
4415 SocExplorerPlot* PythonQtWrapper_SocExplorerPlot::new_SocExplorerPlot(QWidget* parent)
4806 SocExplorerPlot* PythonQtWrapper_SocExplorerPlot::new_SocExplorerPlot(QWidget* parent)
4416 {
4807 {
4417 return new PythonQtShell_SocExplorerPlot(parent); }
4808 return new PythonQtShell_SocExplorerPlot(parent); }
4418
4809
4419 int PythonQtWrapper_SocExplorerPlot::addGraph(SocExplorerPlot* theWrappedObject)
4810 int PythonQtWrapper_SocExplorerPlot::addGraph(SocExplorerPlot* theWrappedObject)
4420 {
4811 {
4421 return ( theWrappedObject->addGraph());
4812 return ( theWrappedObject->addGraph());
4422 }
4813 }
4423
4814
4424 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4815 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4425 {
4816 {
4426 ( theWrappedObject->addGraphData(graphIndex, x, y));
4817 ( theWrappedObject->addGraphData(graphIndex, x, y));
4427 }
4818 }
4428
4819
4429 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y)
4820 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y)
4430 {
4821 {
4431 ( theWrappedObject->addGraphData(graphIndex, x, y));
4822 ( theWrappedObject->addGraphData(graphIndex, x, y));
4432 }
4823 }
4433
4824
4434 QPen PythonQtWrapper_SocExplorerPlot::getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex)
4825 QPen PythonQtWrapper_SocExplorerPlot::getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex)
4435 {
4826 {
4436 return ( theWrappedObject->getGraphPen(graphIndex));
4827 return ( theWrappedObject->getGraphPen(graphIndex));
4437 }
4828 }
4438
4829
4439 void PythonQtWrapper_SocExplorerPlot::keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4830 void PythonQtWrapper_SocExplorerPlot::keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4440 {
4831 {
4441 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyPressEvent(arg__1));
4832 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyPressEvent(arg__1));
4442 }
4833 }
4443
4834
4444 void PythonQtWrapper_SocExplorerPlot::keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4835 void PythonQtWrapper_SocExplorerPlot::keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4445 {
4836 {
4446 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyReleaseEvent(arg__1));
4837 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyReleaseEvent(arg__1));
4447 }
4838 }
4448
4839
4449 void PythonQtWrapper_SocExplorerPlot::mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4840 void PythonQtWrapper_SocExplorerPlot::mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4450 {
4841 {
4451 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseMoveEvent(arg__1));
4842 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseMoveEvent(arg__1));
4452 }
4843 }
4453
4844
4454 void PythonQtWrapper_SocExplorerPlot::mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4845 void PythonQtWrapper_SocExplorerPlot::mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4455 {
4846 {
4456 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mousePressEvent(arg__1));
4847 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mousePressEvent(arg__1));
4457 }
4848 }
4458
4849
4459 void PythonQtWrapper_SocExplorerPlot::mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4850 void PythonQtWrapper_SocExplorerPlot::mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4460 {
4851 {
4461 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseReleaseEvent(arg__1));
4852 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseReleaseEvent(arg__1));
4462 }
4853 }
4463
4854
4464 void PythonQtWrapper_SocExplorerPlot::rescaleAxis(SocExplorerPlot* theWrappedObject)
4855 void PythonQtWrapper_SocExplorerPlot::rescaleAxis(SocExplorerPlot* theWrappedObject)
4465 {
4856 {
4466 ( theWrappedObject->rescaleAxis());
4857 ( theWrappedObject->rescaleAxis());
4467 }
4858 }
4468
4859
4469 void PythonQtWrapper_SocExplorerPlot::setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable)
4860 void PythonQtWrapper_SocExplorerPlot::setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable)
4470 {
4861 {
4471 ( theWrappedObject->setAdaptativeSampling(graphIndex, enable));
4862 ( theWrappedObject->setAdaptativeSampling(graphIndex, enable));
4472 }
4863 }
4473
4864
4474 void PythonQtWrapper_SocExplorerPlot::setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4865 void PythonQtWrapper_SocExplorerPlot::setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4475 {
4866 {
4476 ( theWrappedObject->setGraphData(graphIndex, x, y));
4867 ( theWrappedObject->setGraphData(graphIndex, x, y));
4477 }
4868 }
4478
4869
4479 void PythonQtWrapper_SocExplorerPlot::setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle)
4870 void PythonQtWrapper_SocExplorerPlot::setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle)
4480 {
4871 {
4481 ( theWrappedObject->setGraphLineStyle(graphIndex, lineStyle));
4872 ( theWrappedObject->setGraphLineStyle(graphIndex, lineStyle));
4482 }
4873 }
4483
4874
4484 void PythonQtWrapper_SocExplorerPlot::setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name)
4875 void PythonQtWrapper_SocExplorerPlot::setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name)
4485 {
4876 {
4486 ( theWrappedObject->setGraphName(graphIndex, name));
4877 ( theWrappedObject->setGraphName(graphIndex, name));
4487 }
4878 }
4488
4879
4489 void PythonQtWrapper_SocExplorerPlot::setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen)
4880 void PythonQtWrapper_SocExplorerPlot::setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen)
4490 {
4881 {
4491 ( theWrappedObject->setGraphPen(graphIndex, pen));
4882 ( theWrappedObject->setGraphPen(graphIndex, pen));
4492 }
4883 }
4493
4884
4494 void PythonQtWrapper_SocExplorerPlot::setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle)
4885 void PythonQtWrapper_SocExplorerPlot::setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle)
4495 {
4886 {
4496 ( theWrappedObject->setGraphScatterStyle(graphIndex, scatterStyle));
4887 ( theWrappedObject->setGraphScatterStyle(graphIndex, scatterStyle));
4497 }
4888 }
4498
4889
4499 void PythonQtWrapper_SocExplorerPlot::setLegendFont(SocExplorerPlot* theWrappedObject, QFont font)
4890 void PythonQtWrapper_SocExplorerPlot::setLegendFont(SocExplorerPlot* theWrappedObject, QFont font)
4500 {
4891 {
4501 ( theWrappedObject->setLegendFont(font));
4892 ( theWrappedObject->setLegendFont(font));
4502 }
4893 }
4503
4894
4504 void PythonQtWrapper_SocExplorerPlot::setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font)
4895 void PythonQtWrapper_SocExplorerPlot::setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font)
4505 {
4896 {
4506 ( theWrappedObject->setLegendSelectedFont(font));
4897 ( theWrappedObject->setLegendSelectedFont(font));
4507 }
4898 }
4508
4899
4509 void PythonQtWrapper_SocExplorerPlot::setTitle(SocExplorerPlot* theWrappedObject, QString title)
4900 void PythonQtWrapper_SocExplorerPlot::setTitle(SocExplorerPlot* theWrappedObject, QString title)
4510 {
4901 {
4511 ( theWrappedObject->setTitle(title));
4902 ( theWrappedObject->setTitle(title));
4512 }
4903 }
4513
4904
4514 void PythonQtWrapper_SocExplorerPlot::setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4905 void PythonQtWrapper_SocExplorerPlot::setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4515 {
4906 {
4516 ( theWrappedObject->setXaxisLabel(label));
4907 ( theWrappedObject->setXaxisLabel(label));
4517 }
4908 }
4518
4909
4519 void PythonQtWrapper_SocExplorerPlot::setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4910 void PythonQtWrapper_SocExplorerPlot::setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4520 {
4911 {
4521 ( theWrappedObject->setXaxisRange(lower, upper));
4912 ( theWrappedObject->setXaxisRange(lower, upper));
4522 }
4913 }
4523
4914
4524 void PythonQtWrapper_SocExplorerPlot::setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4915 void PythonQtWrapper_SocExplorerPlot::setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4525 {
4916 {
4526 ( theWrappedObject->setYaxisLabel(label));
4917 ( theWrappedObject->setYaxisLabel(label));
4527 }
4918 }
4528
4919
4529 void PythonQtWrapper_SocExplorerPlot::setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4920 void PythonQtWrapper_SocExplorerPlot::setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4530 {
4921 {
4531 ( theWrappedObject->setYaxisRange(lower, upper));
4922 ( theWrappedObject->setYaxisRange(lower, upper));
4532 }
4923 }
4533
4924
4534 void PythonQtWrapper_SocExplorerPlot::show(SocExplorerPlot* theWrappedObject)
4925 void PythonQtWrapper_SocExplorerPlot::show(SocExplorerPlot* theWrappedObject)
4535 {
4926 {
4536 ( theWrappedObject->show());
4927 ( theWrappedObject->show());
4537 }
4928 }
4538
4929
4539 void PythonQtWrapper_SocExplorerPlot::wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1)
4930 void PythonQtWrapper_SocExplorerPlot::wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1)
4540 {
4931 {
4541 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_wheelEvent(arg__1));
4932 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_wheelEvent(arg__1));
4542 }
4933 }
4543
4934
4544
4935
4545
4936
4546 PythonQtShell_TCP_Terminal_Client::~PythonQtShell_TCP_Terminal_Client() {
4937 PythonQtShell_TCP_Terminal_Client::~PythonQtShell_TCP_Terminal_Client() {
4547 PythonQtPrivate* priv = PythonQt::priv();
4938 PythonQtPrivate* priv = PythonQt::priv();
4548 if (priv) { priv->shellClassDeleted(this); }
4939 if (priv) { priv->shellClassDeleted(this); }
4549 }
4940 }
4550 void PythonQtShell_TCP_Terminal_Client::childEvent(QChildEvent* arg__1)
4941 void PythonQtShell_TCP_Terminal_Client::childEvent(QChildEvent* arg__1)
4551 {
4942 {
4552 if (_wrapper) {
4943 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4553 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
4944 static PyObject* name = PyString_FromString("childEvent");
4554 PyErr_Clear();
4945 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4555 if (obj && !PythonQtSlotFunction_Check(obj)) {
4946 if (obj) {
4556 static const char* argumentList[] ={"" , "QChildEvent*"};
4947 static const char* argumentList[] ={"" , "QChildEvent*"};
4557 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4948 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4558 void* args[2] = {NULL, (void*)&arg__1};
4949 void* args[2] = {NULL, (void*)&arg__1};
4559 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4950 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4560 if (result) { Py_DECREF(result); }
4951 if (result) { Py_DECREF(result); }
4561 Py_DECREF(obj);
4952 Py_DECREF(obj);
4562 return;
4953 return;
4954 } else {
4955 PyErr_Clear();
4563 }
4956 }
4564 }
4957 }
4565 TCP_Terminal_Client::childEvent(arg__1);
4958 TCP_Terminal_Client::childEvent(arg__1);
4566 }
4959 }
4567 void PythonQtShell_TCP_Terminal_Client::customEvent(QEvent* arg__1)
4960 void PythonQtShell_TCP_Terminal_Client::customEvent(QEvent* arg__1)
4568 {
4961 {
4569 if (_wrapper) {
4962 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4570 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
4963 static PyObject* name = PyString_FromString("customEvent");
4571 PyErr_Clear();
4964 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4572 if (obj && !PythonQtSlotFunction_Check(obj)) {
4965 if (obj) {
4573 static const char* argumentList[] ={"" , "QEvent*"};
4966 static const char* argumentList[] ={"" , "QEvent*"};
4574 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4967 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4575 void* args[2] = {NULL, (void*)&arg__1};
4968 void* args[2] = {NULL, (void*)&arg__1};
4576 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4969 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4577 if (result) { Py_DECREF(result); }
4970 if (result) { Py_DECREF(result); }
4578 Py_DECREF(obj);
4971 Py_DECREF(obj);
4579 return;
4972 return;
4973 } else {
4974 PyErr_Clear();
4580 }
4975 }
4581 }
4976 }
4582 TCP_Terminal_Client::customEvent(arg__1);
4977 TCP_Terminal_Client::customEvent(arg__1);
4583 }
4978 }
4584 bool PythonQtShell_TCP_Terminal_Client::event(QEvent* arg__1)
4979 bool PythonQtShell_TCP_Terminal_Client::event(QEvent* arg__1)
4585 {
4980 {
4586 if (_wrapper) {
4981 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4587 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
4982 static PyObject* name = PyString_FromString("event");
4588 PyErr_Clear();
4983 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4589 if (obj && !PythonQtSlotFunction_Check(obj)) {
4984 if (obj) {
4590 static const char* argumentList[] ={"bool" , "QEvent*"};
4985 static const char* argumentList[] ={"bool" , "QEvent*"};
4591 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4986 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4592 bool returnValue;
4987 bool returnValue;
4593 void* args[2] = {NULL, (void*)&arg__1};
4988 void* args[2] = {NULL, (void*)&arg__1};
4594 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4989 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4595 if (result) {
4990 if (result) {
4596 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4991 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4597 if (args[0]!=&returnValue) {
4992 if (args[0]!=&returnValue) {
4598 if (args[0]==NULL) {
4993 if (args[0]==NULL) {
4599 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
4994 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
4600 } else {
4995 } else {
4601 returnValue = *((bool*)args[0]);
4996 returnValue = *((bool*)args[0]);
4602 }
4997 }
4603 }
4998 }
4604 }
4999 }
4605 if (result) { Py_DECREF(result); }
5000 if (result) { Py_DECREF(result); }
4606 Py_DECREF(obj);
5001 Py_DECREF(obj);
4607 return returnValue;
5002 return returnValue;
5003 } else {
5004 PyErr_Clear();
4608 }
5005 }
4609 }
5006 }
4610 return TCP_Terminal_Client::event(arg__1);
5007 return TCP_Terminal_Client::event(arg__1);
4611 }
5008 }
4612 bool PythonQtShell_TCP_Terminal_Client::eventFilter(QObject* arg__1, QEvent* arg__2)
5009 bool PythonQtShell_TCP_Terminal_Client::eventFilter(QObject* arg__1, QEvent* arg__2)
4613 {
5010 {
4614 if (_wrapper) {
5011 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4615 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
5012 static PyObject* name = PyString_FromString("eventFilter");
4616 PyErr_Clear();
5013 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4617 if (obj && !PythonQtSlotFunction_Check(obj)) {
5014 if (obj) {
4618 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5015 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4619 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5016 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4620 bool returnValue;
5017 bool returnValue;
4621 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
5018 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
4622 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5019 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4623 if (result) {
5020 if (result) {
4624 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5021 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4625 if (args[0]!=&returnValue) {
5022 if (args[0]!=&returnValue) {
4626 if (args[0]==NULL) {
5023 if (args[0]==NULL) {
4627 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
5024 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
4628 } else {
5025 } else {
4629 returnValue = *((bool*)args[0]);
5026 returnValue = *((bool*)args[0]);
4630 }
5027 }
4631 }
5028 }
4632 }
5029 }
4633 if (result) { Py_DECREF(result); }
5030 if (result) { Py_DECREF(result); }
4634 Py_DECREF(obj);
5031 Py_DECREF(obj);
4635 return returnValue;
5032 return returnValue;
5033 } else {
5034 PyErr_Clear();
4636 }
5035 }
4637 }
5036 }
4638 return TCP_Terminal_Client::eventFilter(arg__1, arg__2);
5037 return TCP_Terminal_Client::eventFilter(arg__1, arg__2);
4639 }
5038 }
4640 void PythonQtShell_TCP_Terminal_Client::timerEvent(QTimerEvent* arg__1)
5039 void PythonQtShell_TCP_Terminal_Client::timerEvent(QTimerEvent* arg__1)
4641 {
5040 {
4642 if (_wrapper) {
5041 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4643 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
5042 static PyObject* name = PyString_FromString("timerEvent");
4644 PyErr_Clear();
5043 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4645 if (obj && !PythonQtSlotFunction_Check(obj)) {
5044 if (obj) {
4646 static const char* argumentList[] ={"" , "QTimerEvent*"};
5045 static const char* argumentList[] ={"" , "QTimerEvent*"};
4647 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5046 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4648 void* args[2] = {NULL, (void*)&arg__1};
5047 void* args[2] = {NULL, (void*)&arg__1};
4649 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5048 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4650 if (result) { Py_DECREF(result); }
5049 if (result) { Py_DECREF(result); }
4651 Py_DECREF(obj);
5050 Py_DECREF(obj);
4652 return;
5051 return;
5052 } else {
5053 PyErr_Clear();
4653 }
5054 }
4654 }
5055 }
4655 TCP_Terminal_Client::timerEvent(arg__1);
5056 TCP_Terminal_Client::timerEvent(arg__1);
4656 }
5057 }
4657 TCP_Terminal_Client* PythonQtWrapper_TCP_Terminal_Client::new_TCP_Terminal_Client(QObject* parent)
5058 TCP_Terminal_Client* PythonQtWrapper_TCP_Terminal_Client::new_TCP_Terminal_Client(QObject* parent)
4658 {
5059 {
4659 return new PythonQtShell_TCP_Terminal_Client(parent); }
5060 return new PythonQtShell_TCP_Terminal_Client(parent); }
4660
5061
4661 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject)
5062 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject)
4662 {
5063 {
4663 ( theWrappedObject->connectToServer());
5064 ( theWrappedObject->connectToServer());
4664 }
5065 }
4665
5066
4666 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port)
5067 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port)
4667 {
5068 {
4668 ( theWrappedObject->connectToServer(IP, port));
5069 ( theWrappedObject->connectToServer(IP, port));
4669 }
5070 }
4670
5071
4671 bool PythonQtWrapper_TCP_Terminal_Client::isConnected(TCP_Terminal_Client* theWrappedObject)
5072 bool PythonQtWrapper_TCP_Terminal_Client::isConnected(TCP_Terminal_Client* theWrappedObject)
4672 {
5073 {
4673 return ( theWrappedObject->isConnected());
5074 return ( theWrappedObject->isConnected());
4674 }
5075 }
4675
5076
4676 void PythonQtWrapper_TCP_Terminal_Client::sendText(TCP_Terminal_Client* theWrappedObject, const QString& text)
5077 void PythonQtWrapper_TCP_Terminal_Client::sendText(TCP_Terminal_Client* theWrappedObject, const QString& text)
4677 {
5078 {
4678 ( theWrappedObject->sendText(text));
5079 ( theWrappedObject->sendText(text));
4679 }
5080 }
4680
5081
4681 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject)
5082 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject)
4682 {
5083 {
4683 ( theWrappedObject->startServer());
5084 ( theWrappedObject->startServer());
4684 }
5085 }
4685
5086
4686 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject, int port)
5087 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject, int port)
4687 {
5088 {
4688 ( theWrappedObject->startServer(port));
5089 ( theWrappedObject->startServer(port));
4689 }
5090 }
4690
5091
4691
5092
4692
5093
4693 XByteArray* PythonQtWrapper_XByteArray::new_XByteArray()
5094 XByteArray* PythonQtWrapper_XByteArray::new_XByteArray()
4694 {
5095 {
4695 return new XByteArray(); }
5096 return new XByteArray(); }
4696
5097
4697 int PythonQtWrapper_XByteArray::addressOffset(XByteArray* theWrappedObject)
5098 int PythonQtWrapper_XByteArray::addressOffset(XByteArray* theWrappedObject)
4698 {
5099 {
4699 return ( theWrappedObject->addressOffset());
5100 return ( theWrappedObject->addressOffset());
4700 }
5101 }
4701
5102
4702 int PythonQtWrapper_XByteArray::addressWidth(XByteArray* theWrappedObject)
5103 int PythonQtWrapper_XByteArray::addressWidth(XByteArray* theWrappedObject)
4703 {
5104 {
4704 return ( theWrappedObject->addressWidth());
5105 return ( theWrappedObject->addressWidth());
4705 }
5106 }
4706
5107
4707 QChar PythonQtWrapper_XByteArray::asciiChar(XByteArray* theWrappedObject, int index)
5108 QChar PythonQtWrapper_XByteArray::asciiChar(XByteArray* theWrappedObject, int index)
4708 {
5109 {
4709 return ( theWrappedObject->asciiChar(index));
5110 return ( theWrappedObject->asciiChar(index));
4710 }
5111 }
4711
5112
4712 QByteArray* PythonQtWrapper_XByteArray::data(XByteArray* theWrappedObject)
5113 QByteArray* PythonQtWrapper_XByteArray::data(XByteArray* theWrappedObject)
4713 {
5114 {
4714 return &( theWrappedObject->data());
5115 return &( theWrappedObject->data());
4715 }
5116 }
4716
5117
4717 bool PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i)
5118 bool PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i)
4718 {
5119 {
4719 return ( theWrappedObject->dataChanged(i));
5120 return ( theWrappedObject->dataChanged(i));
4720 }
5121 }
4721
5122
4722 QByteArray PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i, int len)
5123 QByteArray PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i, int len)
4723 {
5124 {
4724 return ( theWrappedObject->dataChanged(i, len));
5125 return ( theWrappedObject->dataChanged(i, len));
4725 }
5126 }
4726
5127
4727 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, char ch)
5128 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, char ch)
4728 {
5129 {
4729 return &( theWrappedObject->insert(i, ch));
5130 return &( theWrappedObject->insert(i, ch));
4730 }
5131 }
4731
5132
4732 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, const QByteArray& ba)
5133 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, const QByteArray& ba)
4733 {
5134 {
4734 return &( theWrappedObject->insert(i, ba));
5135 return &( theWrappedObject->insert(i, ba));
4735 }
5136 }
4736
5137
4737 int PythonQtWrapper_XByteArray::realAddressNumbers(XByteArray* theWrappedObject)
5138 int PythonQtWrapper_XByteArray::realAddressNumbers(XByteArray* theWrappedObject)
4738 {
5139 {
4739 return ( theWrappedObject->realAddressNumbers());
5140 return ( theWrappedObject->realAddressNumbers());
4740 }
5141 }
4741
5142
4742 QByteArray* PythonQtWrapper_XByteArray::remove(XByteArray* theWrappedObject, int pos, int len)
5143 QByteArray* PythonQtWrapper_XByteArray::remove(XByteArray* theWrappedObject, int pos, int len)
4743 {
5144 {
4744 return &( theWrappedObject->remove(pos, len));
5145 return &( theWrappedObject->remove(pos, len));
4745 }
5146 }
4746
5147
4747 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, char ch)
5148 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, char ch)
4748 {
5149 {
4749 return &( theWrappedObject->replace(index, ch));
5150 return &( theWrappedObject->replace(index, ch));
4750 }
5151 }
4751
5152
4752 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, const QByteArray& ba)
5153 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, const QByteArray& ba)
4753 {
5154 {
4754 return &( theWrappedObject->replace(index, ba));
5155 return &( theWrappedObject->replace(index, ba));
4755 }
5156 }
4756
5157
4757 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba)
5158 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba)
4758 {
5159 {
4759 return &( theWrappedObject->replace(index, length, ba));
5160 return &( theWrappedObject->replace(index, length, ba));
4760 }
5161 }
4761
5162
4762 void PythonQtWrapper_XByteArray::setAddressOffset(XByteArray* theWrappedObject, int offset)
5163 void PythonQtWrapper_XByteArray::setAddressOffset(XByteArray* theWrappedObject, int offset)
4763 {
5164 {
4764 ( theWrappedObject->setAddressOffset(offset));
5165 ( theWrappedObject->setAddressOffset(offset));
4765 }
5166 }
4766
5167
4767 void PythonQtWrapper_XByteArray::setAddressWidth(XByteArray* theWrappedObject, int width)
5168 void PythonQtWrapper_XByteArray::setAddressWidth(XByteArray* theWrappedObject, int width)
4768 {
5169 {
4769 ( theWrappedObject->setAddressWidth(width));
5170 ( theWrappedObject->setAddressWidth(width));
4770 }
5171 }
4771
5172
4772 void PythonQtWrapper_XByteArray::setData(XByteArray* theWrappedObject, QByteArray data)
5173 void PythonQtWrapper_XByteArray::setData(XByteArray* theWrappedObject, QByteArray data)
4773 {
5174 {
4774 ( theWrappedObject->setData(data));
5175 ( theWrappedObject->setData(data));
4775 }
5176 }
4776
5177
4777 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, bool state)
5178 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, bool state)
4778 {
5179 {
4779 ( theWrappedObject->setDataChanged(i, state));
5180 ( theWrappedObject->setDataChanged(i, state));
4780 }
5181 }
4781
5182
4782 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state)
5183 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state)
4783 {
5184 {
4784 ( theWrappedObject->setDataChanged(i, state));
5185 ( theWrappedObject->setDataChanged(i, state));
4785 }
5186 }
4786
5187
4787 int PythonQtWrapper_XByteArray::size(XByteArray* theWrappedObject)
5188 int PythonQtWrapper_XByteArray::size(XByteArray* theWrappedObject)
4788 {
5189 {
4789 return ( theWrappedObject->size());
5190 return ( theWrappedObject->size());
4790 }
5191 }
4791
5192
4792 QString PythonQtWrapper_XByteArray::toRedableString(XByteArray* theWrappedObject, int start, int end)
5193 QString PythonQtWrapper_XByteArray::toRedableString(XByteArray* theWrappedObject, int start, int end)
4793 {
5194 {
4794 return ( theWrappedObject->toRedableString(start, end));
5195 return ( theWrappedObject->toRedableString(start, end));
4795 }
5196 }
4796
5197
4797
5198
4798
5199
4799 PythonQtShell_abstractBinFile::~PythonQtShell_abstractBinFile() {
5200 PythonQtShell_abstractBinFile::~PythonQtShell_abstractBinFile() {
4800 PythonQtPrivate* priv = PythonQt::priv();
5201 PythonQtPrivate* priv = PythonQt::priv();
4801 if (priv) { priv->shellClassDeleted(this); }
5202 if (priv) { priv->shellClassDeleted(this); }
4802 }
5203 }
4803 void PythonQtShell_abstractBinFile::childEvent(QChildEvent* arg__1)
5204 void PythonQtShell_abstractBinFile::childEvent(QChildEvent* arg__1)
4804 {
5205 {
4805 if (_wrapper) {
5206 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4806 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
5207 static PyObject* name = PyString_FromString("childEvent");
4807 PyErr_Clear();
5208 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4808 if (obj && !PythonQtSlotFunction_Check(obj)) {
5209 if (obj) {
4809 static const char* argumentList[] ={"" , "QChildEvent*"};
5210 static const char* argumentList[] ={"" , "QChildEvent*"};
4810 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5211 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4811 void* args[2] = {NULL, (void*)&arg__1};
5212 void* args[2] = {NULL, (void*)&arg__1};
4812 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5213 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4813 if (result) { Py_DECREF(result); }
5214 if (result) { Py_DECREF(result); }
4814 Py_DECREF(obj);
5215 Py_DECREF(obj);
4815 return;
5216 return;
5217 } else {
5218 PyErr_Clear();
4816 }
5219 }
4817 }
5220 }
4818 abstractBinFile::childEvent(arg__1);
5221 abstractBinFile::childEvent(arg__1);
4819 }
5222 }
4820 int PythonQtShell_abstractBinFile::closeFile()
5223 int PythonQtShell_abstractBinFile::closeFile()
4821 {
5224 {
4822 if (_wrapper) {
5225 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4823 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
5226 static PyObject* name = PyString_FromString("closeFile");
4824 PyErr_Clear();
5227 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4825 if (obj && !PythonQtSlotFunction_Check(obj)) {
5228 if (obj) {
4826 static const char* argumentList[] ={"int"};
5229 static const char* argumentList[] ={"int"};
4827 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5230 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4828 int returnValue;
5231 int returnValue;
4829 void* args[1] = {NULL};
5232 void* args[1] = {NULL};
4830 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5233 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4831 if (result) {
5234 if (result) {
4832 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5235 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4833 if (args[0]!=&returnValue) {
5236 if (args[0]!=&returnValue) {
4834 if (args[0]==NULL) {
5237 if (args[0]==NULL) {
4835 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
5238 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
4836 } else {
5239 } else {
4837 returnValue = *((int*)args[0]);
5240 returnValue = *((int*)args[0]);
4838 }
5241 }
4839 }
5242 }
4840 }
5243 }
4841 if (result) { Py_DECREF(result); }
5244 if (result) { Py_DECREF(result); }
4842 Py_DECREF(obj);
5245 Py_DECREF(obj);
4843 return returnValue;
5246 return returnValue;
5247 } else {
5248 PyErr_Clear();
4844 }
5249 }
4845 }
5250 }
4846 return int();
5251 return int();
4847 }
5252 }
4848 void PythonQtShell_abstractBinFile::customEvent(QEvent* arg__1)
5253 void PythonQtShell_abstractBinFile::customEvent(QEvent* arg__1)
4849 {
5254 {
4850 if (_wrapper) {
5255 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4851 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
5256 static PyObject* name = PyString_FromString("customEvent");
4852 PyErr_Clear();
5257 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4853 if (obj && !PythonQtSlotFunction_Check(obj)) {
5258 if (obj) {
4854 static const char* argumentList[] ={"" , "QEvent*"};
5259 static const char* argumentList[] ={"" , "QEvent*"};
4855 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5260 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4856 void* args[2] = {NULL, (void*)&arg__1};
5261 void* args[2] = {NULL, (void*)&arg__1};
4857 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5262 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4858 if (result) { Py_DECREF(result); }
5263 if (result) { Py_DECREF(result); }
4859 Py_DECREF(obj);
5264 Py_DECREF(obj);
4860 return;
5265 return;
5266 } else {
5267 PyErr_Clear();
4861 }
5268 }
4862 }
5269 }
4863 abstractBinFile::customEvent(arg__1);
5270 abstractBinFile::customEvent(arg__1);
4864 }
5271 }
4865 bool PythonQtShell_abstractBinFile::event(QEvent* arg__1)
5272 bool PythonQtShell_abstractBinFile::event(QEvent* arg__1)
4866 {
5273 {
4867 if (_wrapper) {
5274 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4868 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
5275 static PyObject* name = PyString_FromString("event");
4869 PyErr_Clear();
5276 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4870 if (obj && !PythonQtSlotFunction_Check(obj)) {
5277 if (obj) {
4871 static const char* argumentList[] ={"bool" , "QEvent*"};
5278 static const char* argumentList[] ={"bool" , "QEvent*"};
4872 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5279 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4873 bool returnValue;
5280 bool returnValue;
4874 void* args[2] = {NULL, (void*)&arg__1};
5281 void* args[2] = {NULL, (void*)&arg__1};
4875 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5282 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4876 if (result) {
5283 if (result) {
4877 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5284 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4878 if (args[0]!=&returnValue) {
5285 if (args[0]!=&returnValue) {
4879 if (args[0]==NULL) {
5286 if (args[0]==NULL) {
4880 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
5287 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
4881 } else {
5288 } else {
4882 returnValue = *((bool*)args[0]);
5289 returnValue = *((bool*)args[0]);
4883 }
5290 }
4884 }
5291 }
4885 }
5292 }
4886 if (result) { Py_DECREF(result); }
5293 if (result) { Py_DECREF(result); }
4887 Py_DECREF(obj);
5294 Py_DECREF(obj);
4888 return returnValue;
5295 return returnValue;
5296 } else {
5297 PyErr_Clear();
4889 }
5298 }
4890 }
5299 }
4891 return abstractBinFile::event(arg__1);
5300 return abstractBinFile::event(arg__1);
4892 }
5301 }
4893 bool PythonQtShell_abstractBinFile::eventFilter(QObject* arg__1, QEvent* arg__2)
5302 bool PythonQtShell_abstractBinFile::eventFilter(QObject* arg__1, QEvent* arg__2)
4894 {
5303 {
4895 if (_wrapper) {
5304 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4896 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
5305 static PyObject* name = PyString_FromString("eventFilter");
4897 PyErr_Clear();
5306 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4898 if (obj && !PythonQtSlotFunction_Check(obj)) {
5307 if (obj) {
4899 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5308 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4900 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5309 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4901 bool returnValue;
5310 bool returnValue;
4902 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
5311 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
4903 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5312 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4904 if (result) {
5313 if (result) {
4905 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5314 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4906 if (args[0]!=&returnValue) {
5315 if (args[0]!=&returnValue) {
4907 if (args[0]==NULL) {
5316 if (args[0]==NULL) {
4908 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
5317 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
4909 } else {
5318 } else {
4910 returnValue = *((bool*)args[0]);
5319 returnValue = *((bool*)args[0]);
4911 }
5320 }
4912 }
5321 }
4913 }
5322 }
4914 if (result) { Py_DECREF(result); }
5323 if (result) { Py_DECREF(result); }
4915 Py_DECREF(obj);
5324 Py_DECREF(obj);
4916 return returnValue;
5325 return returnValue;
5326 } else {
5327 PyErr_Clear();
4917 }
5328 }
4918 }
5329 }
4919 return abstractBinFile::eventFilter(arg__1, arg__2);
5330 return abstractBinFile::eventFilter(arg__1, arg__2);
4920 }
5331 }
4921 QList<codeFragment* > PythonQtShell_abstractBinFile::getFragments()
5332 QList<codeFragment* > PythonQtShell_abstractBinFile::getFragments()
4922 {
5333 {
4923 if (_wrapper) {
5334 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4924 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
5335 static PyObject* name = PyString_FromString("getFragments");
4925 PyErr_Clear();
5336 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4926 if (obj && !PythonQtSlotFunction_Check(obj)) {
5337 if (obj) {
4927 static const char* argumentList[] ={"QList<codeFragment* >"};
5338 static const char* argumentList[] ={"QList<codeFragment* >"};
4928 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5339 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4929 QList<codeFragment* > returnValue;
5340 QList<codeFragment* > returnValue;
4930 void* args[1] = {NULL};
5341 void* args[1] = {NULL};
4931 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5342 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4932 if (result) {
5343 if (result) {
4933 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5344 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4934 if (args[0]!=&returnValue) {
5345 if (args[0]!=&returnValue) {
4935 if (args[0]==NULL) {
5346 if (args[0]==NULL) {
4936 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
5347 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
4937 } else {
5348 } else {
4938 returnValue = *((QList<codeFragment* >*)args[0]);
5349 returnValue = *((QList<codeFragment* >*)args[0]);
4939 }
5350 }
4940 }
5351 }
4941 }
5352 }
4942 if (result) { Py_DECREF(result); }
5353 if (result) { Py_DECREF(result); }
4943 Py_DECREF(obj);
5354 Py_DECREF(obj);
4944 return returnValue;
5355 return returnValue;
5356 } else {
5357 PyErr_Clear();
4945 }
5358 }
4946 }
5359 }
4947 return QList<codeFragment* >();
5360 return QList<codeFragment* >();
4948 }
5361 }
4949 bool PythonQtShell_abstractBinFile::isopened()
5362 bool PythonQtShell_abstractBinFile::isopened()
4950 {
5363 {
4951 if (_wrapper) {
5364 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4952 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
5365 static PyObject* name = PyString_FromString("isopened");
4953 PyErr_Clear();
5366 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4954 if (obj && !PythonQtSlotFunction_Check(obj)) {
5367 if (obj) {
4955 static const char* argumentList[] ={"bool"};
5368 static const char* argumentList[] ={"bool"};
4956 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5369 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4957 bool returnValue;
5370 bool returnValue;
4958 void* args[1] = {NULL};
5371 void* args[1] = {NULL};
4959 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5372 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4960 if (result) {
5373 if (result) {
4961 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5374 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4962 if (args[0]!=&returnValue) {
5375 if (args[0]!=&returnValue) {
4963 if (args[0]==NULL) {
5376 if (args[0]==NULL) {
4964 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
5377 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
4965 } else {
5378 } else {
4966 returnValue = *((bool*)args[0]);
5379 returnValue = *((bool*)args[0]);
4967 }
5380 }
4968 }
5381 }
4969 }
5382 }
4970 if (result) { Py_DECREF(result); }
5383 if (result) { Py_DECREF(result); }
4971 Py_DECREF(obj);
5384 Py_DECREF(obj);
4972 return returnValue;
5385 return returnValue;
5386 } else {
5387 PyErr_Clear();
4973 }
5388 }
4974 }
5389 }
4975 return bool();
5390 return bool();
4976 }
5391 }
4977 bool PythonQtShell_abstractBinFile::openFile(const QString& File)
5392 bool PythonQtShell_abstractBinFile::openFile(const QString& File0)
4978 {
5393 {
4979 if (_wrapper) {
5394 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4980 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
5395 static PyObject* name = PyString_FromString("openFile");
4981 PyErr_Clear();
5396 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4982 if (obj && !PythonQtSlotFunction_Check(obj)) {
5397 if (obj) {
4983 static const char* argumentList[] ={"bool" , "const QString&"};
5398 static const char* argumentList[] ={"bool" , "const QString&"};
4984 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5399 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4985 bool returnValue;
5400 bool returnValue;
4986 void* args[2] = {NULL, (void*)&File};
5401 void* args[2] = {NULL, (void*)&File0};
4987 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5402 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4988 if (result) {
5403 if (result) {
4989 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5404 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4990 if (args[0]!=&returnValue) {
5405 if (args[0]!=&returnValue) {
4991 if (args[0]==NULL) {
5406 if (args[0]==NULL) {
4992 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
5407 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
4993 } else {
5408 } else {
4994 returnValue = *((bool*)args[0]);
5409 returnValue = *((bool*)args[0]);
4995 }
5410 }
4996 }
5411 }
4997 }
5412 }
4998 if (result) { Py_DECREF(result); }
5413 if (result) { Py_DECREF(result); }
4999 Py_DECREF(obj);
5414 Py_DECREF(obj);
5000 return returnValue;
5415 return returnValue;
5416 } else {
5417 PyErr_Clear();
5001 }
5418 }
5002 }
5419 }
5003 return bool();
5420 return bool();
5004 }
5421 }
5005 void PythonQtShell_abstractBinFile::timerEvent(QTimerEvent* arg__1)
5422 void PythonQtShell_abstractBinFile::timerEvent(QTimerEvent* arg__1)
5006 {
5423 {
5007 if (_wrapper) {
5424 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5008 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
5425 static PyObject* name = PyString_FromString("timerEvent");
5009 PyErr_Clear();
5426 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5010 if (obj && !PythonQtSlotFunction_Check(obj)) {
5427 if (obj) {
5011 static const char* argumentList[] ={"" , "QTimerEvent*"};
5428 static const char* argumentList[] ={"" , "QTimerEvent*"};
5012 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5429 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5013 void* args[2] = {NULL, (void*)&arg__1};
5430 void* args[2] = {NULL, (void*)&arg__1};
5014 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5431 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5015 if (result) { Py_DECREF(result); }
5432 if (result) { Py_DECREF(result); }
5016 Py_DECREF(obj);
5433 Py_DECREF(obj);
5017 return;
5434 return;
5435 } else {
5436 PyErr_Clear();
5018 }
5437 }
5019 }
5438 }
5020 abstractBinFile::timerEvent(arg__1);
5439 abstractBinFile::timerEvent(arg__1);
5021 }
5440 }
5022 bool PythonQtShell_abstractBinFile::toBinary(const QString& File)
5441 bool PythonQtShell_abstractBinFile::toBinary(const QString& File0)
5023 {
5442 {
5024 if (_wrapper) {
5443 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5025 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
5444 static PyObject* name = PyString_FromString("toBinary");
5026 PyErr_Clear();
5445 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5027 if (obj && !PythonQtSlotFunction_Check(obj)) {
5446 if (obj) {
5028 static const char* argumentList[] ={"bool" , "const QString&"};
5447 static const char* argumentList[] ={"bool" , "const QString&"};
5029 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5448 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5030 bool returnValue;
5449 bool returnValue;
5031 void* args[2] = {NULL, (void*)&File};
5450 void* args[2] = {NULL, (void*)&File0};
5032 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5451 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5033 if (result) {
5452 if (result) {
5034 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5453 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5035 if (args[0]!=&returnValue) {
5454 if (args[0]!=&returnValue) {
5036 if (args[0]==NULL) {
5455 if (args[0]==NULL) {
5037 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
5456 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
5038 } else {
5457 } else {
5039 returnValue = *((bool*)args[0]);
5458 returnValue = *((bool*)args[0]);
5040 }
5459 }
5041 }
5460 }
5042 }
5461 }
5043 if (result) { Py_DECREF(result); }
5462 if (result) { Py_DECREF(result); }
5044 Py_DECREF(obj);
5463 Py_DECREF(obj);
5045 return returnValue;
5464 return returnValue;
5465 } else {
5466 PyErr_Clear();
5046 }
5467 }
5047 }
5468 }
5048 return bool();
5469 return bool();
5049 }
5470 }
5050 bool PythonQtShell_abstractBinFile::toSrec(const QString& File)
5471 bool PythonQtShell_abstractBinFile::toSrec(const QString& File0)
5051 {
5472 {
5052 if (_wrapper) {
5473 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5053 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
5474 static PyObject* name = PyString_FromString("toSrec");
5054 PyErr_Clear();
5475 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5055 if (obj && !PythonQtSlotFunction_Check(obj)) {
5476 if (obj) {
5056 static const char* argumentList[] ={"bool" , "const QString&"};
5477 static const char* argumentList[] ={"bool" , "const QString&"};
5057 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5478 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5058 bool returnValue;
5479 bool returnValue;
5059 void* args[2] = {NULL, (void*)&File};
5480 void* args[2] = {NULL, (void*)&File0};
5060 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5481 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5061 if (result) {
5482 if (result) {
5062 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5483 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5063 if (args[0]!=&returnValue) {
5484 if (args[0]!=&returnValue) {
5064 if (args[0]==NULL) {
5485 if (args[0]==NULL) {
5065 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
5486 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
5066 } else {
5487 } else {
5067 returnValue = *((bool*)args[0]);
5488 returnValue = *((bool*)args[0]);
5068 }
5489 }
5069 }
5490 }
5070 }
5491 }
5071 if (result) { Py_DECREF(result); }
5492 if (result) { Py_DECREF(result); }
5072 Py_DECREF(obj);
5493 Py_DECREF(obj);
5073 return returnValue;
5494 return returnValue;
5495 } else {
5496 PyErr_Clear();
5074 }
5497 }
5075 }
5498 }
5076 return bool();
5499 return bool();
5077 }
5500 }
5078 abstractBinFile* PythonQtWrapper_abstractBinFile::new_abstractBinFile()
5501 abstractBinFile* PythonQtWrapper_abstractBinFile::new_abstractBinFile()
5079 {
5502 {
5080 return new PythonQtShell_abstractBinFile(); }
5503 return new PythonQtShell_abstractBinFile(); }
5081
5504
5505 int PythonQtWrapper_abstractBinFile::closeFile(abstractBinFile* theWrappedObject)
5506 {
5507 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_closeFile());
5508 }
5509
5510 QList<codeFragment* > PythonQtWrapper_abstractBinFile::getFragments(abstractBinFile* theWrappedObject)
5511 {
5512 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_getFragments());
5513 }
5514
5515 bool PythonQtWrapper_abstractBinFile::isopened(abstractBinFile* theWrappedObject)
5516 {
5517 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_isopened());
5518 }
5519
5520 bool PythonQtWrapper_abstractBinFile::openFile(abstractBinFile* theWrappedObject, const QString& File)
5521 {
5522 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_openFile(File));
5523 }
5524
5525 bool PythonQtWrapper_abstractBinFile::toBinary(abstractBinFile* theWrappedObject, const QString& File)
5526 {
5527 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_toBinary(File));
5528 }
5529
5530 bool PythonQtWrapper_abstractBinFile::toSrec(abstractBinFile* theWrappedObject, const QString& File)
5531 {
5532 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_toSrec(File));
5533 }
5534
5082
5535
5083
5536
5084 PythonQtShell_abstractBinFileWidget::~PythonQtShell_abstractBinFileWidget() {
5537 PythonQtShell_abstractBinFileWidget::~PythonQtShell_abstractBinFileWidget() {
5085 PythonQtPrivate* priv = PythonQt::priv();
5538 PythonQtPrivate* priv = PythonQt::priv();
5086 if (priv) { priv->shellClassDeleted(this); }
5539 if (priv) { priv->shellClassDeleted(this); }
5087 }
5540 }
5088 void PythonQtShell_abstractBinFileWidget::actionEvent(QActionEvent* arg__1)
5541 void PythonQtShell_abstractBinFileWidget::actionEvent(QActionEvent* arg__1)
5089 {
5542 {
5090 if (_wrapper) {
5543 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5091 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
5544 static PyObject* name = PyString_FromString("actionEvent");
5092 PyErr_Clear();
5545 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5093 if (obj && !PythonQtSlotFunction_Check(obj)) {
5546 if (obj) {
5094 static const char* argumentList[] ={"" , "QActionEvent*"};
5547 static const char* argumentList[] ={"" , "QActionEvent*"};
5095 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5548 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5096 void* args[2] = {NULL, (void*)&arg__1};
5549 void* args[2] = {NULL, (void*)&arg__1};
5097 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5550 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5098 if (result) { Py_DECREF(result); }
5551 if (result) { Py_DECREF(result); }
5099 Py_DECREF(obj);
5552 Py_DECREF(obj);
5100 return;
5553 return;
5554 } else {
5555 PyErr_Clear();
5101 }
5556 }
5102 }
5557 }
5103 abstractBinFileWidget::actionEvent(arg__1);
5558 abstractBinFileWidget::actionEvent(arg__1);
5104 }
5559 }
5105 void PythonQtShell_abstractBinFileWidget::changeEvent(QEvent* arg__1)
5560 void PythonQtShell_abstractBinFileWidget::changeEvent(QEvent* arg__1)
5106 {
5561 {
5107 if (_wrapper) {
5562 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5108 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
5563 static PyObject* name = PyString_FromString("changeEvent");
5109 PyErr_Clear();
5564 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5110 if (obj && !PythonQtSlotFunction_Check(obj)) {
5565 if (obj) {
5111 static const char* argumentList[] ={"" , "QEvent*"};
5566 static const char* argumentList[] ={"" , "QEvent*"};
5112 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5567 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5113 void* args[2] = {NULL, (void*)&arg__1};
5568 void* args[2] = {NULL, (void*)&arg__1};
5114 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5569 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5115 if (result) { Py_DECREF(result); }
5570 if (result) { Py_DECREF(result); }
5116 Py_DECREF(obj);
5571 Py_DECREF(obj);
5117 return;
5572 return;
5573 } else {
5574 PyErr_Clear();
5118 }
5575 }
5119 }
5576 }
5120 abstractBinFileWidget::changeEvent(arg__1);
5577 abstractBinFileWidget::changeEvent(arg__1);
5121 }
5578 }
5122 void PythonQtShell_abstractBinFileWidget::childEvent(QChildEvent* arg__1)
5579 void PythonQtShell_abstractBinFileWidget::childEvent(QChildEvent* arg__1)
5123 {
5580 {
5124 if (_wrapper) {
5581 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5125 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
5582 static PyObject* name = PyString_FromString("childEvent");
5126 PyErr_Clear();
5583 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5127 if (obj && !PythonQtSlotFunction_Check(obj)) {
5584 if (obj) {
5128 static const char* argumentList[] ={"" , "QChildEvent*"};
5585 static const char* argumentList[] ={"" , "QChildEvent*"};
5129 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5586 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5130 void* args[2] = {NULL, (void*)&arg__1};
5587 void* args[2] = {NULL, (void*)&arg__1};
5131 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5588 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5132 if (result) { Py_DECREF(result); }
5589 if (result) { Py_DECREF(result); }
5133 Py_DECREF(obj);
5590 Py_DECREF(obj);
5134 return;
5591 return;
5592 } else {
5593 PyErr_Clear();
5135 }
5594 }
5136 }
5595 }
5137 abstractBinFileWidget::childEvent(arg__1);
5596 abstractBinFileWidget::childEvent(arg__1);
5138 }
5597 }
5139 void PythonQtShell_abstractBinFileWidget::closeEvent(QCloseEvent* arg__1)
5598 void PythonQtShell_abstractBinFileWidget::closeEvent(QCloseEvent* arg__1)
5140 {
5599 {
5141 if (_wrapper) {
5600 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5142 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
5601 static PyObject* name = PyString_FromString("closeEvent");
5143 PyErr_Clear();
5602 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5144 if (obj && !PythonQtSlotFunction_Check(obj)) {
5603 if (obj) {
5145 static const char* argumentList[] ={"" , "QCloseEvent*"};
5604 static const char* argumentList[] ={"" , "QCloseEvent*"};
5146 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5605 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5147 void* args[2] = {NULL, (void*)&arg__1};
5606 void* args[2] = {NULL, (void*)&arg__1};
5148 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5607 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5149 if (result) { Py_DECREF(result); }
5608 if (result) { Py_DECREF(result); }
5150 Py_DECREF(obj);
5609 Py_DECREF(obj);
5151 return;
5610 return;
5611 } else {
5612 PyErr_Clear();
5152 }
5613 }
5153 }
5614 }
5154 abstractBinFileWidget::closeEvent(arg__1);
5615 abstractBinFileWidget::closeEvent(arg__1);
5155 }
5616 }
5156 void PythonQtShell_abstractBinFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
5617 void PythonQtShell_abstractBinFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
5157 {
5618 {
5158 if (_wrapper) {
5619 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5159 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
5620 static PyObject* name = PyString_FromString("contextMenuEvent");
5160 PyErr_Clear();
5621 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5161 if (obj && !PythonQtSlotFunction_Check(obj)) {
5622 if (obj) {
5162 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
5623 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
5163 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5624 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5164 void* args[2] = {NULL, (void*)&arg__1};
5625 void* args[2] = {NULL, (void*)&arg__1};
5165 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5626 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5166 if (result) { Py_DECREF(result); }
5627 if (result) { Py_DECREF(result); }
5167 Py_DECREF(obj);
5628 Py_DECREF(obj);
5168 return;
5629 return;
5630 } else {
5631 PyErr_Clear();
5169 }
5632 }
5170 }
5633 }
5171 abstractBinFileWidget::contextMenuEvent(arg__1);
5634 abstractBinFileWidget::contextMenuEvent(arg__1);
5172 }
5635 }
5173 void PythonQtShell_abstractBinFileWidget::customEvent(QEvent* arg__1)
5636 void PythonQtShell_abstractBinFileWidget::customEvent(QEvent* arg__1)
5174 {
5637 {
5175 if (_wrapper) {
5638 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5176 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
5639 static PyObject* name = PyString_FromString("customEvent");
5177 PyErr_Clear();
5640 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5178 if (obj && !PythonQtSlotFunction_Check(obj)) {
5641 if (obj) {
5179 static const char* argumentList[] ={"" , "QEvent*"};
5642 static const char* argumentList[] ={"" , "QEvent*"};
5180 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5643 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5181 void* args[2] = {NULL, (void*)&arg__1};
5644 void* args[2] = {NULL, (void*)&arg__1};
5182 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5645 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5183 if (result) { Py_DECREF(result); }
5646 if (result) { Py_DECREF(result); }
5184 Py_DECREF(obj);
5647 Py_DECREF(obj);
5185 return;
5648 return;
5649 } else {
5650 PyErr_Clear();
5186 }
5651 }
5187 }
5652 }
5188 abstractBinFileWidget::customEvent(arg__1);
5653 abstractBinFileWidget::customEvent(arg__1);
5189 }
5654 }
5190 int PythonQtShell_abstractBinFileWidget::devType() const
5655 int PythonQtShell_abstractBinFileWidget::devType() const
5191 {
5656 {
5192 if (_wrapper) {
5657 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5193 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
5658 static PyObject* name = PyString_FromString("devType");
5194 PyErr_Clear();
5659 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5195 if (obj && !PythonQtSlotFunction_Check(obj)) {
5660 if (obj) {
5196 static const char* argumentList[] ={"int"};
5661 static const char* argumentList[] ={"int"};
5197 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5662 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5198 int returnValue;
5663 int returnValue;
5199 void* args[1] = {NULL};
5664 void* args[1] = {NULL};
5200 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5665 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5201 if (result) {
5666 if (result) {
5202 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5667 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5203 if (args[0]!=&returnValue) {
5668 if (args[0]!=&returnValue) {
5204 if (args[0]==NULL) {
5669 if (args[0]==NULL) {
5205 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
5670 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
5206 } else {
5671 } else {
5207 returnValue = *((int*)args[0]);
5672 returnValue = *((int*)args[0]);
5208 }
5673 }
5209 }
5674 }
5210 }
5675 }
5211 if (result) { Py_DECREF(result); }
5676 if (result) { Py_DECREF(result); }
5212 Py_DECREF(obj);
5677 Py_DECREF(obj);
5213 return returnValue;
5678 return returnValue;
5679 } else {
5680 PyErr_Clear();
5214 }
5681 }
5215 }
5682 }
5216 return abstractBinFileWidget::devType();
5683 return abstractBinFileWidget::devType();
5217 }
5684 }
5218 void PythonQtShell_abstractBinFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
5685 void PythonQtShell_abstractBinFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
5219 {
5686 {
5220 if (_wrapper) {
5687 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5221 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
5688 static PyObject* name = PyString_FromString("dragEnterEvent");
5222 PyErr_Clear();
5689 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5223 if (obj && !PythonQtSlotFunction_Check(obj)) {
5690 if (obj) {
5224 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
5691 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
5225 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5692 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5226 void* args[2] = {NULL, (void*)&arg__1};
5693 void* args[2] = {NULL, (void*)&arg__1};
5227 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5694 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5228 if (result) { Py_DECREF(result); }
5695 if (result) { Py_DECREF(result); }
5229 Py_DECREF(obj);
5696 Py_DECREF(obj);
5230 return;
5697 return;
5698 } else {
5699 PyErr_Clear();
5231 }
5700 }
5232 }
5701 }
5233 abstractBinFileWidget::dragEnterEvent(arg__1);
5702 abstractBinFileWidget::dragEnterEvent(arg__1);
5234 }
5703 }
5235 void PythonQtShell_abstractBinFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
5704 void PythonQtShell_abstractBinFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
5236 {
5705 {
5237 if (_wrapper) {
5706 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5238 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
5707 static PyObject* name = PyString_FromString("dragLeaveEvent");
5239 PyErr_Clear();
5708 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5240 if (obj && !PythonQtSlotFunction_Check(obj)) {
5709 if (obj) {
5241 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
5710 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
5242 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5711 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5243 void* args[2] = {NULL, (void*)&arg__1};
5712 void* args[2] = {NULL, (void*)&arg__1};
5244 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5713 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5245 if (result) { Py_DECREF(result); }
5714 if (result) { Py_DECREF(result); }
5246 Py_DECREF(obj);
5715 Py_DECREF(obj);
5247 return;
5716 return;
5717 } else {
5718 PyErr_Clear();
5248 }
5719 }
5249 }
5720 }
5250 abstractBinFileWidget::dragLeaveEvent(arg__1);
5721 abstractBinFileWidget::dragLeaveEvent(arg__1);
5251 }
5722 }
5252 void PythonQtShell_abstractBinFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
5723 void PythonQtShell_abstractBinFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
5253 {
5724 {
5254 if (_wrapper) {
5725 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5255 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
5726 static PyObject* name = PyString_FromString("dragMoveEvent");
5256 PyErr_Clear();
5727 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5257 if (obj && !PythonQtSlotFunction_Check(obj)) {
5728 if (obj) {
5258 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
5729 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
5259 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5730 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5260 void* args[2] = {NULL, (void*)&arg__1};
5731 void* args[2] = {NULL, (void*)&arg__1};
5261 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5732 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5262 if (result) { Py_DECREF(result); }
5733 if (result) { Py_DECREF(result); }
5263 Py_DECREF(obj);
5734 Py_DECREF(obj);
5264 return;
5735 return;
5736 } else {
5737 PyErr_Clear();
5265 }
5738 }
5266 }
5739 }
5267 abstractBinFileWidget::dragMoveEvent(arg__1);
5740 abstractBinFileWidget::dragMoveEvent(arg__1);
5268 }
5741 }
5269 void PythonQtShell_abstractBinFileWidget::dropEvent(QDropEvent* arg__1)
5742 void PythonQtShell_abstractBinFileWidget::dropEvent(QDropEvent* arg__1)
5270 {
5743 {
5271 if (_wrapper) {
5744 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5272 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
5745 static PyObject* name = PyString_FromString("dropEvent");
5273 PyErr_Clear();
5746 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5274 if (obj && !PythonQtSlotFunction_Check(obj)) {
5747 if (obj) {
5275 static const char* argumentList[] ={"" , "QDropEvent*"};
5748 static const char* argumentList[] ={"" , "QDropEvent*"};
5276 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5749 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5277 void* args[2] = {NULL, (void*)&arg__1};
5750 void* args[2] = {NULL, (void*)&arg__1};
5278 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5751 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5279 if (result) { Py_DECREF(result); }
5752 if (result) { Py_DECREF(result); }
5280 Py_DECREF(obj);
5753 Py_DECREF(obj);
5281 return;
5754 return;
5755 } else {
5756 PyErr_Clear();
5282 }
5757 }
5283 }
5758 }
5284 abstractBinFileWidget::dropEvent(arg__1);
5759 abstractBinFileWidget::dropEvent(arg__1);
5285 }
5760 }
5286 void PythonQtShell_abstractBinFileWidget::enterEvent(QEvent* arg__1)
5761 void PythonQtShell_abstractBinFileWidget::enterEvent(QEvent* arg__1)
5287 {
5762 {
5288 if (_wrapper) {
5763 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5289 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
5764 static PyObject* name = PyString_FromString("enterEvent");
5290 PyErr_Clear();
5765 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5291 if (obj && !PythonQtSlotFunction_Check(obj)) {
5766 if (obj) {
5292 static const char* argumentList[] ={"" , "QEvent*"};
5767 static const char* argumentList[] ={"" , "QEvent*"};
5293 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5768 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5294 void* args[2] = {NULL, (void*)&arg__1};
5769 void* args[2] = {NULL, (void*)&arg__1};
5295 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5770 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5296 if (result) { Py_DECREF(result); }
5771 if (result) { Py_DECREF(result); }
5297 Py_DECREF(obj);
5772 Py_DECREF(obj);
5298 return;
5773 return;
5774 } else {
5775 PyErr_Clear();
5299 }
5776 }
5300 }
5777 }
5301 abstractBinFileWidget::enterEvent(arg__1);
5778 abstractBinFileWidget::enterEvent(arg__1);
5302 }
5779 }
5303 bool PythonQtShell_abstractBinFileWidget::event(QEvent* arg__1)
5780 bool PythonQtShell_abstractBinFileWidget::event(QEvent* arg__1)
5304 {
5781 {
5305 if (_wrapper) {
5782 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5306 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
5783 static PyObject* name = PyString_FromString("event");
5307 PyErr_Clear();
5784 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5308 if (obj && !PythonQtSlotFunction_Check(obj)) {
5785 if (obj) {
5309 static const char* argumentList[] ={"bool" , "QEvent*"};
5786 static const char* argumentList[] ={"bool" , "QEvent*"};
5310 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5787 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5311 bool returnValue;
5788 bool returnValue;
5312 void* args[2] = {NULL, (void*)&arg__1};
5789 void* args[2] = {NULL, (void*)&arg__1};
5313 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5790 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5314 if (result) {
5791 if (result) {
5315 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5792 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5316 if (args[0]!=&returnValue) {
5793 if (args[0]!=&returnValue) {
5317 if (args[0]==NULL) {
5794 if (args[0]==NULL) {
5318 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
5795 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
5319 } else {
5796 } else {
5320 returnValue = *((bool*)args[0]);
5797 returnValue = *((bool*)args[0]);
5321 }
5798 }
5322 }
5799 }
5323 }
5800 }
5324 if (result) { Py_DECREF(result); }
5801 if (result) { Py_DECREF(result); }
5325 Py_DECREF(obj);
5802 Py_DECREF(obj);
5326 return returnValue;
5803 return returnValue;
5804 } else {
5805 PyErr_Clear();
5327 }
5806 }
5328 }
5807 }
5329 return abstractBinFileWidget::event(arg__1);
5808 return abstractBinFileWidget::event(arg__1);
5330 }
5809 }
5331 bool PythonQtShell_abstractBinFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
5810 bool PythonQtShell_abstractBinFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
5332 {
5811 {
5333 if (_wrapper) {
5812 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5334 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
5813 static PyObject* name = PyString_FromString("eventFilter");
5335 PyErr_Clear();
5814 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5336 if (obj && !PythonQtSlotFunction_Check(obj)) {
5815 if (obj) {
5337 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5816 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5338 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5817 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5339 bool returnValue;
5818 bool returnValue;
5340 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
5819 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
5341 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5820 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5342 if (result) {
5821 if (result) {
5343 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5822 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5344 if (args[0]!=&returnValue) {
5823 if (args[0]!=&returnValue) {
5345 if (args[0]==NULL) {
5824 if (args[0]==NULL) {
5346 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
5825 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
5347 } else {
5826 } else {
5348 returnValue = *((bool*)args[0]);
5827 returnValue = *((bool*)args[0]);
5349 }
5828 }
5350 }
5829 }
5351 }
5830 }
5352 if (result) { Py_DECREF(result); }
5831 if (result) { Py_DECREF(result); }
5353 Py_DECREF(obj);
5832 Py_DECREF(obj);
5354 return returnValue;
5833 return returnValue;
5834 } else {
5835 PyErr_Clear();
5355 }
5836 }
5356 }
5837 }
5357 return abstractBinFileWidget::eventFilter(arg__1, arg__2);
5838 return abstractBinFileWidget::eventFilter(arg__1, arg__2);
5358 }
5839 }
5359 void PythonQtShell_abstractBinFileWidget::focusInEvent(QFocusEvent* arg__1)
5840 void PythonQtShell_abstractBinFileWidget::focusInEvent(QFocusEvent* arg__1)
5360 {
5841 {
5361 if (_wrapper) {
5842 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5362 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
5843 static PyObject* name = PyString_FromString("focusInEvent");
5363 PyErr_Clear();
5844 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5364 if (obj && !PythonQtSlotFunction_Check(obj)) {
5845 if (obj) {
5365 static const char* argumentList[] ={"" , "QFocusEvent*"};
5846 static const char* argumentList[] ={"" , "QFocusEvent*"};
5366 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5847 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5367 void* args[2] = {NULL, (void*)&arg__1};
5848 void* args[2] = {NULL, (void*)&arg__1};
5368 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5849 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5369 if (result) { Py_DECREF(result); }
5850 if (result) { Py_DECREF(result); }
5370 Py_DECREF(obj);
5851 Py_DECREF(obj);
5371 return;
5852 return;
5853 } else {
5854 PyErr_Clear();
5372 }
5855 }
5373 }
5856 }
5374 abstractBinFileWidget::focusInEvent(arg__1);
5857 abstractBinFileWidget::focusInEvent(arg__1);
5375 }
5858 }
5376 bool PythonQtShell_abstractBinFileWidget::focusNextPrevChild(bool next)
5859 bool PythonQtShell_abstractBinFileWidget::focusNextPrevChild(bool next0)
5377 {
5860 {
5378 if (_wrapper) {
5861 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5379 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
5862 static PyObject* name = PyString_FromString("focusNextPrevChild");
5380 PyErr_Clear();
5863 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5381 if (obj && !PythonQtSlotFunction_Check(obj)) {
5864 if (obj) {
5382 static const char* argumentList[] ={"bool" , "bool"};
5865 static const char* argumentList[] ={"bool" , "bool"};
5383 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5866 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5384 bool returnValue;
5867 bool returnValue;
5385 void* args[2] = {NULL, (void*)&next};
5868 void* args[2] = {NULL, (void*)&next0};
5386 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5869 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5387 if (result) {
5870 if (result) {
5388 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5871 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5389 if (args[0]!=&returnValue) {
5872 if (args[0]!=&returnValue) {
5390 if (args[0]==NULL) {
5873 if (args[0]==NULL) {
5391 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
5874 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
5392 } else {
5875 } else {
5393 returnValue = *((bool*)args[0]);
5876 returnValue = *((bool*)args[0]);
5394 }
5877 }
5395 }
5878 }
5396 }
5879 }
5397 if (result) { Py_DECREF(result); }
5880 if (result) { Py_DECREF(result); }
5398 Py_DECREF(obj);
5881 Py_DECREF(obj);
5399 return returnValue;
5882 return returnValue;
5400 }
5883 } else {
5401 }
5884 PyErr_Clear();
5402 return abstractBinFileWidget::focusNextPrevChild(next);
5885 }
5886 }
5887 return abstractBinFileWidget::focusNextPrevChild(next0);
5403 }
5888 }
5404 void PythonQtShell_abstractBinFileWidget::focusOutEvent(QFocusEvent* arg__1)
5889 void PythonQtShell_abstractBinFileWidget::focusOutEvent(QFocusEvent* arg__1)
5405 {
5890 {
5406 if (_wrapper) {
5891 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5407 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
5892 static PyObject* name = PyString_FromString("focusOutEvent");
5408 PyErr_Clear();
5893 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5409 if (obj && !PythonQtSlotFunction_Check(obj)) {
5894 if (obj) {
5410 static const char* argumentList[] ={"" , "QFocusEvent*"};
5895 static const char* argumentList[] ={"" , "QFocusEvent*"};
5411 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5896 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5412 void* args[2] = {NULL, (void*)&arg__1};
5897 void* args[2] = {NULL, (void*)&arg__1};
5413 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5898 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5414 if (result) { Py_DECREF(result); }
5899 if (result) { Py_DECREF(result); }
5415 Py_DECREF(obj);
5900 Py_DECREF(obj);
5416 return;
5901 return;
5902 } else {
5903 PyErr_Clear();
5417 }
5904 }
5418 }
5905 }
5419 abstractBinFileWidget::focusOutEvent(arg__1);
5906 abstractBinFileWidget::focusOutEvent(arg__1);
5420 }
5907 }
5421 bool PythonQtShell_abstractBinFileWidget::hasHeightForWidth() const
5908 bool PythonQtShell_abstractBinFileWidget::hasHeightForWidth() const
5422 {
5909 {
5423 if (_wrapper) {
5910 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5424 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
5911 static PyObject* name = PyString_FromString("hasHeightForWidth");
5425 PyErr_Clear();
5912 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5426 if (obj && !PythonQtSlotFunction_Check(obj)) {
5913 if (obj) {
5427 static const char* argumentList[] ={"bool"};
5914 static const char* argumentList[] ={"bool"};
5428 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5915 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5429 bool returnValue;
5916 bool returnValue;
5430 void* args[1] = {NULL};
5917 void* args[1] = {NULL};
5431 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5918 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5432 if (result) {
5919 if (result) {
5433 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5920 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5434 if (args[0]!=&returnValue) {
5921 if (args[0]!=&returnValue) {
5435 if (args[0]==NULL) {
5922 if (args[0]==NULL) {
5436 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
5923 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
5437 } else {
5924 } else {
5438 returnValue = *((bool*)args[0]);
5925 returnValue = *((bool*)args[0]);
5439 }
5926 }
5440 }
5927 }
5441 }
5928 }
5442 if (result) { Py_DECREF(result); }
5929 if (result) { Py_DECREF(result); }
5443 Py_DECREF(obj);
5930 Py_DECREF(obj);
5444 return returnValue;
5931 return returnValue;
5932 } else {
5933 PyErr_Clear();
5445 }
5934 }
5446 }
5935 }
5447 return abstractBinFileWidget::hasHeightForWidth();
5936 return abstractBinFileWidget::hasHeightForWidth();
5448 }
5937 }
5449 int PythonQtShell_abstractBinFileWidget::heightForWidth(int arg__1) const
5938 int PythonQtShell_abstractBinFileWidget::heightForWidth(int arg__1) const
5450 {
5939 {
5451 if (_wrapper) {
5940 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5452 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
5941 static PyObject* name = PyString_FromString("heightForWidth");
5453 PyErr_Clear();
5942 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5454 if (obj && !PythonQtSlotFunction_Check(obj)) {
5943 if (obj) {
5455 static const char* argumentList[] ={"int" , "int"};
5944 static const char* argumentList[] ={"int" , "int"};
5456 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5945 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5457 int returnValue;
5946 int returnValue;
5458 void* args[2] = {NULL, (void*)&arg__1};
5947 void* args[2] = {NULL, (void*)&arg__1};
5459 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5948 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5460 if (result) {
5949 if (result) {
5461 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5950 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5462 if (args[0]!=&returnValue) {
5951 if (args[0]!=&returnValue) {
5463 if (args[0]==NULL) {
5952 if (args[0]==NULL) {
5464 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
5953 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
5465 } else {
5954 } else {
5466 returnValue = *((int*)args[0]);
5955 returnValue = *((int*)args[0]);
5467 }
5956 }
5468 }
5957 }
5469 }
5958 }
5470 if (result) { Py_DECREF(result); }
5959 if (result) { Py_DECREF(result); }
5471 Py_DECREF(obj);
5960 Py_DECREF(obj);
5472 return returnValue;
5961 return returnValue;
5962 } else {
5963 PyErr_Clear();
5473 }
5964 }
5474 }
5965 }
5475 return abstractBinFileWidget::heightForWidth(arg__1);
5966 return abstractBinFileWidget::heightForWidth(arg__1);
5476 }
5967 }
5477 void PythonQtShell_abstractBinFileWidget::hideEvent(QHideEvent* arg__1)
5968 void PythonQtShell_abstractBinFileWidget::hideEvent(QHideEvent* arg__1)
5478 {
5969 {
5479 if (_wrapper) {
5970 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5480 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
5971 static PyObject* name = PyString_FromString("hideEvent");
5481 PyErr_Clear();
5972 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5482 if (obj && !PythonQtSlotFunction_Check(obj)) {
5973 if (obj) {
5483 static const char* argumentList[] ={"" , "QHideEvent*"};
5974 static const char* argumentList[] ={"" , "QHideEvent*"};
5484 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5975 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5485 void* args[2] = {NULL, (void*)&arg__1};
5976 void* args[2] = {NULL, (void*)&arg__1};
5486 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5977 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5487 if (result) { Py_DECREF(result); }
5978 if (result) { Py_DECREF(result); }
5488 Py_DECREF(obj);
5979 Py_DECREF(obj);
5489 return;
5980 return;
5981 } else {
5982 PyErr_Clear();
5490 }
5983 }
5491 }
5984 }
5492 abstractBinFileWidget::hideEvent(arg__1);
5985 abstractBinFileWidget::hideEvent(arg__1);
5493 }
5986 }
5494 void PythonQtShell_abstractBinFileWidget::initPainter(QPainter* painter) const
5987 void PythonQtShell_abstractBinFileWidget::initPainter(QPainter* painter0) const
5495 {
5988 {
5496 if (_wrapper) {
5989 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5497 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
5990 static PyObject* name = PyString_FromString("initPainter");
5498 PyErr_Clear();
5991 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5499 if (obj && !PythonQtSlotFunction_Check(obj)) {
5992 if (obj) {
5500 static const char* argumentList[] ={"" , "QPainter*"};
5993 static const char* argumentList[] ={"" , "QPainter*"};
5501 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5994 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5502 void* args[2] = {NULL, (void*)&painter};
5995 void* args[2] = {NULL, (void*)&painter0};
5503 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5996 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5504 if (result) { Py_DECREF(result); }
5997 if (result) { Py_DECREF(result); }
5505 Py_DECREF(obj);
5998 Py_DECREF(obj);
5506 return;
5999 return;
5507 }
6000 } else {
5508 }
6001 PyErr_Clear();
5509 abstractBinFileWidget::initPainter(painter);
6002 }
6003 }
6004 abstractBinFileWidget::initPainter(painter0);
5510 }
6005 }
5511 void PythonQtShell_abstractBinFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
6006 void PythonQtShell_abstractBinFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
5512 {
6007 {
5513 if (_wrapper) {
6008 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5514 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
6009 static PyObject* name = PyString_FromString("inputMethodEvent");
5515 PyErr_Clear();
6010 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5516 if (obj && !PythonQtSlotFunction_Check(obj)) {
6011 if (obj) {
5517 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
6012 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
5518 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6013 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5519 void* args[2] = {NULL, (void*)&arg__1};
6014 void* args[2] = {NULL, (void*)&arg__1};
5520 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6015 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5521 if (result) { Py_DECREF(result); }
6016 if (result) { Py_DECREF(result); }
5522 Py_DECREF(obj);
6017 Py_DECREF(obj);
5523 return;
6018 return;
6019 } else {
6020 PyErr_Clear();
5524 }
6021 }
5525 }
6022 }
5526 abstractBinFileWidget::inputMethodEvent(arg__1);
6023 abstractBinFileWidget::inputMethodEvent(arg__1);
5527 }
6024 }
5528 QVariant PythonQtShell_abstractBinFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
6025 QVariant PythonQtShell_abstractBinFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
5529 {
6026 {
5530 if (_wrapper) {
6027 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5531 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
6028 static PyObject* name = PyString_FromString("inputMethodQuery");
5532 PyErr_Clear();
6029 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5533 if (obj && !PythonQtSlotFunction_Check(obj)) {
6030 if (obj) {
5534 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
6031 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
5535 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6032 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5536 QVariant returnValue;
6033 QVariant returnValue;
5537 void* args[2] = {NULL, (void*)&arg__1};
6034 void* args[2] = {NULL, (void*)&arg__1};
5538 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6035 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5539 if (result) {
6036 if (result) {
5540 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6037 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5541 if (args[0]!=&returnValue) {
6038 if (args[0]!=&returnValue) {
5542 if (args[0]==NULL) {
6039 if (args[0]==NULL) {
5543 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
6040 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
5544 } else {
6041 } else {
5545 returnValue = *((QVariant*)args[0]);
6042 returnValue = *((QVariant*)args[0]);
5546 }
6043 }
5547 }
6044 }
5548 }
6045 }
5549 if (result) { Py_DECREF(result); }
6046 if (result) { Py_DECREF(result); }
5550 Py_DECREF(obj);
6047 Py_DECREF(obj);
5551 return returnValue;
6048 return returnValue;
6049 } else {
6050 PyErr_Clear();
5552 }
6051 }
5553 }
6052 }
5554 return abstractBinFileWidget::inputMethodQuery(arg__1);
6053 return abstractBinFileWidget::inputMethodQuery(arg__1);
5555 }
6054 }
5556 void PythonQtShell_abstractBinFileWidget::keyPressEvent(QKeyEvent* arg__1)
6055 void PythonQtShell_abstractBinFileWidget::keyPressEvent(QKeyEvent* arg__1)
5557 {
6056 {
5558 if (_wrapper) {
6057 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5559 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
6058 static PyObject* name = PyString_FromString("keyPressEvent");
5560 PyErr_Clear();
6059 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5561 if (obj && !PythonQtSlotFunction_Check(obj)) {
6060 if (obj) {
5562 static const char* argumentList[] ={"" , "QKeyEvent*"};
6061 static const char* argumentList[] ={"" , "QKeyEvent*"};
5563 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6062 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5564 void* args[2] = {NULL, (void*)&arg__1};
6063 void* args[2] = {NULL, (void*)&arg__1};
5565 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6064 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5566 if (result) { Py_DECREF(result); }
6065 if (result) { Py_DECREF(result); }
5567 Py_DECREF(obj);
6066 Py_DECREF(obj);
5568 return;
6067 return;
6068 } else {
6069 PyErr_Clear();
5569 }
6070 }
5570 }
6071 }
5571 abstractBinFileWidget::keyPressEvent(arg__1);
6072 abstractBinFileWidget::keyPressEvent(arg__1);
5572 }
6073 }
5573 void PythonQtShell_abstractBinFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
6074 void PythonQtShell_abstractBinFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
5574 {
6075 {
5575 if (_wrapper) {
6076 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5576 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
6077 static PyObject* name = PyString_FromString("keyReleaseEvent");
5577 PyErr_Clear();
6078 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5578 if (obj && !PythonQtSlotFunction_Check(obj)) {
6079 if (obj) {
5579 static const char* argumentList[] ={"" , "QKeyEvent*"};
6080 static const char* argumentList[] ={"" , "QKeyEvent*"};
5580 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6081 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5581 void* args[2] = {NULL, (void*)&arg__1};
6082 void* args[2] = {NULL, (void*)&arg__1};
5582 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6083 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5583 if (result) { Py_DECREF(result); }
6084 if (result) { Py_DECREF(result); }
5584 Py_DECREF(obj);
6085 Py_DECREF(obj);
5585 return;
6086 return;
6087 } else {
6088 PyErr_Clear();
5586 }
6089 }
5587 }
6090 }
5588 abstractBinFileWidget::keyReleaseEvent(arg__1);
6091 abstractBinFileWidget::keyReleaseEvent(arg__1);
5589 }
6092 }
5590 void PythonQtShell_abstractBinFileWidget::leaveEvent(QEvent* arg__1)
6093 void PythonQtShell_abstractBinFileWidget::leaveEvent(QEvent* arg__1)
5591 {
6094 {
5592 if (_wrapper) {
6095 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5593 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
6096 static PyObject* name = PyString_FromString("leaveEvent");
5594 PyErr_Clear();
6097 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5595 if (obj && !PythonQtSlotFunction_Check(obj)) {
6098 if (obj) {
5596 static const char* argumentList[] ={"" , "QEvent*"};
6099 static const char* argumentList[] ={"" , "QEvent*"};
5597 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6100 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5598 void* args[2] = {NULL, (void*)&arg__1};
6101 void* args[2] = {NULL, (void*)&arg__1};
5599 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6102 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5600 if (result) { Py_DECREF(result); }
6103 if (result) { Py_DECREF(result); }
5601 Py_DECREF(obj);
6104 Py_DECREF(obj);
5602 return;
6105 return;
6106 } else {
6107 PyErr_Clear();
5603 }
6108 }
5604 }
6109 }
5605 abstractBinFileWidget::leaveEvent(arg__1);
6110 abstractBinFileWidget::leaveEvent(arg__1);
5606 }
6111 }
5607 int PythonQtShell_abstractBinFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
6112 int PythonQtShell_abstractBinFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
5608 {
6113 {
5609 if (_wrapper) {
6114 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5610 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
6115 static PyObject* name = PyString_FromString("metric");
5611 PyErr_Clear();
6116 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5612 if (obj && !PythonQtSlotFunction_Check(obj)) {
6117 if (obj) {
5613 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
6118 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
5614 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6119 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5615 int returnValue;
6120 int returnValue;
5616 void* args[2] = {NULL, (void*)&arg__1};
6121 void* args[2] = {NULL, (void*)&arg__1};
5617 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6122 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5618 if (result) {
6123 if (result) {
5619 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6124 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5620 if (args[0]!=&returnValue) {
6125 if (args[0]!=&returnValue) {
5621 if (args[0]==NULL) {
6126 if (args[0]==NULL) {
5622 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
6127 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
5623 } else {
6128 } else {
5624 returnValue = *((int*)args[0]);
6129 returnValue = *((int*)args[0]);
5625 }
6130 }
5626 }
6131 }
5627 }
6132 }
5628 if (result) { Py_DECREF(result); }
6133 if (result) { Py_DECREF(result); }
5629 Py_DECREF(obj);
6134 Py_DECREF(obj);
5630 return returnValue;
6135 return returnValue;
6136 } else {
6137 PyErr_Clear();
5631 }
6138 }
5632 }
6139 }
5633 return abstractBinFileWidget::metric(arg__1);
6140 return abstractBinFileWidget::metric(arg__1);
5634 }
6141 }
5635 QSize PythonQtShell_abstractBinFileWidget::minimumSizeHint() const
6142 QSize PythonQtShell_abstractBinFileWidget::minimumSizeHint() const
5636 {
6143 {
5637 if (_wrapper) {
6144 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5638 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
6145 static PyObject* name = PyString_FromString("getMinimumSizeHint");
5639 PyErr_Clear();
6146 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5640 if (obj && !PythonQtSlotFunction_Check(obj)) {
6147 if (obj) {
5641 static const char* argumentList[] ={"QSize"};
6148 static const char* argumentList[] ={"QSize"};
5642 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6149 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5643 QSize returnValue;
6150 QSize returnValue;
5644 void* args[1] = {NULL};
6151 void* args[1] = {NULL};
5645 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6152 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5646 if (result) {
6153 if (result) {
5647 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6154 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5648 if (args[0]!=&returnValue) {
6155 if (args[0]!=&returnValue) {
5649 if (args[0]==NULL) {
6156 if (args[0]==NULL) {
5650 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
6157 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
5651 } else {
6158 } else {
5652 returnValue = *((QSize*)args[0]);
6159 returnValue = *((QSize*)args[0]);
5653 }
6160 }
5654 }
6161 }
5655 }
6162 }
5656 if (result) { Py_DECREF(result); }
6163 if (result) { Py_DECREF(result); }
5657 Py_DECREF(obj);
6164 Py_DECREF(obj);
5658 return returnValue;
6165 return returnValue;
6166 } else {
6167 PyErr_Clear();
5659 }
6168 }
5660 }
6169 }
5661 return abstractBinFileWidget::minimumSizeHint();
6170 return abstractBinFileWidget::minimumSizeHint();
5662 }
6171 }
5663 void PythonQtShell_abstractBinFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
6172 void PythonQtShell_abstractBinFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
5664 {
6173 {
5665 if (_wrapper) {
6174 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5666 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
6175 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
5667 PyErr_Clear();
6176 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5668 if (obj && !PythonQtSlotFunction_Check(obj)) {
6177 if (obj) {
5669 static const char* argumentList[] ={"" , "QMouseEvent*"};
6178 static const char* argumentList[] ={"" , "QMouseEvent*"};
5670 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6179 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5671 void* args[2] = {NULL, (void*)&arg__1};
6180 void* args[2] = {NULL, (void*)&arg__1};
5672 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6181 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5673 if (result) { Py_DECREF(result); }
6182 if (result) { Py_DECREF(result); }
5674 Py_DECREF(obj);
6183 Py_DECREF(obj);
5675 return;
6184 return;
6185 } else {
6186 PyErr_Clear();
5676 }
6187 }
5677 }
6188 }
5678 abstractBinFileWidget::mouseDoubleClickEvent(arg__1);
6189 abstractBinFileWidget::mouseDoubleClickEvent(arg__1);
5679 }
6190 }
5680 void PythonQtShell_abstractBinFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
6191 void PythonQtShell_abstractBinFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
5681 {
6192 {
5682 if (_wrapper) {
6193 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5683 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
6194 static PyObject* name = PyString_FromString("mouseMoveEvent");
5684 PyErr_Clear();
6195 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5685 if (obj && !PythonQtSlotFunction_Check(obj)) {
6196 if (obj) {
5686 static const char* argumentList[] ={"" , "QMouseEvent*"};
6197 static const char* argumentList[] ={"" , "QMouseEvent*"};
5687 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6198 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5688 void* args[2] = {NULL, (void*)&arg__1};
6199 void* args[2] = {NULL, (void*)&arg__1};
5689 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6200 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5690 if (result) { Py_DECREF(result); }
6201 if (result) { Py_DECREF(result); }
5691 Py_DECREF(obj);
6202 Py_DECREF(obj);
5692 return;
6203 return;
6204 } else {
6205 PyErr_Clear();
5693 }
6206 }
5694 }
6207 }
5695 abstractBinFileWidget::mouseMoveEvent(arg__1);
6208 abstractBinFileWidget::mouseMoveEvent(arg__1);
5696 }
6209 }
5697 void PythonQtShell_abstractBinFileWidget::mousePressEvent(QMouseEvent* arg__1)
6210 void PythonQtShell_abstractBinFileWidget::mousePressEvent(QMouseEvent* arg__1)
5698 {
6211 {
5699 if (_wrapper) {
6212 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5700 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
6213 static PyObject* name = PyString_FromString("mousePressEvent");
5701 PyErr_Clear();
6214 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5702 if (obj && !PythonQtSlotFunction_Check(obj)) {
6215 if (obj) {
5703 static const char* argumentList[] ={"" , "QMouseEvent*"};
6216 static const char* argumentList[] ={"" , "QMouseEvent*"};
5704 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6217 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5705 void* args[2] = {NULL, (void*)&arg__1};
6218 void* args[2] = {NULL, (void*)&arg__1};
5706 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6219 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5707 if (result) { Py_DECREF(result); }
6220 if (result) { Py_DECREF(result); }
5708 Py_DECREF(obj);
6221 Py_DECREF(obj);
5709 return;
6222 return;
6223 } else {
6224 PyErr_Clear();
5710 }
6225 }
5711 }
6226 }
5712 abstractBinFileWidget::mousePressEvent(arg__1);
6227 abstractBinFileWidget::mousePressEvent(arg__1);
5713 }
6228 }
5714 void PythonQtShell_abstractBinFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
6229 void PythonQtShell_abstractBinFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
5715 {
6230 {
5716 if (_wrapper) {
6231 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5717 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
6232 static PyObject* name = PyString_FromString("mouseReleaseEvent");
5718 PyErr_Clear();
6233 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5719 if (obj && !PythonQtSlotFunction_Check(obj)) {
6234 if (obj) {
5720 static const char* argumentList[] ={"" , "QMouseEvent*"};
6235 static const char* argumentList[] ={"" , "QMouseEvent*"};
5721 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6236 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5722 void* args[2] = {NULL, (void*)&arg__1};
6237 void* args[2] = {NULL, (void*)&arg__1};
5723 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6238 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5724 if (result) { Py_DECREF(result); }
6239 if (result) { Py_DECREF(result); }
5725 Py_DECREF(obj);
6240 Py_DECREF(obj);
5726 return;
6241 return;
6242 } else {
6243 PyErr_Clear();
5727 }
6244 }
5728 }
6245 }
5729 abstractBinFileWidget::mouseReleaseEvent(arg__1);
6246 abstractBinFileWidget::mouseReleaseEvent(arg__1);
5730 }
6247 }
5731 void PythonQtShell_abstractBinFileWidget::moveEvent(QMoveEvent* arg__1)
6248 void PythonQtShell_abstractBinFileWidget::moveEvent(QMoveEvent* arg__1)
5732 {
6249 {
5733 if (_wrapper) {
6250 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5734 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
6251 static PyObject* name = PyString_FromString("moveEvent");
5735 PyErr_Clear();
6252 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5736 if (obj && !PythonQtSlotFunction_Check(obj)) {
6253 if (obj) {
5737 static const char* argumentList[] ={"" , "QMoveEvent*"};
6254 static const char* argumentList[] ={"" , "QMoveEvent*"};
5738 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6255 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5739 void* args[2] = {NULL, (void*)&arg__1};
6256 void* args[2] = {NULL, (void*)&arg__1};
5740 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6257 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5741 if (result) { Py_DECREF(result); }
6258 if (result) { Py_DECREF(result); }
5742 Py_DECREF(obj);
6259 Py_DECREF(obj);
5743 return;
6260 return;
6261 } else {
6262 PyErr_Clear();
5744 }
6263 }
5745 }
6264 }
5746 abstractBinFileWidget::moveEvent(arg__1);
6265 abstractBinFileWidget::moveEvent(arg__1);
5747 }
6266 }
5748 bool PythonQtShell_abstractBinFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result)
6267 bool PythonQtShell_abstractBinFileWidget::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
5749 {
6268 {
5750 if (_wrapper) {
6269 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5751 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
6270 static PyObject* name = PyString_FromString("nativeEvent");
5752 PyErr_Clear();
6271 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5753 if (obj && !PythonQtSlotFunction_Check(obj)) {
6272 if (obj) {
5754 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
6273 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
5755 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
6274 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
5756 bool returnValue;
6275 bool returnValue;
5757 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
6276 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
5758 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6277 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5759 if (result) {
6278 if (result) {
5760 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6279 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5761 if (args[0]!=&returnValue) {
6280 if (args[0]!=&returnValue) {
5762 if (args[0]==NULL) {
6281 if (args[0]==NULL) {
5763 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
6282 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
5764 } else {
6283 } else {
5765 returnValue = *((bool*)args[0]);
6284 returnValue = *((bool*)args[0]);
5766 }
6285 }
5767 }
6286 }
5768 }
6287 }
5769 if (result) { Py_DECREF(result); }
6288 if (result) { Py_DECREF(result); }
5770 Py_DECREF(obj);
6289 Py_DECREF(obj);
5771 return returnValue;
6290 return returnValue;
5772 }
6291 } else {
5773 }
6292 PyErr_Clear();
5774 return abstractBinFileWidget::nativeEvent(eventType, message, result);
6293 }
6294 }
6295 return abstractBinFileWidget::nativeEvent(eventType0, message1, result2);
5775 }
6296 }
5776 QPaintEngine* PythonQtShell_abstractBinFileWidget::paintEngine() const
6297 QPaintEngine* PythonQtShell_abstractBinFileWidget::paintEngine() const
5777 {
6298 {
5778 if (_wrapper) {
6299 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5779 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
6300 static PyObject* name = PyString_FromString("paintEngine");
5780 PyErr_Clear();
6301 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5781 if (obj && !PythonQtSlotFunction_Check(obj)) {
6302 if (obj) {
5782 static const char* argumentList[] ={"QPaintEngine*"};
6303 static const char* argumentList[] ={"QPaintEngine*"};
5783 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6304 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5784 QPaintEngine* returnValue;
6305 QPaintEngine* returnValue;
5785 void* args[1] = {NULL};
6306 void* args[1] = {NULL};
5786 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6307 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5787 if (result) {
6308 if (result) {
5788 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6309 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5789 if (args[0]!=&returnValue) {
6310 if (args[0]!=&returnValue) {
5790 if (args[0]==NULL) {
6311 if (args[0]==NULL) {
5791 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
6312 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
5792 } else {
6313 } else {
5793 returnValue = *((QPaintEngine**)args[0]);
6314 returnValue = *((QPaintEngine**)args[0]);
5794 }
6315 }
5795 }
6316 }
5796 }
6317 }
5797 if (result) { Py_DECREF(result); }
6318 if (result) { Py_DECREF(result); }
5798 Py_DECREF(obj);
6319 Py_DECREF(obj);
5799 return returnValue;
6320 return returnValue;
6321 } else {
6322 PyErr_Clear();
5800 }
6323 }
5801 }
6324 }
5802 return abstractBinFileWidget::paintEngine();
6325 return abstractBinFileWidget::paintEngine();
5803 }
6326 }
5804 void PythonQtShell_abstractBinFileWidget::paintEvent(QPaintEvent* arg__1)
6327 void PythonQtShell_abstractBinFileWidget::paintEvent(QPaintEvent* arg__1)
5805 {
6328 {
5806 if (_wrapper) {
6329 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5807 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
6330 static PyObject* name = PyString_FromString("paintEvent");
5808 PyErr_Clear();
6331 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5809 if (obj && !PythonQtSlotFunction_Check(obj)) {
6332 if (obj) {
5810 static const char* argumentList[] ={"" , "QPaintEvent*"};
6333 static const char* argumentList[] ={"" , "QPaintEvent*"};
5811 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6334 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5812 void* args[2] = {NULL, (void*)&arg__1};
6335 void* args[2] = {NULL, (void*)&arg__1};
5813 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6336 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5814 if (result) { Py_DECREF(result); }
6337 if (result) { Py_DECREF(result); }
5815 Py_DECREF(obj);
6338 Py_DECREF(obj);
5816 return;
6339 return;
6340 } else {
6341 PyErr_Clear();
5817 }
6342 }
5818 }
6343 }
5819 abstractBinFileWidget::paintEvent(arg__1);
6344 abstractBinFileWidget::paintEvent(arg__1);
5820 }
6345 }
5821 QPaintDevice* PythonQtShell_abstractBinFileWidget::redirected(QPoint* offset) const
6346 QPaintDevice* PythonQtShell_abstractBinFileWidget::redirected(QPoint* offset0) const
5822 {
6347 {
5823 if (_wrapper) {
6348 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5824 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
6349 static PyObject* name = PyString_FromString("redirected");
5825 PyErr_Clear();
6350 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5826 if (obj && !PythonQtSlotFunction_Check(obj)) {
6351 if (obj) {
5827 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
6352 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
5828 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6353 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5829 QPaintDevice* returnValue;
6354 QPaintDevice* returnValue;
5830 void* args[2] = {NULL, (void*)&offset};
6355 void* args[2] = {NULL, (void*)&offset0};
5831 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6356 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5832 if (result) {
6357 if (result) {
5833 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6358 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5834 if (args[0]!=&returnValue) {
6359 if (args[0]!=&returnValue) {
5835 if (args[0]==NULL) {
6360 if (args[0]==NULL) {
5836 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
6361 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
5837 } else {
6362 } else {
5838 returnValue = *((QPaintDevice**)args[0]);
6363 returnValue = *((QPaintDevice**)args[0]);
5839 }
6364 }
5840 }
6365 }
5841 }
6366 }
5842 if (result) { Py_DECREF(result); }
6367 if (result) { Py_DECREF(result); }
5843 Py_DECREF(obj);
6368 Py_DECREF(obj);
5844 return returnValue;
6369 return returnValue;
5845 }
6370 } else {
5846 }
6371 PyErr_Clear();
5847 return abstractBinFileWidget::redirected(offset);
6372 }
6373 }
6374 return abstractBinFileWidget::redirected(offset0);
5848 }
6375 }
5849 void PythonQtShell_abstractBinFileWidget::reloadFile()
6376 void PythonQtShell_abstractBinFileWidget::reloadFile()
5850 {
6377 {
5851 if (_wrapper) {
6378 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5852 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
6379 static PyObject* name = PyString_FromString("reloadFile");
5853 PyErr_Clear();
6380 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5854 if (obj && !PythonQtSlotFunction_Check(obj)) {
6381 if (obj) {
5855 static const char* argumentList[] ={""};
6382 static const char* argumentList[] ={""};
5856 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6383 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5857 void* args[1] = {NULL};
6384 void* args[1] = {NULL};
5858 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6385 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5859 if (result) { Py_DECREF(result); }
6386 if (result) { Py_DECREF(result); }
5860 Py_DECREF(obj);
6387 Py_DECREF(obj);
5861 return;
6388 return;
6389 } else {
6390 PyErr_Clear();
5862 }
6391 }
5863 }
6392 }
5864
6393
5865 }
6394 }
5866 void PythonQtShell_abstractBinFileWidget::resizeEvent(QResizeEvent* arg__1)
6395 void PythonQtShell_abstractBinFileWidget::resizeEvent(QResizeEvent* arg__1)
5867 {
6396 {
5868 if (_wrapper) {
6397 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5869 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
6398 static PyObject* name = PyString_FromString("resizeEvent");
5870 PyErr_Clear();
6399 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5871 if (obj && !PythonQtSlotFunction_Check(obj)) {
6400 if (obj) {
5872 static const char* argumentList[] ={"" , "QResizeEvent*"};
6401 static const char* argumentList[] ={"" , "QResizeEvent*"};
5873 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6402 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5874 void* args[2] = {NULL, (void*)&arg__1};
6403 void* args[2] = {NULL, (void*)&arg__1};
5875 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6404 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5876 if (result) { Py_DECREF(result); }
6405 if (result) { Py_DECREF(result); }
5877 Py_DECREF(obj);
6406 Py_DECREF(obj);
5878 return;
6407 return;
6408 } else {
6409 PyErr_Clear();
5879 }
6410 }
5880 }
6411 }
5881 abstractBinFileWidget::resizeEvent(arg__1);
6412 abstractBinFileWidget::resizeEvent(arg__1);
5882 }
6413 }
5883 void PythonQtShell_abstractBinFileWidget::setFile(abstractBinFile* file)
6414 void PythonQtShell_abstractBinFileWidget::setFile(abstractBinFile* file0)
5884 {
6415 {
5885 if (_wrapper) {
6416 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5886 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
6417 static PyObject* name = PyString_FromString("setFile");
5887 PyErr_Clear();
6418 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5888 if (obj && !PythonQtSlotFunction_Check(obj)) {
6419 if (obj) {
5889 static const char* argumentList[] ={"" , "abstractBinFile*"};
6420 static const char* argumentList[] ={"" , "abstractBinFile*"};
5890 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6421 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5891 void* args[2] = {NULL, (void*)&file};
6422 void* args[2] = {NULL, (void*)&file0};
5892 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6423 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5893 if (result) { Py_DECREF(result); }
6424 if (result) { Py_DECREF(result); }
5894 Py_DECREF(obj);
6425 Py_DECREF(obj);
5895 return;
6426 return;
6427 } else {
6428 PyErr_Clear();
5896 }
6429 }
5897 }
6430 }
5898
6431
5899 }
6432 }
5900 QPainter* PythonQtShell_abstractBinFileWidget::sharedPainter() const
6433 QPainter* PythonQtShell_abstractBinFileWidget::sharedPainter() const
5901 {
6434 {
5902 if (_wrapper) {
6435 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5903 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
6436 static PyObject* name = PyString_FromString("sharedPainter");
5904 PyErr_Clear();
6437 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5905 if (obj && !PythonQtSlotFunction_Check(obj)) {
6438 if (obj) {
5906 static const char* argumentList[] ={"QPainter*"};
6439 static const char* argumentList[] ={"QPainter*"};
5907 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6440 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5908 QPainter* returnValue;
6441 QPainter* returnValue;
5909 void* args[1] = {NULL};
6442 void* args[1] = {NULL};
5910 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6443 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5911 if (result) {
6444 if (result) {
5912 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6445 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5913 if (args[0]!=&returnValue) {
6446 if (args[0]!=&returnValue) {
5914 if (args[0]==NULL) {
6447 if (args[0]==NULL) {
5915 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
6448 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
5916 } else {
6449 } else {
5917 returnValue = *((QPainter**)args[0]);
6450 returnValue = *((QPainter**)args[0]);
5918 }
6451 }
5919 }
6452 }
5920 }
6453 }
5921 if (result) { Py_DECREF(result); }
6454 if (result) { Py_DECREF(result); }
5922 Py_DECREF(obj);
6455 Py_DECREF(obj);
5923 return returnValue;
6456 return returnValue;
6457 } else {
6458 PyErr_Clear();
5924 }
6459 }
5925 }
6460 }
5926 return abstractBinFileWidget::sharedPainter();
6461 return abstractBinFileWidget::sharedPainter();
5927 }
6462 }
5928 void PythonQtShell_abstractBinFileWidget::showEvent(QShowEvent* arg__1)
6463 void PythonQtShell_abstractBinFileWidget::showEvent(QShowEvent* arg__1)
5929 {
6464 {
5930 if (_wrapper) {
6465 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5931 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
6466 static PyObject* name = PyString_FromString("showEvent");
5932 PyErr_Clear();
6467 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5933 if (obj && !PythonQtSlotFunction_Check(obj)) {
6468 if (obj) {
5934 static const char* argumentList[] ={"" , "QShowEvent*"};
6469 static const char* argumentList[] ={"" , "QShowEvent*"};
5935 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6470 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5936 void* args[2] = {NULL, (void*)&arg__1};
6471 void* args[2] = {NULL, (void*)&arg__1};
5937 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6472 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5938 if (result) { Py_DECREF(result); }
6473 if (result) { Py_DECREF(result); }
5939 Py_DECREF(obj);
6474 Py_DECREF(obj);
5940 return;
6475 return;
6476 } else {
6477 PyErr_Clear();
5941 }
6478 }
5942 }
6479 }
5943 abstractBinFileWidget::showEvent(arg__1);
6480 abstractBinFileWidget::showEvent(arg__1);
5944 }
6481 }
5945 QSize PythonQtShell_abstractBinFileWidget::sizeHint() const
6482 QSize PythonQtShell_abstractBinFileWidget::sizeHint() const
5946 {
6483 {
5947 if (_wrapper) {
6484 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5948 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
6485 static PyObject* name = PyString_FromString("getSizeHint");
5949 PyErr_Clear();
6486 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5950 if (obj && !PythonQtSlotFunction_Check(obj)) {
6487 if (obj) {
5951 static const char* argumentList[] ={"QSize"};
6488 static const char* argumentList[] ={"QSize"};
5952 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6489 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5953 QSize returnValue;
6490 QSize returnValue;
5954 void* args[1] = {NULL};
6491 void* args[1] = {NULL};
5955 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6492 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5956 if (result) {
6493 if (result) {
5957 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6494 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5958 if (args[0]!=&returnValue) {
6495 if (args[0]!=&returnValue) {
5959 if (args[0]==NULL) {
6496 if (args[0]==NULL) {
5960 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
6497 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
5961 } else {
6498 } else {
5962 returnValue = *((QSize*)args[0]);
6499 returnValue = *((QSize*)args[0]);
5963 }
6500 }
5964 }
6501 }
5965 }
6502 }
5966 if (result) { Py_DECREF(result); }
6503 if (result) { Py_DECREF(result); }
5967 Py_DECREF(obj);
6504 Py_DECREF(obj);
5968 return returnValue;
6505 return returnValue;
6506 } else {
6507 PyErr_Clear();
5969 }
6508 }
5970 }
6509 }
5971 return abstractBinFileWidget::sizeHint();
6510 return abstractBinFileWidget::sizeHint();
5972 }
6511 }
5973 void PythonQtShell_abstractBinFileWidget::tabletEvent(QTabletEvent* arg__1)
6512 void PythonQtShell_abstractBinFileWidget::tabletEvent(QTabletEvent* arg__1)
5974 {
6513 {
5975 if (_wrapper) {
6514 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5976 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
6515 static PyObject* name = PyString_FromString("tabletEvent");
5977 PyErr_Clear();
6516 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5978 if (obj && !PythonQtSlotFunction_Check(obj)) {
6517 if (obj) {
5979 static const char* argumentList[] ={"" , "QTabletEvent*"};
6518 static const char* argumentList[] ={"" , "QTabletEvent*"};
5980 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6519 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5981 void* args[2] = {NULL, (void*)&arg__1};
6520 void* args[2] = {NULL, (void*)&arg__1};
5982 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6521 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5983 if (result) { Py_DECREF(result); }
6522 if (result) { Py_DECREF(result); }
5984 Py_DECREF(obj);
6523 Py_DECREF(obj);
5985 return;
6524 return;
6525 } else {
6526 PyErr_Clear();
5986 }
6527 }
5987 }
6528 }
5988 abstractBinFileWidget::tabletEvent(arg__1);
6529 abstractBinFileWidget::tabletEvent(arg__1);
5989 }
6530 }
5990 void PythonQtShell_abstractBinFileWidget::timerEvent(QTimerEvent* arg__1)
6531 void PythonQtShell_abstractBinFileWidget::timerEvent(QTimerEvent* arg__1)
5991 {
6532 {
5992 if (_wrapper) {
6533 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5993 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
6534 static PyObject* name = PyString_FromString("timerEvent");
5994 PyErr_Clear();
6535 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5995 if (obj && !PythonQtSlotFunction_Check(obj)) {
6536 if (obj) {
5996 static const char* argumentList[] ={"" , "QTimerEvent*"};
6537 static const char* argumentList[] ={"" , "QTimerEvent*"};
5997 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6538 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5998 void* args[2] = {NULL, (void*)&arg__1};
6539 void* args[2] = {NULL, (void*)&arg__1};
5999 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6540 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6000 if (result) { Py_DECREF(result); }
6541 if (result) { Py_DECREF(result); }
6001 Py_DECREF(obj);
6542 Py_DECREF(obj);
6002 return;
6543 return;
6544 } else {
6545 PyErr_Clear();
6003 }
6546 }
6004 }
6547 }
6005 abstractBinFileWidget::timerEvent(arg__1);
6548 abstractBinFileWidget::timerEvent(arg__1);
6006 }
6549 }
6007 void PythonQtShell_abstractBinFileWidget::wheelEvent(QWheelEvent* arg__1)
6550 void PythonQtShell_abstractBinFileWidget::wheelEvent(QWheelEvent* arg__1)
6008 {
6551 {
6009 if (_wrapper) {
6552 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6010 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
6553 static PyObject* name = PyString_FromString("wheelEvent");
6011 PyErr_Clear();
6554 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6012 if (obj && !PythonQtSlotFunction_Check(obj)) {
6555 if (obj) {
6013 static const char* argumentList[] ={"" , "QWheelEvent*"};
6556 static const char* argumentList[] ={"" , "QWheelEvent*"};
6014 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6557 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6015 void* args[2] = {NULL, (void*)&arg__1};
6558 void* args[2] = {NULL, (void*)&arg__1};
6016 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6559 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6017 if (result) { Py_DECREF(result); }
6560 if (result) { Py_DECREF(result); }
6018 Py_DECREF(obj);
6561 Py_DECREF(obj);
6019 return;
6562 return;
6563 } else {
6564 PyErr_Clear();
6020 }
6565 }
6021 }
6566 }
6022 abstractBinFileWidget::wheelEvent(arg__1);
6567 abstractBinFileWidget::wheelEvent(arg__1);
6023 }
6568 }
6024 abstractBinFileWidget* PythonQtWrapper_abstractBinFileWidget::new_abstractBinFileWidget(QWidget* parent)
6569 abstractBinFileWidget* PythonQtWrapper_abstractBinFileWidget::new_abstractBinFileWidget(QWidget* parent)
6025 {
6570 {
6026 return new PythonQtShell_abstractBinFileWidget(parent); }
6571 return new PythonQtShell_abstractBinFileWidget(parent); }
6027
6572
6573 void PythonQtWrapper_abstractBinFileWidget::reloadFile(abstractBinFileWidget* theWrappedObject)
6574 {
6575 ( ((PythonQtPublicPromoter_abstractBinFileWidget*)theWrappedObject)->promoted_reloadFile());
6576 }
6577
6578 void PythonQtWrapper_abstractBinFileWidget::setFile(abstractBinFileWidget* theWrappedObject, abstractBinFile* file)
6579 {
6580 ( ((PythonQtPublicPromoter_abstractBinFileWidget*)theWrappedObject)->promoted_setFile(file));
6581 }
6582
6028
6583
6029
6584
6030 PythonQtShell_binaryFile::~PythonQtShell_binaryFile() {
6585 PythonQtShell_binaryFile::~PythonQtShell_binaryFile() {
6031 PythonQtPrivate* priv = PythonQt::priv();
6586 PythonQtPrivate* priv = PythonQt::priv();
6032 if (priv) { priv->shellClassDeleted(this); }
6587 if (priv) { priv->shellClassDeleted(this); }
6033 }
6588 }
6034 int PythonQtShell_binaryFile::closeFile()
6589 int PythonQtShell_binaryFile::closeFile()
6035 {
6590 {
6036 if (_wrapper) {
6591 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6037 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
6592 static PyObject* name = PyString_FromString("closeFile");
6038 PyErr_Clear();
6593 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6039 if (obj && !PythonQtSlotFunction_Check(obj)) {
6594 if (obj) {
6040 static const char* argumentList[] ={"int"};
6595 static const char* argumentList[] ={"int"};
6041 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6596 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6042 int returnValue;
6597 int returnValue;
6043 void* args[1] = {NULL};
6598 void* args[1] = {NULL};
6044 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6599 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6045 if (result) {
6600 if (result) {
6046 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6601 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6047 if (args[0]!=&returnValue) {
6602 if (args[0]!=&returnValue) {
6048 if (args[0]==NULL) {
6603 if (args[0]==NULL) {
6049 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
6604 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
6050 } else {
6605 } else {
6051 returnValue = *((int*)args[0]);
6606 returnValue = *((int*)args[0]);
6052 }
6607 }
6053 }
6608 }
6054 }
6609 }
6055 if (result) { Py_DECREF(result); }
6610 if (result) { Py_DECREF(result); }
6056 Py_DECREF(obj);
6611 Py_DECREF(obj);
6057 return returnValue;
6612 return returnValue;
6613 } else {
6614 PyErr_Clear();
6058 }
6615 }
6059 }
6616 }
6060 return binaryFile::closeFile();
6617 return binaryFile::closeFile();
6061 }
6618 }
6062 QList<codeFragment* > PythonQtShell_binaryFile::getFragments()
6619 QList<codeFragment* > PythonQtShell_binaryFile::getFragments()
6063 {
6620 {
6064 if (_wrapper) {
6621 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6065 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
6622 static PyObject* name = PyString_FromString("getFragments");
6066 PyErr_Clear();
6623 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6067 if (obj && !PythonQtSlotFunction_Check(obj)) {
6624 if (obj) {
6068 static const char* argumentList[] ={"QList<codeFragment* >"};
6625 static const char* argumentList[] ={"QList<codeFragment* >"};
6069 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6626 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6070 QList<codeFragment* > returnValue;
6627 QList<codeFragment* > returnValue;
6071 void* args[1] = {NULL};
6628 void* args[1] = {NULL};
6072 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6629 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6073 if (result) {
6630 if (result) {
6074 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6631 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6075 if (args[0]!=&returnValue) {
6632 if (args[0]!=&returnValue) {
6076 if (args[0]==NULL) {
6633 if (args[0]==NULL) {
6077 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
6634 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
6078 } else {
6635 } else {
6079 returnValue = *((QList<codeFragment* >*)args[0]);
6636 returnValue = *((QList<codeFragment* >*)args[0]);
6080 }
6637 }
6081 }
6638 }
6082 }
6639 }
6083 if (result) { Py_DECREF(result); }
6640 if (result) { Py_DECREF(result); }
6084 Py_DECREF(obj);
6641 Py_DECREF(obj);
6085 return returnValue;
6642 return returnValue;
6643 } else {
6644 PyErr_Clear();
6086 }
6645 }
6087 }
6646 }
6088 return binaryFile::getFragments();
6647 return binaryFile::getFragments();
6089 }
6648 }
6090 bool PythonQtShell_binaryFile::isopened()
6649 bool PythonQtShell_binaryFile::isopened()
6091 {
6650 {
6092 if (_wrapper) {
6651 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6093 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
6652 static PyObject* name = PyString_FromString("isopened");
6094 PyErr_Clear();
6653 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6095 if (obj && !PythonQtSlotFunction_Check(obj)) {
6654 if (obj) {
6096 static const char* argumentList[] ={"bool"};
6655 static const char* argumentList[] ={"bool"};
6097 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6656 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6098 bool returnValue;
6657 bool returnValue;
6099 void* args[1] = {NULL};
6658 void* args[1] = {NULL};
6100 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6659 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6101 if (result) {
6660 if (result) {
6102 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6661 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6103 if (args[0]!=&returnValue) {
6662 if (args[0]!=&returnValue) {
6104 if (args[0]==NULL) {
6663 if (args[0]==NULL) {
6105 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
6664 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
6106 } else {
6665 } else {
6107 returnValue = *((bool*)args[0]);
6666 returnValue = *((bool*)args[0]);
6108 }
6667 }
6109 }
6668 }
6110 }
6669 }
6111 if (result) { Py_DECREF(result); }
6670 if (result) { Py_DECREF(result); }
6112 Py_DECREF(obj);
6671 Py_DECREF(obj);
6113 return returnValue;
6672 return returnValue;
6673 } else {
6674 PyErr_Clear();
6114 }
6675 }
6115 }
6676 }
6116 return binaryFile::isopened();
6677 return binaryFile::isopened();
6117 }
6678 }
6118 bool PythonQtShell_binaryFile::openFile(const QString& File)
6679 bool PythonQtShell_binaryFile::openFile(const QString& File0)
6119 {
6680 {
6120 if (_wrapper) {
6681 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6121 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
6682 static PyObject* name = PyString_FromString("openFile");
6122 PyErr_Clear();
6683 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6123 if (obj && !PythonQtSlotFunction_Check(obj)) {
6684 if (obj) {
6124 static const char* argumentList[] ={"bool" , "const QString&"};
6685 static const char* argumentList[] ={"bool" , "const QString&"};
6125 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6686 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6126 bool returnValue;
6687 bool returnValue;
6127 void* args[2] = {NULL, (void*)&File};
6688 void* args[2] = {NULL, (void*)&File0};
6128 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6689 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6129 if (result) {
6690 if (result) {
6130 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6691 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6131 if (args[0]!=&returnValue) {
6692 if (args[0]!=&returnValue) {
6132 if (args[0]==NULL) {
6693 if (args[0]==NULL) {
6133 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
6694 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
6134 } else {
6695 } else {
6135 returnValue = *((bool*)args[0]);
6696 returnValue = *((bool*)args[0]);
6136 }
6697 }
6137 }
6698 }
6138 }
6699 }
6139 if (result) { Py_DECREF(result); }
6700 if (result) { Py_DECREF(result); }
6140 Py_DECREF(obj);
6701 Py_DECREF(obj);
6141 return returnValue;
6702 return returnValue;
6142 }
6703 } else {
6143 }
6704 PyErr_Clear();
6144 return binaryFile::openFile(File);
6705 }
6145 }
6706 }
6146 bool PythonQtShell_binaryFile::toBinary(const QString& fileName)
6707 return binaryFile::openFile(File0);
6147 {
6708 }
6148 if (_wrapper) {
6709 bool PythonQtShell_binaryFile::toBinary(const QString& fileName0)
6149 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
6710 {
6150 PyErr_Clear();
6711 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6151 if (obj && !PythonQtSlotFunction_Check(obj)) {
6712 static PyObject* name = PyString_FromString("toBinary");
6713 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6714 if (obj) {
6152 static const char* argumentList[] ={"bool" , "const QString&"};
6715 static const char* argumentList[] ={"bool" , "const QString&"};
6153 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6716 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6154 bool returnValue;
6717 bool returnValue;
6155 void* args[2] = {NULL, (void*)&fileName};
6718 void* args[2] = {NULL, (void*)&fileName0};
6156 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6719 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6157 if (result) {
6720 if (result) {
6158 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6721 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6159 if (args[0]!=&returnValue) {
6722 if (args[0]!=&returnValue) {
6160 if (args[0]==NULL) {
6723 if (args[0]==NULL) {
6161 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
6724 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
6162 } else {
6725 } else {
6163 returnValue = *((bool*)args[0]);
6726 returnValue = *((bool*)args[0]);
6164 }
6727 }
6165 }
6728 }
6166 }
6729 }
6167 if (result) { Py_DECREF(result); }
6730 if (result) { Py_DECREF(result); }
6168 Py_DECREF(obj);
6731 Py_DECREF(obj);
6169 return returnValue;
6732 return returnValue;
6170 }
6733 } else {
6171 }
6734 PyErr_Clear();
6172 return binaryFile::toBinary(fileName);
6735 }
6173 }
6736 }
6174 bool PythonQtShell_binaryFile::toSrec(const QString& fileName)
6737 return binaryFile::toBinary(fileName0);
6175 {
6738 }
6176 if (_wrapper) {
6739 bool PythonQtShell_binaryFile::toSrec(const QString& fileName0)
6177 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
6740 {
6178 PyErr_Clear();
6741 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6179 if (obj && !PythonQtSlotFunction_Check(obj)) {
6742 static PyObject* name = PyString_FromString("toSrec");
6743 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6744 if (obj) {
6180 static const char* argumentList[] ={"bool" , "const QString&"};
6745 static const char* argumentList[] ={"bool" , "const QString&"};
6181 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6746 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6182 bool returnValue;
6747 bool returnValue;
6183 void* args[2] = {NULL, (void*)&fileName};
6748 void* args[2] = {NULL, (void*)&fileName0};
6184 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6749 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6185 if (result) {
6750 if (result) {
6186 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6751 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6187 if (args[0]!=&returnValue) {
6752 if (args[0]!=&returnValue) {
6188 if (args[0]==NULL) {
6753 if (args[0]==NULL) {
6189 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
6754 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
6190 } else {
6755 } else {
6191 returnValue = *((bool*)args[0]);
6756 returnValue = *((bool*)args[0]);
6192 }
6757 }
6193 }
6758 }
6194 }
6759 }
6195 if (result) { Py_DECREF(result); }
6760 if (result) { Py_DECREF(result); }
6196 Py_DECREF(obj);
6761 Py_DECREF(obj);
6197 return returnValue;
6762 return returnValue;
6198 }
6763 } else {
6199 }
6764 PyErr_Clear();
6200 return binaryFile::toSrec(fileName);
6765 }
6766 }
6767 return binaryFile::toSrec(fileName0);
6201 }
6768 }
6202 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile()
6769 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile()
6203 {
6770 {
6204 return new PythonQtShell_binaryFile(); }
6771 return new PythonQtShell_binaryFile(); }
6205
6772
6206 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile(const QString& File)
6773 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile(const QString& File)
6207 {
6774 {
6208 return new PythonQtShell_binaryFile(File); }
6775 return new PythonQtShell_binaryFile(File); }
6209
6776
6210 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile(const QStringList& Files)
6777 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile(const QStringList& Files)
6211 {
6778 {
6212 return new PythonQtShell_binaryFile(Files); }
6779 return new PythonQtShell_binaryFile(Files); }
6213
6780
6214 int PythonQtWrapper_binaryFile::closeFile(binaryFile* theWrappedObject)
6781 int PythonQtWrapper_binaryFile::closeFile(binaryFile* theWrappedObject)
6215 {
6782 {
6216 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_closeFile());
6783 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_closeFile());
6217 }
6784 }
6218
6785
6219 codeFragment* PythonQtWrapper_binaryFile::getFragment(binaryFile* theWrappedObject, int index)
6786 codeFragment* PythonQtWrapper_binaryFile::getFragment(binaryFile* theWrappedObject, int index)
6220 {
6787 {
6221 return ( theWrappedObject->getFragment(index));
6788 return ( theWrappedObject->getFragment(index));
6222 }
6789 }
6223
6790
6224 int PythonQtWrapper_binaryFile::getFragmentAddress(binaryFile* theWrappedObject, int index)
6791 int PythonQtWrapper_binaryFile::getFragmentAddress(binaryFile* theWrappedObject, int index)
6225 {
6792 {
6226 return ( theWrappedObject->getFragmentAddress(index));
6793 return ( theWrappedObject->getFragmentAddress(index));
6227 }
6794 }
6228
6795
6229 bool PythonQtWrapper_binaryFile::getFragmentData(binaryFile* theWrappedObject, int index, char** buffer)
6796 bool PythonQtWrapper_binaryFile::getFragmentData(binaryFile* theWrappedObject, int index, char** buffer)
6230 {
6797 {
6231 return ( theWrappedObject->getFragmentData(index, buffer));
6798 return ( theWrappedObject->getFragmentData(index, buffer));
6232 }
6799 }
6233
6800
6234 QString PythonQtWrapper_binaryFile::getFragmentHeader(binaryFile* theWrappedObject, int index)
6801 QString PythonQtWrapper_binaryFile::getFragmentHeader(binaryFile* theWrappedObject, int index)
6235 {
6802 {
6236 return ( theWrappedObject->getFragmentHeader(index));
6803 return ( theWrappedObject->getFragmentHeader(index));
6237 }
6804 }
6238
6805
6239 int PythonQtWrapper_binaryFile::getFragmentSize(binaryFile* theWrappedObject, int index)
6806 int PythonQtWrapper_binaryFile::getFragmentSize(binaryFile* theWrappedObject, int index)
6240 {
6807 {
6241 return ( theWrappedObject->getFragmentSize(index));
6808 return ( theWrappedObject->getFragmentSize(index));
6242 }
6809 }
6243
6810
6244 QList<codeFragment* > PythonQtWrapper_binaryFile::getFragments(binaryFile* theWrappedObject)
6811 QList<codeFragment* > PythonQtWrapper_binaryFile::getFragments(binaryFile* theWrappedObject)
6245 {
6812 {
6246 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_getFragments());
6813 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_getFragments());
6247 }
6814 }
6248
6815
6249 int PythonQtWrapper_binaryFile::getFragmentsCount(binaryFile* theWrappedObject)
6816 int PythonQtWrapper_binaryFile::getFragmentsCount(binaryFile* theWrappedObject)
6250 {
6817 {
6251 return ( theWrappedObject->getFragmentsCount());
6818 return ( theWrappedObject->getFragmentsCount());
6252 }
6819 }
6253
6820
6254 bool PythonQtWrapper_binaryFile::isopened(binaryFile* theWrappedObject)
6821 bool PythonQtWrapper_binaryFile::isopened(binaryFile* theWrappedObject)
6255 {
6822 {
6256 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_isopened());
6823 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_isopened());
6257 }
6824 }
6258
6825
6259 bool PythonQtWrapper_binaryFile::openFile(binaryFile* theWrappedObject, const QString& File)
6826 bool PythonQtWrapper_binaryFile::openFile(binaryFile* theWrappedObject, const QString& File)
6260 {
6827 {
6261 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_openFile(File));
6828 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_openFile(File));
6262 }
6829 }
6263
6830
6264 bool PythonQtWrapper_binaryFile::openFiles(binaryFile* theWrappedObject, const QStringList& Files)
6831 bool PythonQtWrapper_binaryFile::openFiles(binaryFile* theWrappedObject, const QStringList& Files)
6265 {
6832 {
6266 return ( theWrappedObject->openFiles(Files));
6833 return ( theWrappedObject->openFiles(Files));
6267 }
6834 }
6268
6835
6269 bool PythonQtWrapper_binaryFile::static_binaryFile_toBinary(QList<codeFragment* > fragments, const QString& File)
6836 bool PythonQtWrapper_binaryFile::static_binaryFile_toBinary(QList<codeFragment* > fragments, const QString& File)
6270 {
6837 {
6271 return (binaryFile::toBinary(fragments, File));
6838 return (binaryFile::toBinary(fragments, File));
6272 }
6839 }
6273
6840
6274 bool PythonQtWrapper_binaryFile::toBinary(binaryFile* theWrappedObject, const QString& fileName)
6841 bool PythonQtWrapper_binaryFile::toBinary(binaryFile* theWrappedObject, const QString& fileName)
6275 {
6842 {
6276 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_toBinary(fileName));
6843 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_toBinary(fileName));
6277 }
6844 }
6278
6845
6279 bool PythonQtWrapper_binaryFile::toSrec(binaryFile* theWrappedObject, const QString& fileName)
6846 bool PythonQtWrapper_binaryFile::toSrec(binaryFile* theWrappedObject, const QString& fileName)
6280 {
6847 {
6281 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_toSrec(fileName));
6848 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_toSrec(fileName));
6282 }
6849 }
6283
6850
6284
6851
6285
6852
6286 PythonQtShell_binaryFileWidget::~PythonQtShell_binaryFileWidget() {
6853 PythonQtShell_binaryFileWidget::~PythonQtShell_binaryFileWidget() {
6287 PythonQtPrivate* priv = PythonQt::priv();
6854 PythonQtPrivate* priv = PythonQt::priv();
6288 if (priv) { priv->shellClassDeleted(this); }
6855 if (priv) { priv->shellClassDeleted(this); }
6289 }
6856 }
6290 void PythonQtShell_binaryFileWidget::reloadFile()
6857 void PythonQtShell_binaryFileWidget::reloadFile()
6291 {
6858 {
6292 if (_wrapper) {
6859 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6293 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
6860 static PyObject* name = PyString_FromString("reloadFile");
6294 PyErr_Clear();
6861 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6295 if (obj && !PythonQtSlotFunction_Check(obj)) {
6862 if (obj) {
6296 static const char* argumentList[] ={""};
6863 static const char* argumentList[] ={""};
6297 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6864 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6298 void* args[1] = {NULL};
6865 void* args[1] = {NULL};
6299 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6866 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6300 if (result) { Py_DECREF(result); }
6867 if (result) { Py_DECREF(result); }
6301 Py_DECREF(obj);
6868 Py_DECREF(obj);
6302 return;
6869 return;
6870 } else {
6871 PyErr_Clear();
6303 }
6872 }
6304 }
6873 }
6305 binaryFileWidget::reloadFile();
6874 binaryFileWidget::reloadFile();
6306 }
6875 }
6307 void PythonQtShell_binaryFileWidget::setFile(abstractBinFile* file)
6876 void PythonQtShell_binaryFileWidget::setFile(abstractBinFile* file0)
6308 {
6877 {
6309 if (_wrapper) {
6878 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6310 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
6879 static PyObject* name = PyString_FromString("setFile");
6311 PyErr_Clear();
6880 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6312 if (obj && !PythonQtSlotFunction_Check(obj)) {
6881 if (obj) {
6313 static const char* argumentList[] ={"" , "abstractBinFile*"};
6882 static const char* argumentList[] ={"" , "abstractBinFile*"};
6314 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6883 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6315 void* args[2] = {NULL, (void*)&file};
6884 void* args[2] = {NULL, (void*)&file0};
6316 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6885 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6317 if (result) { Py_DECREF(result); }
6886 if (result) { Py_DECREF(result); }
6318 Py_DECREF(obj);
6887 Py_DECREF(obj);
6319 return;
6888 return;
6320 }
6889 } else {
6321 }
6890 PyErr_Clear();
6322 binaryFileWidget::setFile(file);
6891 }
6892 }
6893 binaryFileWidget::setFile(file0);
6323 }
6894 }
6324 binaryFileWidget* PythonQtWrapper_binaryFileWidget::new_binaryFileWidget(QWidget* parent)
6895 binaryFileWidget* PythonQtWrapper_binaryFileWidget::new_binaryFileWidget(QWidget* parent)
6325 {
6896 {
6326 return new PythonQtShell_binaryFileWidget(parent); }
6897 return new PythonQtShell_binaryFileWidget(parent); }
6327
6898
6328 void PythonQtWrapper_binaryFileWidget::reloadFile(binaryFileWidget* theWrappedObject)
6899 void PythonQtWrapper_binaryFileWidget::reloadFile(binaryFileWidget* theWrappedObject)
6329 {
6900 {
6330 ( ((PythonQtPublicPromoter_binaryFileWidget*)theWrappedObject)->promoted_reloadFile());
6901 ( ((PythonQtPublicPromoter_binaryFileWidget*)theWrappedObject)->promoted_reloadFile());
6331 }
6902 }
6332
6903
6333 void PythonQtWrapper_binaryFileWidget::setFile(binaryFileWidget* theWrappedObject, abstractBinFile* file)
6904 void PythonQtWrapper_binaryFileWidget::setFile(binaryFileWidget* theWrappedObject, abstractBinFile* file)
6334 {
6905 {
6335 ( ((PythonQtPublicPromoter_binaryFileWidget*)theWrappedObject)->promoted_setFile(file));
6906 ( ((PythonQtPublicPromoter_binaryFileWidget*)theWrappedObject)->promoted_setFile(file));
6336 }
6907 }
6337
6908
6338
6909
6339
6910
6340 PythonQtShell_codeFragment::~PythonQtShell_codeFragment() {
6911 PythonQtShell_codeFragment::~PythonQtShell_codeFragment() {
6341 PythonQtPrivate* priv = PythonQt::priv();
6912 PythonQtPrivate* priv = PythonQt::priv();
6342 if (priv) { priv->shellClassDeleted(this); }
6913 if (priv) { priv->shellClassDeleted(this); }
6343 }
6914 }
6344 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment()
6915 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment()
6345 {
6916 {
6346 return new PythonQtShell_codeFragment(); }
6917 return new PythonQtShell_codeFragment(); }
6347
6918
6348 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment(char* data, quint64 size, quint64 address)
6919 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment(char* data, quint64 size, quint64 address)
6349 {
6920 {
6350 return new PythonQtShell_codeFragment(data, size, address); }
6921 return new PythonQtShell_codeFragment(data, size, address); }
6351
6922
6352
6923
6353
6924
6354 PythonQtShell_elfFileWidget::~PythonQtShell_elfFileWidget() {
6925 PythonQtShell_elfFileWidget::~PythonQtShell_elfFileWidget() {
6355 PythonQtPrivate* priv = PythonQt::priv();
6926 PythonQtPrivate* priv = PythonQt::priv();
6356 if (priv) { priv->shellClassDeleted(this); }
6927 if (priv) { priv->shellClassDeleted(this); }
6357 }
6928 }
6358 void PythonQtShell_elfFileWidget::reloadFile()
6929 void PythonQtShell_elfFileWidget::reloadFile()
6359 {
6930 {
6360 if (_wrapper) {
6931 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6361 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
6932 static PyObject* name = PyString_FromString("reloadFile");
6362 PyErr_Clear();
6933 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6363 if (obj && !PythonQtSlotFunction_Check(obj)) {
6934 if (obj) {
6364 static const char* argumentList[] ={""};
6935 static const char* argumentList[] ={""};
6365 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6936 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6366 void* args[1] = {NULL};
6937 void* args[1] = {NULL};
6367 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6938 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6368 if (result) { Py_DECREF(result); }
6939 if (result) { Py_DECREF(result); }
6369 Py_DECREF(obj);
6940 Py_DECREF(obj);
6370 return;
6941 return;
6942 } else {
6943 PyErr_Clear();
6371 }
6944 }
6372 }
6945 }
6373 elfFileWidget::reloadFile();
6946 elfFileWidget::reloadFile();
6374 }
6947 }
6375 void PythonQtShell_elfFileWidget::setFile(abstractBinFile* file)
6948 void PythonQtShell_elfFileWidget::setFile(abstractBinFile* file0)
6376 {
6949 {
6377 if (_wrapper) {
6950 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6378 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
6951 static PyObject* name = PyString_FromString("setFile");
6379 PyErr_Clear();
6952 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6380 if (obj && !PythonQtSlotFunction_Check(obj)) {
6953 if (obj) {
6381 static const char* argumentList[] ={"" , "abstractBinFile*"};
6954 static const char* argumentList[] ={"" , "abstractBinFile*"};
6382 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6955 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6383 void* args[2] = {NULL, (void*)&file};
6956 void* args[2] = {NULL, (void*)&file0};
6384 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6957 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6385 if (result) { Py_DECREF(result); }
6958 if (result) { Py_DECREF(result); }
6386 Py_DECREF(obj);
6959 Py_DECREF(obj);
6387 return;
6960 return;
6388 }
6961 } else {
6389 }
6962 PyErr_Clear();
6390 elfFileWidget::setFile(file);
6963 }
6964 }
6965 elfFileWidget::setFile(file0);
6391 }
6966 }
6392 elfFileWidget* PythonQtWrapper_elfFileWidget::new_elfFileWidget(QWidget* parent)
6967 elfFileWidget* PythonQtWrapper_elfFileWidget::new_elfFileWidget(QWidget* parent)
6393 {
6968 {
6394 return new PythonQtShell_elfFileWidget(parent); }
6969 return new PythonQtShell_elfFileWidget(parent); }
6395
6970
6396 void PythonQtWrapper_elfFileWidget::reloadFile(elfFileWidget* theWrappedObject)
6971 void PythonQtWrapper_elfFileWidget::reloadFile(elfFileWidget* theWrappedObject)
6397 {
6972 {
6398 ( ((PythonQtPublicPromoter_elfFileWidget*)theWrappedObject)->promoted_reloadFile());
6973 ( ((PythonQtPublicPromoter_elfFileWidget*)theWrappedObject)->promoted_reloadFile());
6399 }
6974 }
6400
6975
6401 void PythonQtWrapper_elfFileWidget::setFile(elfFileWidget* theWrappedObject, abstractBinFile* file)
6976 void PythonQtWrapper_elfFileWidget::setFile(elfFileWidget* theWrappedObject, abstractBinFile* file)
6402 {
6977 {
6403 ( ((PythonQtPublicPromoter_elfFileWidget*)theWrappedObject)->promoted_setFile(file));
6978 ( ((PythonQtPublicPromoter_elfFileWidget*)theWrappedObject)->promoted_setFile(file));
6404 }
6979 }
6405
6980
6406
6981
6407
6982
6408 PythonQtShell_elfInfoWdgt::~PythonQtShell_elfInfoWdgt() {
6983 PythonQtShell_elfInfoWdgt::~PythonQtShell_elfInfoWdgt() {
6409 PythonQtPrivate* priv = PythonQt::priv();
6984 PythonQtPrivate* priv = PythonQt::priv();
6410 if (priv) { priv->shellClassDeleted(this); }
6985 if (priv) { priv->shellClassDeleted(this); }
6411 }
6986 }
6412 void PythonQtShell_elfInfoWdgt::actionEvent(QActionEvent* arg__1)
6987 void PythonQtShell_elfInfoWdgt::actionEvent(QActionEvent* arg__1)
6413 {
6988 {
6414 if (_wrapper) {
6989 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6415 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
6990 static PyObject* name = PyString_FromString("actionEvent");
6416 PyErr_Clear();
6991 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6417 if (obj && !PythonQtSlotFunction_Check(obj)) {
6992 if (obj) {
6418 static const char* argumentList[] ={"" , "QActionEvent*"};
6993 static const char* argumentList[] ={"" , "QActionEvent*"};
6419 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6994 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6420 void* args[2] = {NULL, (void*)&arg__1};
6995 void* args[2] = {NULL, (void*)&arg__1};
6421 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6996 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6422 if (result) { Py_DECREF(result); }
6997 if (result) { Py_DECREF(result); }
6423 Py_DECREF(obj);
6998 Py_DECREF(obj);
6424 return;
6999 return;
7000 } else {
7001 PyErr_Clear();
6425 }
7002 }
6426 }
7003 }
6427 elfInfoWdgt::actionEvent(arg__1);
7004 elfInfoWdgt::actionEvent(arg__1);
6428 }
7005 }
6429 void PythonQtShell_elfInfoWdgt::changeEvent(QEvent* arg__1)
7006 void PythonQtShell_elfInfoWdgt::changeEvent(QEvent* arg__1)
6430 {
7007 {
6431 if (_wrapper) {
7008 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6432 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
7009 static PyObject* name = PyString_FromString("changeEvent");
6433 PyErr_Clear();
7010 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6434 if (obj && !PythonQtSlotFunction_Check(obj)) {
7011 if (obj) {
6435 static const char* argumentList[] ={"" , "QEvent*"};
7012 static const char* argumentList[] ={"" , "QEvent*"};
6436 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7013 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6437 void* args[2] = {NULL, (void*)&arg__1};
7014 void* args[2] = {NULL, (void*)&arg__1};
6438 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7015 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6439 if (result) { Py_DECREF(result); }
7016 if (result) { Py_DECREF(result); }
6440 Py_DECREF(obj);
7017 Py_DECREF(obj);
6441 return;
7018 return;
7019 } else {
7020 PyErr_Clear();
6442 }
7021 }
6443 }
7022 }
6444 elfInfoWdgt::changeEvent(arg__1);
7023 elfInfoWdgt::changeEvent(arg__1);
6445 }
7024 }
6446 void PythonQtShell_elfInfoWdgt::childEvent(QChildEvent* arg__1)
7025 void PythonQtShell_elfInfoWdgt::childEvent(QChildEvent* arg__1)
6447 {
7026 {
6448 if (_wrapper) {
7027 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6449 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
7028 static PyObject* name = PyString_FromString("childEvent");
6450 PyErr_Clear();
7029 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6451 if (obj && !PythonQtSlotFunction_Check(obj)) {
7030 if (obj) {
6452 static const char* argumentList[] ={"" , "QChildEvent*"};
7031 static const char* argumentList[] ={"" , "QChildEvent*"};
6453 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7032 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6454 void* args[2] = {NULL, (void*)&arg__1};
7033 void* args[2] = {NULL, (void*)&arg__1};
6455 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7034 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6456 if (result) { Py_DECREF(result); }
7035 if (result) { Py_DECREF(result); }
6457 Py_DECREF(obj);
7036 Py_DECREF(obj);
6458 return;
7037 return;
7038 } else {
7039 PyErr_Clear();
6459 }
7040 }
6460 }
7041 }
6461 elfInfoWdgt::childEvent(arg__1);
7042 elfInfoWdgt::childEvent(arg__1);
6462 }
7043 }
6463 void PythonQtShell_elfInfoWdgt::closeEvent(QCloseEvent* arg__1)
7044 void PythonQtShell_elfInfoWdgt::closeEvent(QCloseEvent* arg__1)
6464 {
7045 {
6465 if (_wrapper) {
7046 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6466 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
7047 static PyObject* name = PyString_FromString("closeEvent");
6467 PyErr_Clear();
7048 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6468 if (obj && !PythonQtSlotFunction_Check(obj)) {
7049 if (obj) {
6469 static const char* argumentList[] ={"" , "QCloseEvent*"};
7050 static const char* argumentList[] ={"" , "QCloseEvent*"};
6470 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7051 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6471 void* args[2] = {NULL, (void*)&arg__1};
7052 void* args[2] = {NULL, (void*)&arg__1};
6472 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7053 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6473 if (result) { Py_DECREF(result); }
7054 if (result) { Py_DECREF(result); }
6474 Py_DECREF(obj);
7055 Py_DECREF(obj);
6475 return;
7056 return;
7057 } else {
7058 PyErr_Clear();
6476 }
7059 }
6477 }
7060 }
6478 elfInfoWdgt::closeEvent(arg__1);
7061 elfInfoWdgt::closeEvent(arg__1);
6479 }
7062 }
6480 void PythonQtShell_elfInfoWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
7063 void PythonQtShell_elfInfoWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
6481 {
7064 {
6482 if (_wrapper) {
7065 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6483 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
7066 static PyObject* name = PyString_FromString("contextMenuEvent");
6484 PyErr_Clear();
7067 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6485 if (obj && !PythonQtSlotFunction_Check(obj)) {
7068 if (obj) {
6486 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
7069 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
6487 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7070 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6488 void* args[2] = {NULL, (void*)&arg__1};
7071 void* args[2] = {NULL, (void*)&arg__1};
6489 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7072 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6490 if (result) { Py_DECREF(result); }
7073 if (result) { Py_DECREF(result); }
6491 Py_DECREF(obj);
7074 Py_DECREF(obj);
6492 return;
7075 return;
7076 } else {
7077 PyErr_Clear();
6493 }
7078 }
6494 }
7079 }
6495 elfInfoWdgt::contextMenuEvent(arg__1);
7080 elfInfoWdgt::contextMenuEvent(arg__1);
6496 }
7081 }
6497 void PythonQtShell_elfInfoWdgt::customEvent(QEvent* arg__1)
7082 void PythonQtShell_elfInfoWdgt::customEvent(QEvent* arg__1)
6498 {
7083 {
6499 if (_wrapper) {
7084 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6500 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
7085 static PyObject* name = PyString_FromString("customEvent");
6501 PyErr_Clear();
7086 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6502 if (obj && !PythonQtSlotFunction_Check(obj)) {
7087 if (obj) {
6503 static const char* argumentList[] ={"" , "QEvent*"};
7088 static const char* argumentList[] ={"" , "QEvent*"};
6504 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7089 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6505 void* args[2] = {NULL, (void*)&arg__1};
7090 void* args[2] = {NULL, (void*)&arg__1};
6506 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7091 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6507 if (result) { Py_DECREF(result); }
7092 if (result) { Py_DECREF(result); }
6508 Py_DECREF(obj);
7093 Py_DECREF(obj);
6509 return;
7094 return;
7095 } else {
7096 PyErr_Clear();
6510 }
7097 }
6511 }
7098 }
6512 elfInfoWdgt::customEvent(arg__1);
7099 elfInfoWdgt::customEvent(arg__1);
6513 }
7100 }
6514 int PythonQtShell_elfInfoWdgt::devType() const
7101 int PythonQtShell_elfInfoWdgt::devType() const
6515 {
7102 {
6516 if (_wrapper) {
7103 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6517 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
7104 static PyObject* name = PyString_FromString("devType");
6518 PyErr_Clear();
7105 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6519 if (obj && !PythonQtSlotFunction_Check(obj)) {
7106 if (obj) {
6520 static const char* argumentList[] ={"int"};
7107 static const char* argumentList[] ={"int"};
6521 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7108 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6522 int returnValue;
7109 int returnValue;
6523 void* args[1] = {NULL};
7110 void* args[1] = {NULL};
6524 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7111 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6525 if (result) {
7112 if (result) {
6526 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7113 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6527 if (args[0]!=&returnValue) {
7114 if (args[0]!=&returnValue) {
6528 if (args[0]==NULL) {
7115 if (args[0]==NULL) {
6529 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
7116 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
6530 } else {
7117 } else {
6531 returnValue = *((int*)args[0]);
7118 returnValue = *((int*)args[0]);
6532 }
7119 }
6533 }
7120 }
6534 }
7121 }
6535 if (result) { Py_DECREF(result); }
7122 if (result) { Py_DECREF(result); }
6536 Py_DECREF(obj);
7123 Py_DECREF(obj);
6537 return returnValue;
7124 return returnValue;
7125 } else {
7126 PyErr_Clear();
6538 }
7127 }
6539 }
7128 }
6540 return elfInfoWdgt::devType();
7129 return elfInfoWdgt::devType();
6541 }
7130 }
6542 void PythonQtShell_elfInfoWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
7131 void PythonQtShell_elfInfoWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
6543 {
7132 {
6544 if (_wrapper) {
7133 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6545 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
7134 static PyObject* name = PyString_FromString("dragEnterEvent");
6546 PyErr_Clear();
7135 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6547 if (obj && !PythonQtSlotFunction_Check(obj)) {
7136 if (obj) {
6548 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
7137 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
6549 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7138 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6550 void* args[2] = {NULL, (void*)&arg__1};
7139 void* args[2] = {NULL, (void*)&arg__1};
6551 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7140 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6552 if (result) { Py_DECREF(result); }
7141 if (result) { Py_DECREF(result); }
6553 Py_DECREF(obj);
7142 Py_DECREF(obj);
6554 return;
7143 return;
7144 } else {
7145 PyErr_Clear();
6555 }
7146 }
6556 }
7147 }
6557 elfInfoWdgt::dragEnterEvent(arg__1);
7148 elfInfoWdgt::dragEnterEvent(arg__1);
6558 }
7149 }
6559 void PythonQtShell_elfInfoWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
7150 void PythonQtShell_elfInfoWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
6560 {
7151 {
6561 if (_wrapper) {
7152 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6562 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
7153 static PyObject* name = PyString_FromString("dragLeaveEvent");
6563 PyErr_Clear();
7154 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6564 if (obj && !PythonQtSlotFunction_Check(obj)) {
7155 if (obj) {
6565 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
7156 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
6566 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7157 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6567 void* args[2] = {NULL, (void*)&arg__1};
7158 void* args[2] = {NULL, (void*)&arg__1};
6568 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7159 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6569 if (result) { Py_DECREF(result); }
7160 if (result) { Py_DECREF(result); }
6570 Py_DECREF(obj);
7161 Py_DECREF(obj);
6571 return;
7162 return;
7163 } else {
7164 PyErr_Clear();
6572 }
7165 }
6573 }
7166 }
6574 elfInfoWdgt::dragLeaveEvent(arg__1);
7167 elfInfoWdgt::dragLeaveEvent(arg__1);
6575 }
7168 }
6576 void PythonQtShell_elfInfoWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
7169 void PythonQtShell_elfInfoWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
6577 {
7170 {
6578 if (_wrapper) {
7171 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6579 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
7172 static PyObject* name = PyString_FromString("dragMoveEvent");
6580 PyErr_Clear();
7173 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6581 if (obj && !PythonQtSlotFunction_Check(obj)) {
7174 if (obj) {
6582 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
7175 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
6583 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7176 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6584 void* args[2] = {NULL, (void*)&arg__1};
7177 void* args[2] = {NULL, (void*)&arg__1};
6585 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7178 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6586 if (result) { Py_DECREF(result); }
7179 if (result) { Py_DECREF(result); }
6587 Py_DECREF(obj);
7180 Py_DECREF(obj);
6588 return;
7181 return;
7182 } else {
7183 PyErr_Clear();
6589 }
7184 }
6590 }
7185 }
6591 elfInfoWdgt::dragMoveEvent(arg__1);
7186 elfInfoWdgt::dragMoveEvent(arg__1);
6592 }
7187 }
6593 void PythonQtShell_elfInfoWdgt::dropEvent(QDropEvent* arg__1)
7188 void PythonQtShell_elfInfoWdgt::dropEvent(QDropEvent* arg__1)
6594 {
7189 {
6595 if (_wrapper) {
7190 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6596 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
7191 static PyObject* name = PyString_FromString("dropEvent");
6597 PyErr_Clear();
7192 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6598 if (obj && !PythonQtSlotFunction_Check(obj)) {
7193 if (obj) {
6599 static const char* argumentList[] ={"" , "QDropEvent*"};
7194 static const char* argumentList[] ={"" , "QDropEvent*"};
6600 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7195 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6601 void* args[2] = {NULL, (void*)&arg__1};
7196 void* args[2] = {NULL, (void*)&arg__1};
6602 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7197 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6603 if (result) { Py_DECREF(result); }
7198 if (result) { Py_DECREF(result); }
6604 Py_DECREF(obj);
7199 Py_DECREF(obj);
6605 return;
7200 return;
7201 } else {
7202 PyErr_Clear();
6606 }
7203 }
6607 }
7204 }
6608 elfInfoWdgt::dropEvent(arg__1);
7205 elfInfoWdgt::dropEvent(arg__1);
6609 }
7206 }
6610 void PythonQtShell_elfInfoWdgt::enterEvent(QEvent* arg__1)
7207 void PythonQtShell_elfInfoWdgt::enterEvent(QEvent* arg__1)
6611 {
7208 {
6612 if (_wrapper) {
7209 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6613 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
7210 static PyObject* name = PyString_FromString("enterEvent");
6614 PyErr_Clear();
7211 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6615 if (obj && !PythonQtSlotFunction_Check(obj)) {
7212 if (obj) {
6616 static const char* argumentList[] ={"" , "QEvent*"};
7213 static const char* argumentList[] ={"" , "QEvent*"};
6617 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7214 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6618 void* args[2] = {NULL, (void*)&arg__1};
7215 void* args[2] = {NULL, (void*)&arg__1};
6619 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7216 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6620 if (result) { Py_DECREF(result); }
7217 if (result) { Py_DECREF(result); }
6621 Py_DECREF(obj);
7218 Py_DECREF(obj);
6622 return;
7219 return;
7220 } else {
7221 PyErr_Clear();
6623 }
7222 }
6624 }
7223 }
6625 elfInfoWdgt::enterEvent(arg__1);
7224 elfInfoWdgt::enterEvent(arg__1);
6626 }
7225 }
6627 bool PythonQtShell_elfInfoWdgt::event(QEvent* arg__1)
7226 bool PythonQtShell_elfInfoWdgt::event(QEvent* arg__1)
6628 {
7227 {
6629 if (_wrapper) {
7228 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6630 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
7229 static PyObject* name = PyString_FromString("event");
6631 PyErr_Clear();
7230 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6632 if (obj && !PythonQtSlotFunction_Check(obj)) {
7231 if (obj) {
6633 static const char* argumentList[] ={"bool" , "QEvent*"};
7232 static const char* argumentList[] ={"bool" , "QEvent*"};
6634 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7233 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6635 bool returnValue;
7234 bool returnValue;
6636 void* args[2] = {NULL, (void*)&arg__1};
7235 void* args[2] = {NULL, (void*)&arg__1};
6637 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7236 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6638 if (result) {
7237 if (result) {
6639 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7238 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6640 if (args[0]!=&returnValue) {
7239 if (args[0]!=&returnValue) {
6641 if (args[0]==NULL) {
7240 if (args[0]==NULL) {
6642 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
7241 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
6643 } else {
7242 } else {
6644 returnValue = *((bool*)args[0]);
7243 returnValue = *((bool*)args[0]);
6645 }
7244 }
6646 }
7245 }
6647 }
7246 }
6648 if (result) { Py_DECREF(result); }
7247 if (result) { Py_DECREF(result); }
6649 Py_DECREF(obj);
7248 Py_DECREF(obj);
6650 return returnValue;
7249 return returnValue;
7250 } else {
7251 PyErr_Clear();
6651 }
7252 }
6652 }
7253 }
6653 return elfInfoWdgt::event(arg__1);
7254 return elfInfoWdgt::event(arg__1);
6654 }
7255 }
6655 bool PythonQtShell_elfInfoWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
7256 bool PythonQtShell_elfInfoWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
6656 {
7257 {
6657 if (_wrapper) {
7258 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6658 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
7259 static PyObject* name = PyString_FromString("eventFilter");
6659 PyErr_Clear();
7260 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6660 if (obj && !PythonQtSlotFunction_Check(obj)) {
7261 if (obj) {
6661 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
7262 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
6662 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
7263 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
6663 bool returnValue;
7264 bool returnValue;
6664 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
7265 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
6665 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7266 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6666 if (result) {
7267 if (result) {
6667 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7268 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6668 if (args[0]!=&returnValue) {
7269 if (args[0]!=&returnValue) {
6669 if (args[0]==NULL) {
7270 if (args[0]==NULL) {
6670 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
7271 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
6671 } else {
7272 } else {
6672 returnValue = *((bool*)args[0]);
7273 returnValue = *((bool*)args[0]);
6673 }
7274 }
6674 }
7275 }
6675 }
7276 }
6676 if (result) { Py_DECREF(result); }
7277 if (result) { Py_DECREF(result); }
6677 Py_DECREF(obj);
7278 Py_DECREF(obj);
6678 return returnValue;
7279 return returnValue;
7280 } else {
7281 PyErr_Clear();
6679 }
7282 }
6680 }
7283 }
6681 return elfInfoWdgt::eventFilter(arg__1, arg__2);
7284 return elfInfoWdgt::eventFilter(arg__1, arg__2);
6682 }
7285 }
6683 void PythonQtShell_elfInfoWdgt::focusInEvent(QFocusEvent* arg__1)
7286 void PythonQtShell_elfInfoWdgt::focusInEvent(QFocusEvent* arg__1)
6684 {
7287 {
6685 if (_wrapper) {
7288 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6686 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
7289 static PyObject* name = PyString_FromString("focusInEvent");
6687 PyErr_Clear();
7290 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6688 if (obj && !PythonQtSlotFunction_Check(obj)) {
7291 if (obj) {
6689 static const char* argumentList[] ={"" , "QFocusEvent*"};
7292 static const char* argumentList[] ={"" , "QFocusEvent*"};
6690 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7293 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6691 void* args[2] = {NULL, (void*)&arg__1};
7294 void* args[2] = {NULL, (void*)&arg__1};
6692 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7295 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6693 if (result) { Py_DECREF(result); }
7296 if (result) { Py_DECREF(result); }
6694 Py_DECREF(obj);
7297 Py_DECREF(obj);
6695 return;
7298 return;
7299 } else {
7300 PyErr_Clear();
6696 }
7301 }
6697 }
7302 }
6698 elfInfoWdgt::focusInEvent(arg__1);
7303 elfInfoWdgt::focusInEvent(arg__1);
6699 }
7304 }
6700 bool PythonQtShell_elfInfoWdgt::focusNextPrevChild(bool next)
7305 bool PythonQtShell_elfInfoWdgt::focusNextPrevChild(bool next0)
6701 {
7306 {
6702 if (_wrapper) {
7307 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6703 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
7308 static PyObject* name = PyString_FromString("focusNextPrevChild");
6704 PyErr_Clear();
7309 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6705 if (obj && !PythonQtSlotFunction_Check(obj)) {
7310 if (obj) {
6706 static const char* argumentList[] ={"bool" , "bool"};
7311 static const char* argumentList[] ={"bool" , "bool"};
6707 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7312 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6708 bool returnValue;
7313 bool returnValue;
6709 void* args[2] = {NULL, (void*)&next};
7314 void* args[2] = {NULL, (void*)&next0};
6710 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7315 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6711 if (result) {
7316 if (result) {
6712 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7317 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6713 if (args[0]!=&returnValue) {
7318 if (args[0]!=&returnValue) {
6714 if (args[0]==NULL) {
7319 if (args[0]==NULL) {
6715 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
7320 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
6716 } else {
7321 } else {
6717 returnValue = *((bool*)args[0]);
7322 returnValue = *((bool*)args[0]);
6718 }
7323 }
6719 }
7324 }
6720 }
7325 }
6721 if (result) { Py_DECREF(result); }
7326 if (result) { Py_DECREF(result); }
6722 Py_DECREF(obj);
7327 Py_DECREF(obj);
6723 return returnValue;
7328 return returnValue;
6724 }
7329 } else {
6725 }
7330 PyErr_Clear();
6726 return elfInfoWdgt::focusNextPrevChild(next);
7331 }
7332 }
7333 return elfInfoWdgt::focusNextPrevChild(next0);
6727 }
7334 }
6728 void PythonQtShell_elfInfoWdgt::focusOutEvent(QFocusEvent* arg__1)
7335 void PythonQtShell_elfInfoWdgt::focusOutEvent(QFocusEvent* arg__1)
6729 {
7336 {
6730 if (_wrapper) {
7337 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6731 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
7338 static PyObject* name = PyString_FromString("focusOutEvent");
6732 PyErr_Clear();
7339 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6733 if (obj && !PythonQtSlotFunction_Check(obj)) {
7340 if (obj) {
6734 static const char* argumentList[] ={"" , "QFocusEvent*"};
7341 static const char* argumentList[] ={"" , "QFocusEvent*"};
6735 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7342 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6736 void* args[2] = {NULL, (void*)&arg__1};
7343 void* args[2] = {NULL, (void*)&arg__1};
6737 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7344 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6738 if (result) { Py_DECREF(result); }
7345 if (result) { Py_DECREF(result); }
6739 Py_DECREF(obj);
7346 Py_DECREF(obj);
6740 return;
7347 return;
7348 } else {
7349 PyErr_Clear();
6741 }
7350 }
6742 }
7351 }
6743 elfInfoWdgt::focusOutEvent(arg__1);
7352 elfInfoWdgt::focusOutEvent(arg__1);
6744 }
7353 }
6745 bool PythonQtShell_elfInfoWdgt::hasHeightForWidth() const
7354 bool PythonQtShell_elfInfoWdgt::hasHeightForWidth() const
6746 {
7355 {
6747 if (_wrapper) {
7356 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6748 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
7357 static PyObject* name = PyString_FromString("hasHeightForWidth");
6749 PyErr_Clear();
7358 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6750 if (obj && !PythonQtSlotFunction_Check(obj)) {
7359 if (obj) {
6751 static const char* argumentList[] ={"bool"};
7360 static const char* argumentList[] ={"bool"};
6752 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7361 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6753 bool returnValue;
7362 bool returnValue;
6754 void* args[1] = {NULL};
7363 void* args[1] = {NULL};
6755 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7364 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6756 if (result) {
7365 if (result) {
6757 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7366 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6758 if (args[0]!=&returnValue) {
7367 if (args[0]!=&returnValue) {
6759 if (args[0]==NULL) {
7368 if (args[0]==NULL) {
6760 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
7369 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
6761 } else {
7370 } else {
6762 returnValue = *((bool*)args[0]);
7371 returnValue = *((bool*)args[0]);
6763 }
7372 }
6764 }
7373 }
6765 }
7374 }
6766 if (result) { Py_DECREF(result); }
7375 if (result) { Py_DECREF(result); }
6767 Py_DECREF(obj);
7376 Py_DECREF(obj);
6768 return returnValue;
7377 return returnValue;
7378 } else {
7379 PyErr_Clear();
6769 }
7380 }
6770 }
7381 }
6771 return elfInfoWdgt::hasHeightForWidth();
7382 return elfInfoWdgt::hasHeightForWidth();
6772 }
7383 }
6773 int PythonQtShell_elfInfoWdgt::heightForWidth(int arg__1) const
7384 int PythonQtShell_elfInfoWdgt::heightForWidth(int arg__1) const
6774 {
7385 {
6775 if (_wrapper) {
7386 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6776 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
7387 static PyObject* name = PyString_FromString("heightForWidth");
6777 PyErr_Clear();
7388 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6778 if (obj && !PythonQtSlotFunction_Check(obj)) {
7389 if (obj) {
6779 static const char* argumentList[] ={"int" , "int"};
7390 static const char* argumentList[] ={"int" , "int"};
6780 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7391 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6781 int returnValue;
7392 int returnValue;
6782 void* args[2] = {NULL, (void*)&arg__1};
7393 void* args[2] = {NULL, (void*)&arg__1};
6783 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7394 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6784 if (result) {
7395 if (result) {
6785 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7396 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6786 if (args[0]!=&returnValue) {
7397 if (args[0]!=&returnValue) {
6787 if (args[0]==NULL) {
7398 if (args[0]==NULL) {
6788 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
7399 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
6789 } else {
7400 } else {
6790 returnValue = *((int*)args[0]);
7401 returnValue = *((int*)args[0]);
6791 }
7402 }
6792 }
7403 }
6793 }
7404 }
6794 if (result) { Py_DECREF(result); }
7405 if (result) { Py_DECREF(result); }
6795 Py_DECREF(obj);
7406 Py_DECREF(obj);
6796 return returnValue;
7407 return returnValue;
7408 } else {
7409 PyErr_Clear();
6797 }
7410 }
6798 }
7411 }
6799 return elfInfoWdgt::heightForWidth(arg__1);
7412 return elfInfoWdgt::heightForWidth(arg__1);
6800 }
7413 }
6801 void PythonQtShell_elfInfoWdgt::hideEvent(QHideEvent* arg__1)
7414 void PythonQtShell_elfInfoWdgt::hideEvent(QHideEvent* arg__1)
6802 {
7415 {
6803 if (_wrapper) {
7416 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6804 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
7417 static PyObject* name = PyString_FromString("hideEvent");
6805 PyErr_Clear();
7418 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6806 if (obj && !PythonQtSlotFunction_Check(obj)) {
7419 if (obj) {
6807 static const char* argumentList[] ={"" , "QHideEvent*"};
7420 static const char* argumentList[] ={"" , "QHideEvent*"};
6808 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7421 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6809 void* args[2] = {NULL, (void*)&arg__1};
7422 void* args[2] = {NULL, (void*)&arg__1};
6810 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7423 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6811 if (result) { Py_DECREF(result); }
7424 if (result) { Py_DECREF(result); }
6812 Py_DECREF(obj);
7425 Py_DECREF(obj);
6813 return;
7426 return;
7427 } else {
7428 PyErr_Clear();
6814 }
7429 }
6815 }
7430 }
6816 elfInfoWdgt::hideEvent(arg__1);
7431 elfInfoWdgt::hideEvent(arg__1);
6817 }
7432 }
6818 void PythonQtShell_elfInfoWdgt::initPainter(QPainter* painter) const
7433 void PythonQtShell_elfInfoWdgt::initPainter(QPainter* painter0) const
6819 {
7434 {
6820 if (_wrapper) {
7435 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6821 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
7436 static PyObject* name = PyString_FromString("initPainter");
6822 PyErr_Clear();
7437 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6823 if (obj && !PythonQtSlotFunction_Check(obj)) {
7438 if (obj) {
6824 static const char* argumentList[] ={"" , "QPainter*"};
7439 static const char* argumentList[] ={"" , "QPainter*"};
6825 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7440 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6826 void* args[2] = {NULL, (void*)&painter};
7441 void* args[2] = {NULL, (void*)&painter0};
6827 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7442 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6828 if (result) { Py_DECREF(result); }
7443 if (result) { Py_DECREF(result); }
6829 Py_DECREF(obj);
7444 Py_DECREF(obj);
6830 return;
7445 return;
6831 }
7446 } else {
6832 }
7447 PyErr_Clear();
6833 elfInfoWdgt::initPainter(painter);
7448 }
7449 }
7450 elfInfoWdgt::initPainter(painter0);
6834 }
7451 }
6835 void PythonQtShell_elfInfoWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
7452 void PythonQtShell_elfInfoWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
6836 {
7453 {
6837 if (_wrapper) {
7454 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6838 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
7455 static PyObject* name = PyString_FromString("inputMethodEvent");
6839 PyErr_Clear();
7456 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6840 if (obj && !PythonQtSlotFunction_Check(obj)) {
7457 if (obj) {
6841 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
7458 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
6842 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7459 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6843 void* args[2] = {NULL, (void*)&arg__1};
7460 void* args[2] = {NULL, (void*)&arg__1};
6844 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7461 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6845 if (result) { Py_DECREF(result); }
7462 if (result) { Py_DECREF(result); }
6846 Py_DECREF(obj);
7463 Py_DECREF(obj);
6847 return;
7464 return;
7465 } else {
7466 PyErr_Clear();
6848 }
7467 }
6849 }
7468 }
6850 elfInfoWdgt::inputMethodEvent(arg__1);
7469 elfInfoWdgt::inputMethodEvent(arg__1);
6851 }
7470 }
6852 QVariant PythonQtShell_elfInfoWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
7471 QVariant PythonQtShell_elfInfoWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
6853 {
7472 {
6854 if (_wrapper) {
7473 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6855 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
7474 static PyObject* name = PyString_FromString("inputMethodQuery");
6856 PyErr_Clear();
7475 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6857 if (obj && !PythonQtSlotFunction_Check(obj)) {
7476 if (obj) {
6858 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
7477 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
6859 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7478 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6860 QVariant returnValue;
7479 QVariant returnValue;
6861 void* args[2] = {NULL, (void*)&arg__1};
7480 void* args[2] = {NULL, (void*)&arg__1};
6862 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7481 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6863 if (result) {
7482 if (result) {
6864 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7483 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6865 if (args[0]!=&returnValue) {
7484 if (args[0]!=&returnValue) {
6866 if (args[0]==NULL) {
7485 if (args[0]==NULL) {
6867 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
7486 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
6868 } else {
7487 } else {
6869 returnValue = *((QVariant*)args[0]);
7488 returnValue = *((QVariant*)args[0]);
6870 }
7489 }
6871 }
7490 }
6872 }
7491 }
6873 if (result) { Py_DECREF(result); }
7492 if (result) { Py_DECREF(result); }
6874 Py_DECREF(obj);
7493 Py_DECREF(obj);
6875 return returnValue;
7494 return returnValue;
7495 } else {
7496 PyErr_Clear();
6876 }
7497 }
6877 }
7498 }
6878 return elfInfoWdgt::inputMethodQuery(arg__1);
7499 return elfInfoWdgt::inputMethodQuery(arg__1);
6879 }
7500 }
6880 void PythonQtShell_elfInfoWdgt::keyPressEvent(QKeyEvent* arg__1)
7501 void PythonQtShell_elfInfoWdgt::keyPressEvent(QKeyEvent* arg__1)
6881 {
7502 {
6882 if (_wrapper) {
7503 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6883 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
7504 static PyObject* name = PyString_FromString("keyPressEvent");
6884 PyErr_Clear();
7505 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6885 if (obj && !PythonQtSlotFunction_Check(obj)) {
7506 if (obj) {
6886 static const char* argumentList[] ={"" , "QKeyEvent*"};
7507 static const char* argumentList[] ={"" , "QKeyEvent*"};
6887 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7508 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6888 void* args[2] = {NULL, (void*)&arg__1};
7509 void* args[2] = {NULL, (void*)&arg__1};
6889 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7510 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6890 if (result) { Py_DECREF(result); }
7511 if (result) { Py_DECREF(result); }
6891 Py_DECREF(obj);
7512 Py_DECREF(obj);
6892 return;
7513 return;
7514 } else {
7515 PyErr_Clear();
6893 }
7516 }
6894 }
7517 }
6895 elfInfoWdgt::keyPressEvent(arg__1);
7518 elfInfoWdgt::keyPressEvent(arg__1);
6896 }
7519 }
6897 void PythonQtShell_elfInfoWdgt::keyReleaseEvent(QKeyEvent* arg__1)
7520 void PythonQtShell_elfInfoWdgt::keyReleaseEvent(QKeyEvent* arg__1)
6898 {
7521 {
6899 if (_wrapper) {
7522 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6900 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
7523 static PyObject* name = PyString_FromString("keyReleaseEvent");
6901 PyErr_Clear();
7524 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6902 if (obj && !PythonQtSlotFunction_Check(obj)) {
7525 if (obj) {
6903 static const char* argumentList[] ={"" , "QKeyEvent*"};
7526 static const char* argumentList[] ={"" , "QKeyEvent*"};
6904 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7527 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6905 void* args[2] = {NULL, (void*)&arg__1};
7528 void* args[2] = {NULL, (void*)&arg__1};
6906 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7529 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6907 if (result) { Py_DECREF(result); }
7530 if (result) { Py_DECREF(result); }
6908 Py_DECREF(obj);
7531 Py_DECREF(obj);
6909 return;
7532 return;
7533 } else {
7534 PyErr_Clear();
6910 }
7535 }
6911 }
7536 }
6912 elfInfoWdgt::keyReleaseEvent(arg__1);
7537 elfInfoWdgt::keyReleaseEvent(arg__1);
6913 }
7538 }
6914 void PythonQtShell_elfInfoWdgt::leaveEvent(QEvent* arg__1)
7539 void PythonQtShell_elfInfoWdgt::leaveEvent(QEvent* arg__1)
6915 {
7540 {
6916 if (_wrapper) {
7541 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6917 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
7542 static PyObject* name = PyString_FromString("leaveEvent");
6918 PyErr_Clear();
7543 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6919 if (obj && !PythonQtSlotFunction_Check(obj)) {
7544 if (obj) {
6920 static const char* argumentList[] ={"" , "QEvent*"};
7545 static const char* argumentList[] ={"" , "QEvent*"};
6921 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7546 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6922 void* args[2] = {NULL, (void*)&arg__1};
7547 void* args[2] = {NULL, (void*)&arg__1};
6923 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7548 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6924 if (result) { Py_DECREF(result); }
7549 if (result) { Py_DECREF(result); }
6925 Py_DECREF(obj);
7550 Py_DECREF(obj);
6926 return;
7551 return;
7552 } else {
7553 PyErr_Clear();
6927 }
7554 }
6928 }
7555 }
6929 elfInfoWdgt::leaveEvent(arg__1);
7556 elfInfoWdgt::leaveEvent(arg__1);
6930 }
7557 }
6931 int PythonQtShell_elfInfoWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
7558 int PythonQtShell_elfInfoWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
6932 {
7559 {
6933 if (_wrapper) {
7560 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6934 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
7561 static PyObject* name = PyString_FromString("metric");
6935 PyErr_Clear();
7562 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6936 if (obj && !PythonQtSlotFunction_Check(obj)) {
7563 if (obj) {
6937 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
7564 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
6938 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7565 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6939 int returnValue;
7566 int returnValue;
6940 void* args[2] = {NULL, (void*)&arg__1};
7567 void* args[2] = {NULL, (void*)&arg__1};
6941 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7568 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6942 if (result) {
7569 if (result) {
6943 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7570 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6944 if (args[0]!=&returnValue) {
7571 if (args[0]!=&returnValue) {
6945 if (args[0]==NULL) {
7572 if (args[0]==NULL) {
6946 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
7573 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
6947 } else {
7574 } else {
6948 returnValue = *((int*)args[0]);
7575 returnValue = *((int*)args[0]);
6949 }
7576 }
6950 }
7577 }
6951 }
7578 }
6952 if (result) { Py_DECREF(result); }
7579 if (result) { Py_DECREF(result); }
6953 Py_DECREF(obj);
7580 Py_DECREF(obj);
6954 return returnValue;
7581 return returnValue;
7582 } else {
7583 PyErr_Clear();
6955 }
7584 }
6956 }
7585 }
6957 return elfInfoWdgt::metric(arg__1);
7586 return elfInfoWdgt::metric(arg__1);
6958 }
7587 }
6959 QSize PythonQtShell_elfInfoWdgt::minimumSizeHint() const
7588 QSize PythonQtShell_elfInfoWdgt::minimumSizeHint() const
6960 {
7589 {
6961 if (_wrapper) {
7590 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6962 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
7591 static PyObject* name = PyString_FromString("getMinimumSizeHint");
6963 PyErr_Clear();
7592 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6964 if (obj && !PythonQtSlotFunction_Check(obj)) {
7593 if (obj) {
6965 static const char* argumentList[] ={"QSize"};
7594 static const char* argumentList[] ={"QSize"};
6966 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7595 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6967 QSize returnValue;
7596 QSize returnValue;
6968 void* args[1] = {NULL};
7597 void* args[1] = {NULL};
6969 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7598 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6970 if (result) {
7599 if (result) {
6971 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7600 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6972 if (args[0]!=&returnValue) {
7601 if (args[0]!=&returnValue) {
6973 if (args[0]==NULL) {
7602 if (args[0]==NULL) {
6974 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
7603 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
6975 } else {
7604 } else {
6976 returnValue = *((QSize*)args[0]);
7605 returnValue = *((QSize*)args[0]);
6977 }
7606 }
6978 }
7607 }
6979 }
7608 }
6980 if (result) { Py_DECREF(result); }
7609 if (result) { Py_DECREF(result); }
6981 Py_DECREF(obj);
7610 Py_DECREF(obj);
6982 return returnValue;
7611 return returnValue;
7612 } else {
7613 PyErr_Clear();
6983 }
7614 }
6984 }
7615 }
6985 return elfInfoWdgt::minimumSizeHint();
7616 return elfInfoWdgt::minimumSizeHint();
6986 }
7617 }
6987 void PythonQtShell_elfInfoWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
7618 void PythonQtShell_elfInfoWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
6988 {
7619 {
6989 if (_wrapper) {
7620 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6990 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
7621 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
6991 PyErr_Clear();
7622 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6992 if (obj && !PythonQtSlotFunction_Check(obj)) {
7623 if (obj) {
6993 static const char* argumentList[] ={"" , "QMouseEvent*"};
7624 static const char* argumentList[] ={"" , "QMouseEvent*"};
6994 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7625 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6995 void* args[2] = {NULL, (void*)&arg__1};
7626 void* args[2] = {NULL, (void*)&arg__1};
6996 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7627 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6997 if (result) { Py_DECREF(result); }
7628 if (result) { Py_DECREF(result); }
6998 Py_DECREF(obj);
7629 Py_DECREF(obj);
6999 return;
7630 return;
7631 } else {
7632 PyErr_Clear();
7000 }
7633 }
7001 }
7634 }
7002 elfInfoWdgt::mouseDoubleClickEvent(arg__1);
7635 elfInfoWdgt::mouseDoubleClickEvent(arg__1);
7003 }
7636 }
7004 void PythonQtShell_elfInfoWdgt::mouseMoveEvent(QMouseEvent* arg__1)
7637 void PythonQtShell_elfInfoWdgt::mouseMoveEvent(QMouseEvent* arg__1)
7005 {
7638 {
7006 if (_wrapper) {
7639 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7007 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
7640 static PyObject* name = PyString_FromString("mouseMoveEvent");
7008 PyErr_Clear();
7641 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7009 if (obj && !PythonQtSlotFunction_Check(obj)) {
7642 if (obj) {
7010 static const char* argumentList[] ={"" , "QMouseEvent*"};
7643 static const char* argumentList[] ={"" , "QMouseEvent*"};
7011 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7644 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7012 void* args[2] = {NULL, (void*)&arg__1};
7645 void* args[2] = {NULL, (void*)&arg__1};
7013 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7646 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7014 if (result) { Py_DECREF(result); }
7647 if (result) { Py_DECREF(result); }
7015 Py_DECREF(obj);
7648 Py_DECREF(obj);
7016 return;
7649 return;
7650 } else {
7651 PyErr_Clear();
7017 }
7652 }
7018 }
7653 }
7019 elfInfoWdgt::mouseMoveEvent(arg__1);
7654 elfInfoWdgt::mouseMoveEvent(arg__1);
7020 }
7655 }
7021 void PythonQtShell_elfInfoWdgt::mousePressEvent(QMouseEvent* arg__1)
7656 void PythonQtShell_elfInfoWdgt::mousePressEvent(QMouseEvent* arg__1)
7022 {
7657 {
7023 if (_wrapper) {
7658 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7024 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
7659 static PyObject* name = PyString_FromString("mousePressEvent");
7025 PyErr_Clear();
7660 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7026 if (obj && !PythonQtSlotFunction_Check(obj)) {
7661 if (obj) {
7027 static const char* argumentList[] ={"" , "QMouseEvent*"};
7662 static const char* argumentList[] ={"" , "QMouseEvent*"};
7028 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7663 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7029 void* args[2] = {NULL, (void*)&arg__1};
7664 void* args[2] = {NULL, (void*)&arg__1};
7030 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7665 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7031 if (result) { Py_DECREF(result); }
7666 if (result) { Py_DECREF(result); }
7032 Py_DECREF(obj);
7667 Py_DECREF(obj);
7033 return;
7668 return;
7669 } else {
7670 PyErr_Clear();
7034 }
7671 }
7035 }
7672 }
7036 elfInfoWdgt::mousePressEvent(arg__1);
7673 elfInfoWdgt::mousePressEvent(arg__1);
7037 }
7674 }
7038 void PythonQtShell_elfInfoWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
7675 void PythonQtShell_elfInfoWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
7039 {
7676 {
7040 if (_wrapper) {
7677 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7041 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
7678 static PyObject* name = PyString_FromString("mouseReleaseEvent");
7042 PyErr_Clear();
7679 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7043 if (obj && !PythonQtSlotFunction_Check(obj)) {
7680 if (obj) {
7044 static const char* argumentList[] ={"" , "QMouseEvent*"};
7681 static const char* argumentList[] ={"" , "QMouseEvent*"};
7045 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7682 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7046 void* args[2] = {NULL, (void*)&arg__1};
7683 void* args[2] = {NULL, (void*)&arg__1};
7047 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7684 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7048 if (result) { Py_DECREF(result); }
7685 if (result) { Py_DECREF(result); }
7049 Py_DECREF(obj);
7686 Py_DECREF(obj);
7050 return;
7687 return;
7688 } else {
7689 PyErr_Clear();
7051 }
7690 }
7052 }
7691 }
7053 elfInfoWdgt::mouseReleaseEvent(arg__1);
7692 elfInfoWdgt::mouseReleaseEvent(arg__1);
7054 }
7693 }
7055 void PythonQtShell_elfInfoWdgt::moveEvent(QMoveEvent* arg__1)
7694 void PythonQtShell_elfInfoWdgt::moveEvent(QMoveEvent* arg__1)
7056 {
7695 {
7057 if (_wrapper) {
7696 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7058 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
7697 static PyObject* name = PyString_FromString("moveEvent");
7059 PyErr_Clear();
7698 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7060 if (obj && !PythonQtSlotFunction_Check(obj)) {
7699 if (obj) {
7061 static const char* argumentList[] ={"" , "QMoveEvent*"};
7700 static const char* argumentList[] ={"" , "QMoveEvent*"};
7062 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7701 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7063 void* args[2] = {NULL, (void*)&arg__1};
7702 void* args[2] = {NULL, (void*)&arg__1};
7064 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7703 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7065 if (result) { Py_DECREF(result); }
7704 if (result) { Py_DECREF(result); }
7066 Py_DECREF(obj);
7705 Py_DECREF(obj);
7067 return;
7706 return;
7707 } else {
7708 PyErr_Clear();
7068 }
7709 }
7069 }
7710 }
7070 elfInfoWdgt::moveEvent(arg__1);
7711 elfInfoWdgt::moveEvent(arg__1);
7071 }
7712 }
7072 bool PythonQtShell_elfInfoWdgt::nativeEvent(const QByteArray& eventType, void* message, long* result)
7713 bool PythonQtShell_elfInfoWdgt::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
7073 {
7714 {
7074 if (_wrapper) {
7715 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7075 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
7716 static PyObject* name = PyString_FromString("nativeEvent");
7076 PyErr_Clear();
7717 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7077 if (obj && !PythonQtSlotFunction_Check(obj)) {
7718 if (obj) {
7078 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
7719 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
7079 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
7720 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
7080 bool returnValue;
7721 bool returnValue;
7081 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
7722 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
7082 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7723 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7083 if (result) {
7724 if (result) {
7084 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7725 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7085 if (args[0]!=&returnValue) {
7726 if (args[0]!=&returnValue) {
7086 if (args[0]==NULL) {
7727 if (args[0]==NULL) {
7087 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
7728 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
7088 } else {
7729 } else {
7089 returnValue = *((bool*)args[0]);
7730 returnValue = *((bool*)args[0]);
7090 }
7731 }
7091 }
7732 }
7092 }
7733 }
7093 if (result) { Py_DECREF(result); }
7734 if (result) { Py_DECREF(result); }
7094 Py_DECREF(obj);
7735 Py_DECREF(obj);
7095 return returnValue;
7736 return returnValue;
7096 }
7737 } else {
7097 }
7738 PyErr_Clear();
7098 return elfInfoWdgt::nativeEvent(eventType, message, result);
7739 }
7740 }
7741 return elfInfoWdgt::nativeEvent(eventType0, message1, result2);
7099 }
7742 }
7100 QPaintEngine* PythonQtShell_elfInfoWdgt::paintEngine() const
7743 QPaintEngine* PythonQtShell_elfInfoWdgt::paintEngine() const
7101 {
7744 {
7102 if (_wrapper) {
7745 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7103 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
7746 static PyObject* name = PyString_FromString("paintEngine");
7104 PyErr_Clear();
7747 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7105 if (obj && !PythonQtSlotFunction_Check(obj)) {
7748 if (obj) {
7106 static const char* argumentList[] ={"QPaintEngine*"};
7749 static const char* argumentList[] ={"QPaintEngine*"};
7107 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7750 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7108 QPaintEngine* returnValue;
7751 QPaintEngine* returnValue;
7109 void* args[1] = {NULL};
7752 void* args[1] = {NULL};
7110 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7753 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7111 if (result) {
7754 if (result) {
7112 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7755 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7113 if (args[0]!=&returnValue) {
7756 if (args[0]!=&returnValue) {
7114 if (args[0]==NULL) {
7757 if (args[0]==NULL) {
7115 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
7758 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
7116 } else {
7759 } else {
7117 returnValue = *((QPaintEngine**)args[0]);
7760 returnValue = *((QPaintEngine**)args[0]);
7118 }
7761 }
7119 }
7762 }
7120 }
7763 }
7121 if (result) { Py_DECREF(result); }
7764 if (result) { Py_DECREF(result); }
7122 Py_DECREF(obj);
7765 Py_DECREF(obj);
7123 return returnValue;
7766 return returnValue;
7767 } else {
7768 PyErr_Clear();
7124 }
7769 }
7125 }
7770 }
7126 return elfInfoWdgt::paintEngine();
7771 return elfInfoWdgt::paintEngine();
7127 }
7772 }
7128 void PythonQtShell_elfInfoWdgt::paintEvent(QPaintEvent* arg__1)
7773 void PythonQtShell_elfInfoWdgt::paintEvent(QPaintEvent* arg__1)
7129 {
7774 {
7130 if (_wrapper) {
7775 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7131 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
7776 static PyObject* name = PyString_FromString("paintEvent");
7132 PyErr_Clear();
7777 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7133 if (obj && !PythonQtSlotFunction_Check(obj)) {
7778 if (obj) {
7134 static const char* argumentList[] ={"" , "QPaintEvent*"};
7779 static const char* argumentList[] ={"" , "QPaintEvent*"};
7135 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7780 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7136 void* args[2] = {NULL, (void*)&arg__1};
7781 void* args[2] = {NULL, (void*)&arg__1};
7137 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7782 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7138 if (result) { Py_DECREF(result); }
7783 if (result) { Py_DECREF(result); }
7139 Py_DECREF(obj);
7784 Py_DECREF(obj);
7140 return;
7785 return;
7786 } else {
7787 PyErr_Clear();
7141 }
7788 }
7142 }
7789 }
7143 elfInfoWdgt::paintEvent(arg__1);
7790 elfInfoWdgt::paintEvent(arg__1);
7144 }
7791 }
7145 QPaintDevice* PythonQtShell_elfInfoWdgt::redirected(QPoint* offset) const
7792 QPaintDevice* PythonQtShell_elfInfoWdgt::redirected(QPoint* offset0) const
7146 {
7793 {
7147 if (_wrapper) {
7794 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7148 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
7795 static PyObject* name = PyString_FromString("redirected");
7149 PyErr_Clear();
7796 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7150 if (obj && !PythonQtSlotFunction_Check(obj)) {
7797 if (obj) {
7151 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
7798 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
7152 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7799 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7153 QPaintDevice* returnValue;
7800 QPaintDevice* returnValue;
7154 void* args[2] = {NULL, (void*)&offset};
7801 void* args[2] = {NULL, (void*)&offset0};
7155 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7802 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7156 if (result) {
7803 if (result) {
7157 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7804 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7158 if (args[0]!=&returnValue) {
7805 if (args[0]!=&returnValue) {
7159 if (args[0]==NULL) {
7806 if (args[0]==NULL) {
7160 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
7807 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
7161 } else {
7808 } else {
7162 returnValue = *((QPaintDevice**)args[0]);
7809 returnValue = *((QPaintDevice**)args[0]);
7163 }
7810 }
7164 }
7811 }
7165 }
7812 }
7166 if (result) { Py_DECREF(result); }
7813 if (result) { Py_DECREF(result); }
7167 Py_DECREF(obj);
7814 Py_DECREF(obj);
7168 return returnValue;
7815 return returnValue;
7169 }
7816 } else {
7170 }
7817 PyErr_Clear();
7171 return elfInfoWdgt::redirected(offset);
7818 }
7819 }
7820 return elfInfoWdgt::redirected(offset0);
7172 }
7821 }
7173 void PythonQtShell_elfInfoWdgt::resizeEvent(QResizeEvent* arg__1)
7822 void PythonQtShell_elfInfoWdgt::resizeEvent(QResizeEvent* arg__1)
7174 {
7823 {
7175 if (_wrapper) {
7824 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7176 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
7825 static PyObject* name = PyString_FromString("resizeEvent");
7177 PyErr_Clear();
7826 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7178 if (obj && !PythonQtSlotFunction_Check(obj)) {
7827 if (obj) {
7179 static const char* argumentList[] ={"" , "QResizeEvent*"};
7828 static const char* argumentList[] ={"" , "QResizeEvent*"};
7180 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7829 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7181 void* args[2] = {NULL, (void*)&arg__1};
7830 void* args[2] = {NULL, (void*)&arg__1};
7182 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7831 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7183 if (result) { Py_DECREF(result); }
7832 if (result) { Py_DECREF(result); }
7184 Py_DECREF(obj);
7833 Py_DECREF(obj);
7185 return;
7834 return;
7835 } else {
7836 PyErr_Clear();
7186 }
7837 }
7187 }
7838 }
7188 elfInfoWdgt::resizeEvent(arg__1);
7839 elfInfoWdgt::resizeEvent(arg__1);
7189 }
7840 }
7190 QPainter* PythonQtShell_elfInfoWdgt::sharedPainter() const
7841 QPainter* PythonQtShell_elfInfoWdgt::sharedPainter() const
7191 {
7842 {
7192 if (_wrapper) {
7843 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7193 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
7844 static PyObject* name = PyString_FromString("sharedPainter");
7194 PyErr_Clear();
7845 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7195 if (obj && !PythonQtSlotFunction_Check(obj)) {
7846 if (obj) {
7196 static const char* argumentList[] ={"QPainter*"};
7847 static const char* argumentList[] ={"QPainter*"};
7197 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7848 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7198 QPainter* returnValue;
7849 QPainter* returnValue;
7199 void* args[1] = {NULL};
7850 void* args[1] = {NULL};
7200 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7851 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7201 if (result) {
7852 if (result) {
7202 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7853 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7203 if (args[0]!=&returnValue) {
7854 if (args[0]!=&returnValue) {
7204 if (args[0]==NULL) {
7855 if (args[0]==NULL) {
7205 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
7856 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
7206 } else {
7857 } else {
7207 returnValue = *((QPainter**)args[0]);
7858 returnValue = *((QPainter**)args[0]);
7208 }
7859 }
7209 }
7860 }
7210 }
7861 }
7211 if (result) { Py_DECREF(result); }
7862 if (result) { Py_DECREF(result); }
7212 Py_DECREF(obj);
7863 Py_DECREF(obj);
7213 return returnValue;
7864 return returnValue;
7865 } else {
7866 PyErr_Clear();
7214 }
7867 }
7215 }
7868 }
7216 return elfInfoWdgt::sharedPainter();
7869 return elfInfoWdgt::sharedPainter();
7217 }
7870 }
7218 void PythonQtShell_elfInfoWdgt::showEvent(QShowEvent* arg__1)
7871 void PythonQtShell_elfInfoWdgt::showEvent(QShowEvent* arg__1)
7219 {
7872 {
7220 if (_wrapper) {
7873 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7221 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
7874 static PyObject* name = PyString_FromString("showEvent");
7222 PyErr_Clear();
7875 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7223 if (obj && !PythonQtSlotFunction_Check(obj)) {
7876 if (obj) {
7224 static const char* argumentList[] ={"" , "QShowEvent*"};
7877 static const char* argumentList[] ={"" , "QShowEvent*"};
7225 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7878 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7226 void* args[2] = {NULL, (void*)&arg__1};
7879 void* args[2] = {NULL, (void*)&arg__1};
7227 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7880 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7228 if (result) { Py_DECREF(result); }
7881 if (result) { Py_DECREF(result); }
7229 Py_DECREF(obj);
7882 Py_DECREF(obj);
7230 return;
7883 return;
7884 } else {
7885 PyErr_Clear();
7231 }
7886 }
7232 }
7887 }
7233 elfInfoWdgt::showEvent(arg__1);
7888 elfInfoWdgt::showEvent(arg__1);
7234 }
7889 }
7235 QSize PythonQtShell_elfInfoWdgt::sizeHint() const
7890 QSize PythonQtShell_elfInfoWdgt::sizeHint() const
7236 {
7891 {
7237 if (_wrapper) {
7892 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7238 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
7893 static PyObject* name = PyString_FromString("getSizeHint");
7239 PyErr_Clear();
7894 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7240 if (obj && !PythonQtSlotFunction_Check(obj)) {
7895 if (obj) {
7241 static const char* argumentList[] ={"QSize"};
7896 static const char* argumentList[] ={"QSize"};
7242 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7897 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7243 QSize returnValue;
7898 QSize returnValue;
7244 void* args[1] = {NULL};
7899 void* args[1] = {NULL};
7245 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7900 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7246 if (result) {
7901 if (result) {
7247 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7902 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7248 if (args[0]!=&returnValue) {
7903 if (args[0]!=&returnValue) {
7249 if (args[0]==NULL) {
7904 if (args[0]==NULL) {
7250 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
7905 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
7251 } else {
7906 } else {
7252 returnValue = *((QSize*)args[0]);
7907 returnValue = *((QSize*)args[0]);
7253 }
7908 }
7254 }
7909 }
7255 }
7910 }
7256 if (result) { Py_DECREF(result); }
7911 if (result) { Py_DECREF(result); }
7257 Py_DECREF(obj);
7912 Py_DECREF(obj);
7258 return returnValue;
7913 return returnValue;
7914 } else {
7915 PyErr_Clear();
7259 }
7916 }
7260 }
7917 }
7261 return elfInfoWdgt::sizeHint();
7918 return elfInfoWdgt::sizeHint();
7262 }
7919 }
7263 void PythonQtShell_elfInfoWdgt::tabletEvent(QTabletEvent* arg__1)
7920 void PythonQtShell_elfInfoWdgt::tabletEvent(QTabletEvent* arg__1)
7264 {
7921 {
7265 if (_wrapper) {
7922 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7266 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
7923 static PyObject* name = PyString_FromString("tabletEvent");
7267 PyErr_Clear();
7924 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7268 if (obj && !PythonQtSlotFunction_Check(obj)) {
7925 if (obj) {
7269 static const char* argumentList[] ={"" , "QTabletEvent*"};
7926 static const char* argumentList[] ={"" , "QTabletEvent*"};
7270 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7927 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7271 void* args[2] = {NULL, (void*)&arg__1};
7928 void* args[2] = {NULL, (void*)&arg__1};
7272 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7929 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7273 if (result) { Py_DECREF(result); }
7930 if (result) { Py_DECREF(result); }
7274 Py_DECREF(obj);
7931 Py_DECREF(obj);
7275 return;
7932 return;
7933 } else {
7934 PyErr_Clear();
7276 }
7935 }
7277 }
7936 }
7278 elfInfoWdgt::tabletEvent(arg__1);
7937 elfInfoWdgt::tabletEvent(arg__1);
7279 }
7938 }
7280 void PythonQtShell_elfInfoWdgt::timerEvent(QTimerEvent* arg__1)
7939 void PythonQtShell_elfInfoWdgt::timerEvent(QTimerEvent* arg__1)
7281 {
7940 {
7282 if (_wrapper) {
7941 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7283 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
7942 static PyObject* name = PyString_FromString("timerEvent");
7284 PyErr_Clear();
7943 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7285 if (obj && !PythonQtSlotFunction_Check(obj)) {
7944 if (obj) {
7286 static const char* argumentList[] ={"" , "QTimerEvent*"};
7945 static const char* argumentList[] ={"" , "QTimerEvent*"};
7287 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7946 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7288 void* args[2] = {NULL, (void*)&arg__1};
7947 void* args[2] = {NULL, (void*)&arg__1};
7289 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7948 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7290 if (result) { Py_DECREF(result); }
7949 if (result) { Py_DECREF(result); }
7291 Py_DECREF(obj);
7950 Py_DECREF(obj);
7292 return;
7951 return;
7952 } else {
7953 PyErr_Clear();
7293 }
7954 }
7294 }
7955 }
7295 elfInfoWdgt::timerEvent(arg__1);
7956 elfInfoWdgt::timerEvent(arg__1);
7296 }
7957 }
7297 void PythonQtShell_elfInfoWdgt::wheelEvent(QWheelEvent* arg__1)
7958 void PythonQtShell_elfInfoWdgt::wheelEvent(QWheelEvent* arg__1)
7298 {
7959 {
7299 if (_wrapper) {
7960 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7300 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
7961 static PyObject* name = PyString_FromString("wheelEvent");
7301 PyErr_Clear();
7962 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7302 if (obj && !PythonQtSlotFunction_Check(obj)) {
7963 if (obj) {
7303 static const char* argumentList[] ={"" , "QWheelEvent*"};
7964 static const char* argumentList[] ={"" , "QWheelEvent*"};
7304 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7965 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7305 void* args[2] = {NULL, (void*)&arg__1};
7966 void* args[2] = {NULL, (void*)&arg__1};
7306 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7967 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7307 if (result) { Py_DECREF(result); }
7968 if (result) { Py_DECREF(result); }
7308 Py_DECREF(obj);
7969 Py_DECREF(obj);
7309 return;
7970 return;
7971 } else {
7972 PyErr_Clear();
7310 }
7973 }
7311 }
7974 }
7312 elfInfoWdgt::wheelEvent(arg__1);
7975 elfInfoWdgt::wheelEvent(arg__1);
7313 }
7976 }
7314 elfInfoWdgt* PythonQtWrapper_elfInfoWdgt::new_elfInfoWdgt(QWidget* parent)
7977 elfInfoWdgt* PythonQtWrapper_elfInfoWdgt::new_elfInfoWdgt(QWidget* parent)
7315 {
7978 {
7316 return new PythonQtShell_elfInfoWdgt(parent); }
7979 return new PythonQtShell_elfInfoWdgt(parent); }
7317
7980
7318
7981
7319
7982
7320 elfparser* PythonQtWrapper_elfparser::new_elfparser()
7983 elfparser* PythonQtWrapper_elfparser::new_elfparser()
7321 {
7984 {
7322 return new elfparser(); }
7985 return new elfparser(); }
7323
7986
7324 int PythonQtWrapper_elfparser::closeFile(elfparser* theWrappedObject)
7987 int PythonQtWrapper_elfparser::closeFile(elfparser* theWrappedObject)
7325 {
7988 {
7326 return ( theWrappedObject->closeFile());
7989 return ( theWrappedObject->closeFile());
7327 }
7990 }
7328
7991
7329 QString PythonQtWrapper_elfparser::getABI(elfparser* theWrappedObject)
7992 QString PythonQtWrapper_elfparser::getABI(elfparser* theWrappedObject)
7330 {
7993 {
7331 return ( theWrappedObject->getABI());
7994 return ( theWrappedObject->getABI());
7332 }
7995 }
7333
7996
7334 QString PythonQtWrapper_elfparser::getArchitecture(elfparser* theWrappedObject)
7997 QString PythonQtWrapper_elfparser::getArchitecture(elfparser* theWrappedObject)
7335 {
7998 {
7336 return ( theWrappedObject->getArchitecture());
7999 return ( theWrappedObject->getArchitecture());
7337 }
8000 }
7338
8001
7339 QString PythonQtWrapper_elfparser::getClass(elfparser* theWrappedObject)
8002 QString PythonQtWrapper_elfparser::getClass(elfparser* theWrappedObject)
7340 {
8003 {
7341 return ( theWrappedObject->getClass());
8004 return ( theWrappedObject->getClass());
7342 }
8005 }
7343
8006
7344 QString PythonQtWrapper_elfparser::getEndianness(elfparser* theWrappedObject)
8007 QString PythonQtWrapper_elfparser::getEndianness(elfparser* theWrappedObject)
7345 {
8008 {
7346 return ( theWrappedObject->getEndianness());
8009 return ( theWrappedObject->getEndianness());
7347 }
8010 }
7348
8011
7349 qint64 PythonQtWrapper_elfparser::getEntryPointAddress(elfparser* theWrappedObject)
8012 qint64 PythonQtWrapper_elfparser::getEntryPointAddress(elfparser* theWrappedObject)
7350 {
8013 {
7351 return ( theWrappedObject->getEntryPointAddress());
8014 return ( theWrappedObject->getEntryPointAddress());
7352 }
8015 }
7353
8016
7354 bool PythonQtWrapper_elfparser::getSectionData(elfparser* theWrappedObject, int index, char** buffer)
8017 bool PythonQtWrapper_elfparser::getSectionData(elfparser* theWrappedObject, int index, char** buffer)
7355 {
8018 {
7356 return ( theWrappedObject->getSectionData(index, buffer));
8019 return ( theWrappedObject->getSectionData(index, buffer));
7357 }
8020 }
7358
8021
7359 qint64 PythonQtWrapper_elfparser::getSectionDatasz(elfparser* theWrappedObject, int index)
8022 qint64 PythonQtWrapper_elfparser::getSectionDatasz(elfparser* theWrappedObject, int index)
7360 {
8023 {
7361 return ( theWrappedObject->getSectionDatasz(index));
8024 return ( theWrappedObject->getSectionDatasz(index));
7362 }
8025 }
7363
8026
7364 qint64 PythonQtWrapper_elfparser::getSectionMemsz(elfparser* theWrappedObject, int index)
8027 qint64 PythonQtWrapper_elfparser::getSectionMemsz(elfparser* theWrappedObject, int index)
7365 {
8028 {
7366 return ( theWrappedObject->getSectionMemsz(index));
8029 return ( theWrappedObject->getSectionMemsz(index));
7367 }
8030 }
7368
8031
7369 QString PythonQtWrapper_elfparser::getSectionName(elfparser* theWrappedObject, int index)
8032 QString PythonQtWrapper_elfparser::getSectionName(elfparser* theWrappedObject, int index)
7370 {
8033 {
7371 return ( theWrappedObject->getSectionName(index));
8034 return ( theWrappedObject->getSectionName(index));
7372 }
8035 }
7373
8036
7374 qint64 PythonQtWrapper_elfparser::getSectionPaddr(elfparser* theWrappedObject, int index)
8037 qint64 PythonQtWrapper_elfparser::getSectionPaddr(elfparser* theWrappedObject, int index)
7375 {
8038 {
7376 return ( theWrappedObject->getSectionPaddr(index));
8039 return ( theWrappedObject->getSectionPaddr(index));
7377 }
8040 }
7378
8041
7379 QString PythonQtWrapper_elfparser::getSectionType(elfparser* theWrappedObject, int index)
8042 QString PythonQtWrapper_elfparser::getSectionType(elfparser* theWrappedObject, int index)
7380 {
8043 {
7381 return ( theWrappedObject->getSectionType(index));
8044 return ( theWrappedObject->getSectionType(index));
7382 }
8045 }
7383
8046
7384 int PythonQtWrapper_elfparser::getSectioncount(elfparser* theWrappedObject)
8047 int PythonQtWrapper_elfparser::getSectioncount(elfparser* theWrappedObject)
7385 {
8048 {
7386 return ( theWrappedObject->getSectioncount());
8049 return ( theWrappedObject->getSectioncount());
7387 }
8050 }
7388
8051
7389 qint64 PythonQtWrapper_elfparser::getSegmentFilesz(elfparser* theWrappedObject, int index)
8052 qint64 PythonQtWrapper_elfparser::getSegmentFilesz(elfparser* theWrappedObject, int index)
7390 {
8053 {
7391 return ( theWrappedObject->getSegmentFilesz(index));
8054 return ( theWrappedObject->getSegmentFilesz(index));
7392 }
8055 }
7393
8056
7394 QString PythonQtWrapper_elfparser::getSegmentFlags(elfparser* theWrappedObject, int index)
8057 QString PythonQtWrapper_elfparser::getSegmentFlags(elfparser* theWrappedObject, int index)
7395 {
8058 {
7396 return ( theWrappedObject->getSegmentFlags(index));
8059 return ( theWrappedObject->getSegmentFlags(index));
7397 }
8060 }
7398
8061
7399 qint64 PythonQtWrapper_elfparser::getSegmentMemsz(elfparser* theWrappedObject, int index)
8062 qint64 PythonQtWrapper_elfparser::getSegmentMemsz(elfparser* theWrappedObject, int index)
7400 {
8063 {
7401 return ( theWrappedObject->getSegmentMemsz(index));
8064 return ( theWrappedObject->getSegmentMemsz(index));
7402 }
8065 }
7403
8066
7404 qint64 PythonQtWrapper_elfparser::getSegmentOffset(elfparser* theWrappedObject, int index)
8067 qint64 PythonQtWrapper_elfparser::getSegmentOffset(elfparser* theWrappedObject, int index)
7405 {
8068 {
7406 return ( theWrappedObject->getSegmentOffset(index));
8069 return ( theWrappedObject->getSegmentOffset(index));
7407 }
8070 }
7408
8071
7409 qint64 PythonQtWrapper_elfparser::getSegmentPaddr(elfparser* theWrappedObject, int index)
8072 qint64 PythonQtWrapper_elfparser::getSegmentPaddr(elfparser* theWrappedObject, int index)
7410 {
8073 {
7411 return ( theWrappedObject->getSegmentPaddr(index));
8074 return ( theWrappedObject->getSegmentPaddr(index));
7412 }
8075 }
7413
8076
7414 QString PythonQtWrapper_elfparser::getSegmentType(elfparser* theWrappedObject, int index)
8077 QString PythonQtWrapper_elfparser::getSegmentType(elfparser* theWrappedObject, int index)
7415 {
8078 {
7416 return ( theWrappedObject->getSegmentType(index));
8079 return ( theWrappedObject->getSegmentType(index));
7417 }
8080 }
7418
8081
7419 qint64 PythonQtWrapper_elfparser::getSegmentVaddr(elfparser* theWrappedObject, int index)
8082 qint64 PythonQtWrapper_elfparser::getSegmentVaddr(elfparser* theWrappedObject, int index)
7420 {
8083 {
7421 return ( theWrappedObject->getSegmentVaddr(index));
8084 return ( theWrappedObject->getSegmentVaddr(index));
7422 }
8085 }
7423
8086
7424 int PythonQtWrapper_elfparser::getSegmentcount(elfparser* theWrappedObject)
8087 int PythonQtWrapper_elfparser::getSegmentcount(elfparser* theWrappedObject)
7425 {
8088 {
7426 return ( theWrappedObject->getSegmentcount());
8089 return ( theWrappedObject->getSegmentcount());
7427 }
8090 }
7428
8091
7429 QString PythonQtWrapper_elfparser::getType(elfparser* theWrappedObject)
8092 QString PythonQtWrapper_elfparser::getType(elfparser* theWrappedObject)
7430 {
8093 {
7431 return ( theWrappedObject->getType());
8094 return ( theWrappedObject->getType());
7432 }
8095 }
7433
8096
7434 qint64 PythonQtWrapper_elfparser::getVersion(elfparser* theWrappedObject)
8097 qint64 PythonQtWrapper_elfparser::getVersion(elfparser* theWrappedObject)
7435 {
8098 {
7436 return ( theWrappedObject->getVersion());
8099 return ( theWrappedObject->getVersion());
7437 }
8100 }
7438
8101
7439 bool PythonQtWrapper_elfparser::static_elfparser_isElf(const QString& File)
8102 bool PythonQtWrapper_elfparser::static_elfparser_isElf(const QString& File)
7440 {
8103 {
7441 return (elfparser::isElf(File));
8104 return (elfparser::isElf(File));
7442 }
8105 }
7443
8106
7444 bool PythonQtWrapper_elfparser::iself(elfparser* theWrappedObject)
8107 bool PythonQtWrapper_elfparser::iself(elfparser* theWrappedObject)
7445 {
8108 {
7446 return ( theWrappedObject->iself());
8109 return ( theWrappedObject->iself());
7447 }
8110 }
7448
8111
7449 bool PythonQtWrapper_elfparser::isopened(elfparser* theWrappedObject)
8112 bool PythonQtWrapper_elfparser::isopened(elfparser* theWrappedObject)
7450 {
8113 {
7451 return ( theWrappedObject->isopened());
8114 return ( theWrappedObject->isopened());
7452 }
8115 }
7453
8116
7454 int PythonQtWrapper_elfparser::setFilename(elfparser* theWrappedObject, const QString& name)
8117 int PythonQtWrapper_elfparser::setFilename(elfparser* theWrappedObject, const QString& name)
7455 {
8118 {
7456 return ( theWrappedObject->setFilename(name));
8119 return ( theWrappedObject->setFilename(name));
7457 }
8120 }
7458
8121
7459
8122
7460
8123
7461 PythonQtShell_genericBinaryFileWidget::~PythonQtShell_genericBinaryFileWidget() {
8124 PythonQtShell_genericBinaryFileWidget::~PythonQtShell_genericBinaryFileWidget() {
7462 PythonQtPrivate* priv = PythonQt::priv();
8125 PythonQtPrivate* priv = PythonQt::priv();
7463 if (priv) { priv->shellClassDeleted(this); }
8126 if (priv) { priv->shellClassDeleted(this); }
7464 }
8127 }
7465 void PythonQtShell_genericBinaryFileWidget::actionEvent(QActionEvent* arg__1)
8128 void PythonQtShell_genericBinaryFileWidget::actionEvent(QActionEvent* arg__1)
7466 {
8129 {
7467 if (_wrapper) {
8130 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7468 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
8131 static PyObject* name = PyString_FromString("actionEvent");
7469 PyErr_Clear();
8132 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7470 if (obj && !PythonQtSlotFunction_Check(obj)) {
8133 if (obj) {
7471 static const char* argumentList[] ={"" , "QActionEvent*"};
8134 static const char* argumentList[] ={"" , "QActionEvent*"};
7472 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8135 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7473 void* args[2] = {NULL, (void*)&arg__1};
8136 void* args[2] = {NULL, (void*)&arg__1};
7474 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8137 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7475 if (result) { Py_DECREF(result); }
8138 if (result) { Py_DECREF(result); }
7476 Py_DECREF(obj);
8139 Py_DECREF(obj);
7477 return;
8140 return;
8141 } else {
8142 PyErr_Clear();
7478 }
8143 }
7479 }
8144 }
7480 genericBinaryFileWidget::actionEvent(arg__1);
8145 genericBinaryFileWidget::actionEvent(arg__1);
7481 }
8146 }
7482 void PythonQtShell_genericBinaryFileWidget::changeEvent(QEvent* arg__1)
8147 void PythonQtShell_genericBinaryFileWidget::changeEvent(QEvent* arg__1)
7483 {
8148 {
7484 if (_wrapper) {
8149 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7485 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
8150 static PyObject* name = PyString_FromString("changeEvent");
7486 PyErr_Clear();
8151 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7487 if (obj && !PythonQtSlotFunction_Check(obj)) {
8152 if (obj) {
7488 static const char* argumentList[] ={"" , "QEvent*"};
8153 static const char* argumentList[] ={"" , "QEvent*"};
7489 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8154 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7490 void* args[2] = {NULL, (void*)&arg__1};
8155 void* args[2] = {NULL, (void*)&arg__1};
7491 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8156 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7492 if (result) { Py_DECREF(result); }
8157 if (result) { Py_DECREF(result); }
7493 Py_DECREF(obj);
8158 Py_DECREF(obj);
7494 return;
8159 return;
8160 } else {
8161 PyErr_Clear();
7495 }
8162 }
7496 }
8163 }
7497 genericBinaryFileWidget::changeEvent(arg__1);
8164 genericBinaryFileWidget::changeEvent(arg__1);
7498 }
8165 }
7499 void PythonQtShell_genericBinaryFileWidget::childEvent(QChildEvent* arg__1)
8166 void PythonQtShell_genericBinaryFileWidget::childEvent(QChildEvent* arg__1)
7500 {
8167 {
7501 if (_wrapper) {
8168 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7502 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
8169 static PyObject* name = PyString_FromString("childEvent");
7503 PyErr_Clear();
8170 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7504 if (obj && !PythonQtSlotFunction_Check(obj)) {
8171 if (obj) {
7505 static const char* argumentList[] ={"" , "QChildEvent*"};
8172 static const char* argumentList[] ={"" , "QChildEvent*"};
7506 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8173 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7507 void* args[2] = {NULL, (void*)&arg__1};
8174 void* args[2] = {NULL, (void*)&arg__1};
7508 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8175 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7509 if (result) { Py_DECREF(result); }
8176 if (result) { Py_DECREF(result); }
7510 Py_DECREF(obj);
8177 Py_DECREF(obj);
7511 return;
8178 return;
8179 } else {
8180 PyErr_Clear();
7512 }
8181 }
7513 }
8182 }
7514 genericBinaryFileWidget::childEvent(arg__1);
8183 genericBinaryFileWidget::childEvent(arg__1);
7515 }
8184 }
7516 void PythonQtShell_genericBinaryFileWidget::closeEvent(QCloseEvent* arg__1)
8185 void PythonQtShell_genericBinaryFileWidget::closeEvent(QCloseEvent* arg__1)
7517 {
8186 {
7518 if (_wrapper) {
8187 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7519 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
8188 static PyObject* name = PyString_FromString("closeEvent");
7520 PyErr_Clear();
8189 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7521 if (obj && !PythonQtSlotFunction_Check(obj)) {
8190 if (obj) {
7522 static const char* argumentList[] ={"" , "QCloseEvent*"};
8191 static const char* argumentList[] ={"" , "QCloseEvent*"};
7523 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8192 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7524 void* args[2] = {NULL, (void*)&arg__1};
8193 void* args[2] = {NULL, (void*)&arg__1};
7525 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8194 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7526 if (result) { Py_DECREF(result); }
8195 if (result) { Py_DECREF(result); }
7527 Py_DECREF(obj);
8196 Py_DECREF(obj);
7528 return;
8197 return;
8198 } else {
8199 PyErr_Clear();
7529 }
8200 }
7530 }
8201 }
7531 genericBinaryFileWidget::closeEvent(arg__1);
8202 genericBinaryFileWidget::closeEvent(arg__1);
7532 }
8203 }
7533 void PythonQtShell_genericBinaryFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
8204 void PythonQtShell_genericBinaryFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
7534 {
8205 {
7535 if (_wrapper) {
8206 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7536 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
8207 static PyObject* name = PyString_FromString("contextMenuEvent");
7537 PyErr_Clear();
8208 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7538 if (obj && !PythonQtSlotFunction_Check(obj)) {
8209 if (obj) {
7539 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
8210 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
7540 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8211 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7541 void* args[2] = {NULL, (void*)&arg__1};
8212 void* args[2] = {NULL, (void*)&arg__1};
7542 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8213 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7543 if (result) { Py_DECREF(result); }
8214 if (result) { Py_DECREF(result); }
7544 Py_DECREF(obj);
8215 Py_DECREF(obj);
7545 return;
8216 return;
8217 } else {
8218 PyErr_Clear();
7546 }
8219 }
7547 }
8220 }
7548 genericBinaryFileWidget::contextMenuEvent(arg__1);
8221 genericBinaryFileWidget::contextMenuEvent(arg__1);
7549 }
8222 }
7550 void PythonQtShell_genericBinaryFileWidget::customEvent(QEvent* arg__1)
8223 void PythonQtShell_genericBinaryFileWidget::customEvent(QEvent* arg__1)
7551 {
8224 {
7552 if (_wrapper) {
8225 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7553 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
8226 static PyObject* name = PyString_FromString("customEvent");
7554 PyErr_Clear();
8227 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7555 if (obj && !PythonQtSlotFunction_Check(obj)) {
8228 if (obj) {
7556 static const char* argumentList[] ={"" , "QEvent*"};
8229 static const char* argumentList[] ={"" , "QEvent*"};
7557 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8230 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7558 void* args[2] = {NULL, (void*)&arg__1};
8231 void* args[2] = {NULL, (void*)&arg__1};
7559 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8232 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7560 if (result) { Py_DECREF(result); }
8233 if (result) { Py_DECREF(result); }
7561 Py_DECREF(obj);
8234 Py_DECREF(obj);
7562 return;
8235 return;
8236 } else {
8237 PyErr_Clear();
7563 }
8238 }
7564 }
8239 }
7565 genericBinaryFileWidget::customEvent(arg__1);
8240 genericBinaryFileWidget::customEvent(arg__1);
7566 }
8241 }
7567 int PythonQtShell_genericBinaryFileWidget::devType() const
8242 int PythonQtShell_genericBinaryFileWidget::devType() const
7568 {
8243 {
7569 if (_wrapper) {
8244 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7570 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
8245 static PyObject* name = PyString_FromString("devType");
7571 PyErr_Clear();
8246 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7572 if (obj && !PythonQtSlotFunction_Check(obj)) {
8247 if (obj) {
7573 static const char* argumentList[] ={"int"};
8248 static const char* argumentList[] ={"int"};
7574 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8249 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7575 int returnValue;
8250 int returnValue;
7576 void* args[1] = {NULL};
8251 void* args[1] = {NULL};
7577 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8252 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7578 if (result) {
8253 if (result) {
7579 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8254 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7580 if (args[0]!=&returnValue) {
8255 if (args[0]!=&returnValue) {
7581 if (args[0]==NULL) {
8256 if (args[0]==NULL) {
7582 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
8257 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
7583 } else {
8258 } else {
7584 returnValue = *((int*)args[0]);
8259 returnValue = *((int*)args[0]);
7585 }
8260 }
7586 }
8261 }
7587 }
8262 }
7588 if (result) { Py_DECREF(result); }
8263 if (result) { Py_DECREF(result); }
7589 Py_DECREF(obj);
8264 Py_DECREF(obj);
7590 return returnValue;
8265 return returnValue;
8266 } else {
8267 PyErr_Clear();
7591 }
8268 }
7592 }
8269 }
7593 return genericBinaryFileWidget::devType();
8270 return genericBinaryFileWidget::devType();
7594 }
8271 }
7595 void PythonQtShell_genericBinaryFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
8272 void PythonQtShell_genericBinaryFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
7596 {
8273 {
7597 if (_wrapper) {
8274 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7598 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
8275 static PyObject* name = PyString_FromString("dragEnterEvent");
7599 PyErr_Clear();
8276 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7600 if (obj && !PythonQtSlotFunction_Check(obj)) {
8277 if (obj) {
7601 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
8278 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
7602 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8279 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7603 void* args[2] = {NULL, (void*)&arg__1};
8280 void* args[2] = {NULL, (void*)&arg__1};
7604 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8281 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7605 if (result) { Py_DECREF(result); }
8282 if (result) { Py_DECREF(result); }
7606 Py_DECREF(obj);
8283 Py_DECREF(obj);
7607 return;
8284 return;
8285 } else {
8286 PyErr_Clear();
7608 }
8287 }
7609 }
8288 }
7610 genericBinaryFileWidget::dragEnterEvent(arg__1);
8289 genericBinaryFileWidget::dragEnterEvent(arg__1);
7611 }
8290 }
7612 void PythonQtShell_genericBinaryFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
8291 void PythonQtShell_genericBinaryFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
7613 {
8292 {
7614 if (_wrapper) {
8293 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7615 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
8294 static PyObject* name = PyString_FromString("dragLeaveEvent");
7616 PyErr_Clear();
8295 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7617 if (obj && !PythonQtSlotFunction_Check(obj)) {
8296 if (obj) {
7618 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
8297 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
7619 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8298 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7620 void* args[2] = {NULL, (void*)&arg__1};
8299 void* args[2] = {NULL, (void*)&arg__1};
7621 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8300 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7622 if (result) { Py_DECREF(result); }
8301 if (result) { Py_DECREF(result); }
7623 Py_DECREF(obj);
8302 Py_DECREF(obj);
7624 return;
8303 return;
8304 } else {
8305 PyErr_Clear();
7625 }
8306 }
7626 }
8307 }
7627 genericBinaryFileWidget::dragLeaveEvent(arg__1);
8308 genericBinaryFileWidget::dragLeaveEvent(arg__1);
7628 }
8309 }
7629 void PythonQtShell_genericBinaryFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
8310 void PythonQtShell_genericBinaryFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
7630 {
8311 {
7631 if (_wrapper) {
8312 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7632 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
8313 static PyObject* name = PyString_FromString("dragMoveEvent");
7633 PyErr_Clear();
8314 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7634 if (obj && !PythonQtSlotFunction_Check(obj)) {
8315 if (obj) {
7635 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
8316 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
7636 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8317 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7637 void* args[2] = {NULL, (void*)&arg__1};
8318 void* args[2] = {NULL, (void*)&arg__1};
7638 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8319 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7639 if (result) { Py_DECREF(result); }
8320 if (result) { Py_DECREF(result); }
7640 Py_DECREF(obj);
8321 Py_DECREF(obj);
7641 return;
8322 return;
8323 } else {
8324 PyErr_Clear();
7642 }
8325 }
7643 }
8326 }
7644 genericBinaryFileWidget::dragMoveEvent(arg__1);
8327 genericBinaryFileWidget::dragMoveEvent(arg__1);
7645 }
8328 }
7646 void PythonQtShell_genericBinaryFileWidget::dropEvent(QDropEvent* arg__1)
8329 void PythonQtShell_genericBinaryFileWidget::dropEvent(QDropEvent* arg__1)
7647 {
8330 {
7648 if (_wrapper) {
8331 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7649 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
8332 static PyObject* name = PyString_FromString("dropEvent");
7650 PyErr_Clear();
8333 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7651 if (obj && !PythonQtSlotFunction_Check(obj)) {
8334 if (obj) {
7652 static const char* argumentList[] ={"" , "QDropEvent*"};
8335 static const char* argumentList[] ={"" , "QDropEvent*"};
7653 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8336 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7654 void* args[2] = {NULL, (void*)&arg__1};
8337 void* args[2] = {NULL, (void*)&arg__1};
7655 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8338 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7656 if (result) { Py_DECREF(result); }
8339 if (result) { Py_DECREF(result); }
7657 Py_DECREF(obj);
8340 Py_DECREF(obj);
7658 return;
8341 return;
8342 } else {
8343 PyErr_Clear();
7659 }
8344 }
7660 }
8345 }
7661 genericBinaryFileWidget::dropEvent(arg__1);
8346 genericBinaryFileWidget::dropEvent(arg__1);
7662 }
8347 }
7663 void PythonQtShell_genericBinaryFileWidget::enterEvent(QEvent* arg__1)
8348 void PythonQtShell_genericBinaryFileWidget::enterEvent(QEvent* arg__1)
7664 {
8349 {
7665 if (_wrapper) {
8350 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7666 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
8351 static PyObject* name = PyString_FromString("enterEvent");
7667 PyErr_Clear();
8352 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7668 if (obj && !PythonQtSlotFunction_Check(obj)) {
8353 if (obj) {
7669 static const char* argumentList[] ={"" , "QEvent*"};
8354 static const char* argumentList[] ={"" , "QEvent*"};
7670 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8355 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7671 void* args[2] = {NULL, (void*)&arg__1};
8356 void* args[2] = {NULL, (void*)&arg__1};
7672 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8357 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7673 if (result) { Py_DECREF(result); }
8358 if (result) { Py_DECREF(result); }
7674 Py_DECREF(obj);
8359 Py_DECREF(obj);
7675 return;
8360 return;
8361 } else {
8362 PyErr_Clear();
7676 }
8363 }
7677 }
8364 }
7678 genericBinaryFileWidget::enterEvent(arg__1);
8365 genericBinaryFileWidget::enterEvent(arg__1);
7679 }
8366 }
7680 bool PythonQtShell_genericBinaryFileWidget::event(QEvent* arg__1)
8367 bool PythonQtShell_genericBinaryFileWidget::event(QEvent* arg__1)
7681 {
8368 {
7682 if (_wrapper) {
8369 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7683 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
8370 static PyObject* name = PyString_FromString("event");
7684 PyErr_Clear();
8371 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7685 if (obj && !PythonQtSlotFunction_Check(obj)) {
8372 if (obj) {
7686 static const char* argumentList[] ={"bool" , "QEvent*"};
8373 static const char* argumentList[] ={"bool" , "QEvent*"};
7687 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8374 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7688 bool returnValue;
8375 bool returnValue;
7689 void* args[2] = {NULL, (void*)&arg__1};
8376 void* args[2] = {NULL, (void*)&arg__1};
7690 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8377 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7691 if (result) {
8378 if (result) {
7692 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8379 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7693 if (args[0]!=&returnValue) {
8380 if (args[0]!=&returnValue) {
7694 if (args[0]==NULL) {
8381 if (args[0]==NULL) {
7695 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
8382 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
7696 } else {
8383 } else {
7697 returnValue = *((bool*)args[0]);
8384 returnValue = *((bool*)args[0]);
7698 }
8385 }
7699 }
8386 }
7700 }
8387 }
7701 if (result) { Py_DECREF(result); }
8388 if (result) { Py_DECREF(result); }
7702 Py_DECREF(obj);
8389 Py_DECREF(obj);
7703 return returnValue;
8390 return returnValue;
8391 } else {
8392 PyErr_Clear();
7704 }
8393 }
7705 }
8394 }
7706 return genericBinaryFileWidget::event(arg__1);
8395 return genericBinaryFileWidget::event(arg__1);
7707 }
8396 }
7708 bool PythonQtShell_genericBinaryFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
8397 bool PythonQtShell_genericBinaryFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
7709 {
8398 {
7710 if (_wrapper) {
8399 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7711 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
8400 static PyObject* name = PyString_FromString("eventFilter");
7712 PyErr_Clear();
8401 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7713 if (obj && !PythonQtSlotFunction_Check(obj)) {
8402 if (obj) {
7714 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
8403 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
7715 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
8404 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
7716 bool returnValue;
8405 bool returnValue;
7717 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
8406 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
7718 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8407 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7719 if (result) {
8408 if (result) {
7720 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8409 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7721 if (args[0]!=&returnValue) {
8410 if (args[0]!=&returnValue) {
7722 if (args[0]==NULL) {
8411 if (args[0]==NULL) {
7723 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
8412 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
7724 } else {
8413 } else {
7725 returnValue = *((bool*)args[0]);
8414 returnValue = *((bool*)args[0]);
7726 }
8415 }
7727 }
8416 }
7728 }
8417 }
7729 if (result) { Py_DECREF(result); }
8418 if (result) { Py_DECREF(result); }
7730 Py_DECREF(obj);
8419 Py_DECREF(obj);
7731 return returnValue;
8420 return returnValue;
8421 } else {
8422 PyErr_Clear();
7732 }
8423 }
7733 }
8424 }
7734 return genericBinaryFileWidget::eventFilter(arg__1, arg__2);
8425 return genericBinaryFileWidget::eventFilter(arg__1, arg__2);
7735 }
8426 }
7736 void PythonQtShell_genericBinaryFileWidget::focusInEvent(QFocusEvent* arg__1)
8427 void PythonQtShell_genericBinaryFileWidget::focusInEvent(QFocusEvent* arg__1)
7737 {
8428 {
7738 if (_wrapper) {
8429 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7739 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
8430 static PyObject* name = PyString_FromString("focusInEvent");
7740 PyErr_Clear();
8431 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7741 if (obj && !PythonQtSlotFunction_Check(obj)) {
8432 if (obj) {
7742 static const char* argumentList[] ={"" , "QFocusEvent*"};
8433 static const char* argumentList[] ={"" , "QFocusEvent*"};
7743 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8434 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7744 void* args[2] = {NULL, (void*)&arg__1};
8435 void* args[2] = {NULL, (void*)&arg__1};
7745 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8436 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7746 if (result) { Py_DECREF(result); }
8437 if (result) { Py_DECREF(result); }
7747 Py_DECREF(obj);
8438 Py_DECREF(obj);
7748 return;
8439 return;
8440 } else {
8441 PyErr_Clear();
7749 }
8442 }
7750 }
8443 }
7751 genericBinaryFileWidget::focusInEvent(arg__1);
8444 genericBinaryFileWidget::focusInEvent(arg__1);
7752 }
8445 }
7753 bool PythonQtShell_genericBinaryFileWidget::focusNextPrevChild(bool next)
8446 bool PythonQtShell_genericBinaryFileWidget::focusNextPrevChild(bool next0)
7754 {
8447 {
7755 if (_wrapper) {
8448 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7756 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
8449 static PyObject* name = PyString_FromString("focusNextPrevChild");
7757 PyErr_Clear();
8450 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7758 if (obj && !PythonQtSlotFunction_Check(obj)) {
8451 if (obj) {
7759 static const char* argumentList[] ={"bool" , "bool"};
8452 static const char* argumentList[] ={"bool" , "bool"};
7760 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8453 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7761 bool returnValue;
8454 bool returnValue;
7762 void* args[2] = {NULL, (void*)&next};
8455 void* args[2] = {NULL, (void*)&next0};
7763 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8456 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7764 if (result) {
8457 if (result) {
7765 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8458 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7766 if (args[0]!=&returnValue) {
8459 if (args[0]!=&returnValue) {
7767 if (args[0]==NULL) {
8460 if (args[0]==NULL) {
7768 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
8461 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
7769 } else {
8462 } else {
7770 returnValue = *((bool*)args[0]);
8463 returnValue = *((bool*)args[0]);
7771 }
8464 }
7772 }
8465 }
7773 }
8466 }
7774 if (result) { Py_DECREF(result); }
8467 if (result) { Py_DECREF(result); }
7775 Py_DECREF(obj);
8468 Py_DECREF(obj);
7776 return returnValue;
8469 return returnValue;
7777 }
8470 } else {
7778 }
8471 PyErr_Clear();
7779 return genericBinaryFileWidget::focusNextPrevChild(next);
8472 }
8473 }
8474 return genericBinaryFileWidget::focusNextPrevChild(next0);
7780 }
8475 }
7781 void PythonQtShell_genericBinaryFileWidget::focusOutEvent(QFocusEvent* arg__1)
8476 void PythonQtShell_genericBinaryFileWidget::focusOutEvent(QFocusEvent* arg__1)
7782 {
8477 {
7783 if (_wrapper) {
8478 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7784 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
8479 static PyObject* name = PyString_FromString("focusOutEvent");
7785 PyErr_Clear();
8480 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7786 if (obj && !PythonQtSlotFunction_Check(obj)) {
8481 if (obj) {
7787 static const char* argumentList[] ={"" , "QFocusEvent*"};
8482 static const char* argumentList[] ={"" , "QFocusEvent*"};
7788 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8483 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7789 void* args[2] = {NULL, (void*)&arg__1};
8484 void* args[2] = {NULL, (void*)&arg__1};
7790 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8485 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7791 if (result) { Py_DECREF(result); }
8486 if (result) { Py_DECREF(result); }
7792 Py_DECREF(obj);
8487 Py_DECREF(obj);
7793 return;
8488 return;
8489 } else {
8490 PyErr_Clear();
7794 }
8491 }
7795 }
8492 }
7796 genericBinaryFileWidget::focusOutEvent(arg__1);
8493 genericBinaryFileWidget::focusOutEvent(arg__1);
7797 }
8494 }
7798 bool PythonQtShell_genericBinaryFileWidget::hasHeightForWidth() const
8495 bool PythonQtShell_genericBinaryFileWidget::hasHeightForWidth() const
7799 {
8496 {
7800 if (_wrapper) {
8497 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7801 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
8498 static PyObject* name = PyString_FromString("hasHeightForWidth");
7802 PyErr_Clear();
8499 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7803 if (obj && !PythonQtSlotFunction_Check(obj)) {
8500 if (obj) {
7804 static const char* argumentList[] ={"bool"};
8501 static const char* argumentList[] ={"bool"};
7805 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8502 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7806 bool returnValue;
8503 bool returnValue;
7807 void* args[1] = {NULL};
8504 void* args[1] = {NULL};
7808 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8505 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7809 if (result) {
8506 if (result) {
7810 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8507 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7811 if (args[0]!=&returnValue) {
8508 if (args[0]!=&returnValue) {
7812 if (args[0]==NULL) {
8509 if (args[0]==NULL) {
7813 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
8510 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
7814 } else {
8511 } else {
7815 returnValue = *((bool*)args[0]);
8512 returnValue = *((bool*)args[0]);
7816 }
8513 }
7817 }
8514 }
7818 }
8515 }
7819 if (result) { Py_DECREF(result); }
8516 if (result) { Py_DECREF(result); }
7820 Py_DECREF(obj);
8517 Py_DECREF(obj);
7821 return returnValue;
8518 return returnValue;
8519 } else {
8520 PyErr_Clear();
7822 }
8521 }
7823 }
8522 }
7824 return genericBinaryFileWidget::hasHeightForWidth();
8523 return genericBinaryFileWidget::hasHeightForWidth();
7825 }
8524 }
7826 int PythonQtShell_genericBinaryFileWidget::heightForWidth(int arg__1) const
8525 int PythonQtShell_genericBinaryFileWidget::heightForWidth(int arg__1) const
7827 {
8526 {
7828 if (_wrapper) {
8527 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7829 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
8528 static PyObject* name = PyString_FromString("heightForWidth");
7830 PyErr_Clear();
8529 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7831 if (obj && !PythonQtSlotFunction_Check(obj)) {
8530 if (obj) {
7832 static const char* argumentList[] ={"int" , "int"};
8531 static const char* argumentList[] ={"int" , "int"};
7833 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8532 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7834 int returnValue;
8533 int returnValue;
7835 void* args[2] = {NULL, (void*)&arg__1};
8534 void* args[2] = {NULL, (void*)&arg__1};
7836 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8535 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7837 if (result) {
8536 if (result) {
7838 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8537 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7839 if (args[0]!=&returnValue) {
8538 if (args[0]!=&returnValue) {
7840 if (args[0]==NULL) {
8539 if (args[0]==NULL) {
7841 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
8540 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
7842 } else {
8541 } else {
7843 returnValue = *((int*)args[0]);
8542 returnValue = *((int*)args[0]);
7844 }
8543 }
7845 }
8544 }
7846 }
8545 }
7847 if (result) { Py_DECREF(result); }
8546 if (result) { Py_DECREF(result); }
7848 Py_DECREF(obj);
8547 Py_DECREF(obj);
7849 return returnValue;
8548 return returnValue;
8549 } else {
8550 PyErr_Clear();
7850 }
8551 }
7851 }
8552 }
7852 return genericBinaryFileWidget::heightForWidth(arg__1);
8553 return genericBinaryFileWidget::heightForWidth(arg__1);
7853 }
8554 }
7854 void PythonQtShell_genericBinaryFileWidget::hideEvent(QHideEvent* arg__1)
8555 void PythonQtShell_genericBinaryFileWidget::hideEvent(QHideEvent* arg__1)
7855 {
8556 {
7856 if (_wrapper) {
8557 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7857 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
8558 static PyObject* name = PyString_FromString("hideEvent");
7858 PyErr_Clear();
8559 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7859 if (obj && !PythonQtSlotFunction_Check(obj)) {
8560 if (obj) {
7860 static const char* argumentList[] ={"" , "QHideEvent*"};
8561 static const char* argumentList[] ={"" , "QHideEvent*"};
7861 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8562 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7862 void* args[2] = {NULL, (void*)&arg__1};
8563 void* args[2] = {NULL, (void*)&arg__1};
7863 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8564 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7864 if (result) { Py_DECREF(result); }
8565 if (result) { Py_DECREF(result); }
7865 Py_DECREF(obj);
8566 Py_DECREF(obj);
7866 return;
8567 return;
8568 } else {
8569 PyErr_Clear();
7867 }
8570 }
7868 }
8571 }
7869 genericBinaryFileWidget::hideEvent(arg__1);
8572 genericBinaryFileWidget::hideEvent(arg__1);
7870 }
8573 }
7871 void PythonQtShell_genericBinaryFileWidget::initPainter(QPainter* painter) const
8574 void PythonQtShell_genericBinaryFileWidget::initPainter(QPainter* painter0) const
7872 {
8575 {
7873 if (_wrapper) {
8576 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7874 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
8577 static PyObject* name = PyString_FromString("initPainter");
7875 PyErr_Clear();
8578 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7876 if (obj && !PythonQtSlotFunction_Check(obj)) {
8579 if (obj) {
7877 static const char* argumentList[] ={"" , "QPainter*"};
8580 static const char* argumentList[] ={"" , "QPainter*"};
7878 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8581 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7879 void* args[2] = {NULL, (void*)&painter};
8582 void* args[2] = {NULL, (void*)&painter0};
7880 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8583 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7881 if (result) { Py_DECREF(result); }
8584 if (result) { Py_DECREF(result); }
7882 Py_DECREF(obj);
8585 Py_DECREF(obj);
7883 return;
8586 return;
7884 }
8587 } else {
7885 }
8588 PyErr_Clear();
7886 genericBinaryFileWidget::initPainter(painter);
8589 }
8590 }
8591 genericBinaryFileWidget::initPainter(painter0);
7887 }
8592 }
7888 void PythonQtShell_genericBinaryFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
8593 void PythonQtShell_genericBinaryFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
7889 {
8594 {
7890 if (_wrapper) {
8595 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7891 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
8596 static PyObject* name = PyString_FromString("inputMethodEvent");
7892 PyErr_Clear();
8597 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7893 if (obj && !PythonQtSlotFunction_Check(obj)) {
8598 if (obj) {
7894 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
8599 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
7895 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8600 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7896 void* args[2] = {NULL, (void*)&arg__1};
8601 void* args[2] = {NULL, (void*)&arg__1};
7897 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8602 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7898 if (result) { Py_DECREF(result); }
8603 if (result) { Py_DECREF(result); }
7899 Py_DECREF(obj);
8604 Py_DECREF(obj);
7900 return;
8605 return;
8606 } else {
8607 PyErr_Clear();
7901 }
8608 }
7902 }
8609 }
7903 genericBinaryFileWidget::inputMethodEvent(arg__1);
8610 genericBinaryFileWidget::inputMethodEvent(arg__1);
7904 }
8611 }
7905 QVariant PythonQtShell_genericBinaryFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
8612 QVariant PythonQtShell_genericBinaryFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
7906 {
8613 {
7907 if (_wrapper) {
8614 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7908 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
8615 static PyObject* name = PyString_FromString("inputMethodQuery");
7909 PyErr_Clear();
8616 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7910 if (obj && !PythonQtSlotFunction_Check(obj)) {
8617 if (obj) {
7911 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
8618 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
7912 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8619 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7913 QVariant returnValue;
8620 QVariant returnValue;
7914 void* args[2] = {NULL, (void*)&arg__1};
8621 void* args[2] = {NULL, (void*)&arg__1};
7915 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8622 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7916 if (result) {
8623 if (result) {
7917 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8624 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7918 if (args[0]!=&returnValue) {
8625 if (args[0]!=&returnValue) {
7919 if (args[0]==NULL) {
8626 if (args[0]==NULL) {
7920 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
8627 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
7921 } else {
8628 } else {
7922 returnValue = *((QVariant*)args[0]);
8629 returnValue = *((QVariant*)args[0]);
7923 }
8630 }
7924 }
8631 }
7925 }
8632 }
7926 if (result) { Py_DECREF(result); }
8633 if (result) { Py_DECREF(result); }
7927 Py_DECREF(obj);
8634 Py_DECREF(obj);
7928 return returnValue;
8635 return returnValue;
8636 } else {
8637 PyErr_Clear();
7929 }
8638 }
7930 }
8639 }
7931 return genericBinaryFileWidget::inputMethodQuery(arg__1);
8640 return genericBinaryFileWidget::inputMethodQuery(arg__1);
7932 }
8641 }
7933 void PythonQtShell_genericBinaryFileWidget::keyPressEvent(QKeyEvent* arg__1)
8642 void PythonQtShell_genericBinaryFileWidget::keyPressEvent(QKeyEvent* arg__1)
7934 {
8643 {
7935 if (_wrapper) {
8644 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7936 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
8645 static PyObject* name = PyString_FromString("keyPressEvent");
7937 PyErr_Clear();
8646 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7938 if (obj && !PythonQtSlotFunction_Check(obj)) {
8647 if (obj) {
7939 static const char* argumentList[] ={"" , "QKeyEvent*"};
8648 static const char* argumentList[] ={"" , "QKeyEvent*"};
7940 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8649 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7941 void* args[2] = {NULL, (void*)&arg__1};
8650 void* args[2] = {NULL, (void*)&arg__1};
7942 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8651 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7943 if (result) { Py_DECREF(result); }
8652 if (result) { Py_DECREF(result); }
7944 Py_DECREF(obj);
8653 Py_DECREF(obj);
7945 return;
8654 return;
8655 } else {
8656 PyErr_Clear();
7946 }
8657 }
7947 }
8658 }
7948 genericBinaryFileWidget::keyPressEvent(arg__1);
8659 genericBinaryFileWidget::keyPressEvent(arg__1);
7949 }
8660 }
7950 void PythonQtShell_genericBinaryFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
8661 void PythonQtShell_genericBinaryFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
7951 {
8662 {
7952 if (_wrapper) {
8663 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7953 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
8664 static PyObject* name = PyString_FromString("keyReleaseEvent");
7954 PyErr_Clear();
8665 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7955 if (obj && !PythonQtSlotFunction_Check(obj)) {
8666 if (obj) {
7956 static const char* argumentList[] ={"" , "QKeyEvent*"};
8667 static const char* argumentList[] ={"" , "QKeyEvent*"};
7957 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8668 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7958 void* args[2] = {NULL, (void*)&arg__1};
8669 void* args[2] = {NULL, (void*)&arg__1};
7959 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8670 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7960 if (result) { Py_DECREF(result); }
8671 if (result) { Py_DECREF(result); }
7961 Py_DECREF(obj);
8672 Py_DECREF(obj);
7962 return;
8673 return;
8674 } else {
8675 PyErr_Clear();
7963 }
8676 }
7964 }
8677 }
7965 genericBinaryFileWidget::keyReleaseEvent(arg__1);
8678 genericBinaryFileWidget::keyReleaseEvent(arg__1);
7966 }
8679 }
7967 void PythonQtShell_genericBinaryFileWidget::leaveEvent(QEvent* arg__1)
8680 void PythonQtShell_genericBinaryFileWidget::leaveEvent(QEvent* arg__1)
7968 {
8681 {
7969 if (_wrapper) {
8682 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7970 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
8683 static PyObject* name = PyString_FromString("leaveEvent");
7971 PyErr_Clear();
8684 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7972 if (obj && !PythonQtSlotFunction_Check(obj)) {
8685 if (obj) {
7973 static const char* argumentList[] ={"" , "QEvent*"};
8686 static const char* argumentList[] ={"" , "QEvent*"};
7974 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8687 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7975 void* args[2] = {NULL, (void*)&arg__1};
8688 void* args[2] = {NULL, (void*)&arg__1};
7976 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8689 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7977 if (result) { Py_DECREF(result); }
8690 if (result) { Py_DECREF(result); }
7978 Py_DECREF(obj);
8691 Py_DECREF(obj);
7979 return;
8692 return;
8693 } else {
8694 PyErr_Clear();
7980 }
8695 }
7981 }
8696 }
7982 genericBinaryFileWidget::leaveEvent(arg__1);
8697 genericBinaryFileWidget::leaveEvent(arg__1);
7983 }
8698 }
7984 int PythonQtShell_genericBinaryFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
8699 int PythonQtShell_genericBinaryFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
7985 {
8700 {
7986 if (_wrapper) {
8701 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7987 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
8702 static PyObject* name = PyString_FromString("metric");
7988 PyErr_Clear();
8703 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7989 if (obj && !PythonQtSlotFunction_Check(obj)) {
8704 if (obj) {
7990 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
8705 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
7991 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8706 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7992 int returnValue;
8707 int returnValue;
7993 void* args[2] = {NULL, (void*)&arg__1};
8708 void* args[2] = {NULL, (void*)&arg__1};
7994 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8709 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7995 if (result) {
8710 if (result) {
7996 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8711 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7997 if (args[0]!=&returnValue) {
8712 if (args[0]!=&returnValue) {
7998 if (args[0]==NULL) {
8713 if (args[0]==NULL) {
7999 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
8714 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
8000 } else {
8715 } else {
8001 returnValue = *((int*)args[0]);
8716 returnValue = *((int*)args[0]);
8002 }
8717 }
8003 }
8718 }
8004 }
8719 }
8005 if (result) { Py_DECREF(result); }
8720 if (result) { Py_DECREF(result); }
8006 Py_DECREF(obj);
8721 Py_DECREF(obj);
8007 return returnValue;
8722 return returnValue;
8723 } else {
8724 PyErr_Clear();
8008 }
8725 }
8009 }
8726 }
8010 return genericBinaryFileWidget::metric(arg__1);
8727 return genericBinaryFileWidget::metric(arg__1);
8011 }
8728 }
8012 QSize PythonQtShell_genericBinaryFileWidget::minimumSizeHint() const
8729 QSize PythonQtShell_genericBinaryFileWidget::minimumSizeHint() const
8013 {
8730 {
8014 if (_wrapper) {
8731 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8015 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
8732 static PyObject* name = PyString_FromString("getMinimumSizeHint");
8016 PyErr_Clear();
8733 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8017 if (obj && !PythonQtSlotFunction_Check(obj)) {
8734 if (obj) {
8018 static const char* argumentList[] ={"QSize"};
8735 static const char* argumentList[] ={"QSize"};
8019 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8736 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8020 QSize returnValue;
8737 QSize returnValue;
8021 void* args[1] = {NULL};
8738 void* args[1] = {NULL};
8022 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8739 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8023 if (result) {
8740 if (result) {
8024 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8741 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8025 if (args[0]!=&returnValue) {
8742 if (args[0]!=&returnValue) {
8026 if (args[0]==NULL) {
8743 if (args[0]==NULL) {
8027 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
8744 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
8028 } else {
8745 } else {
8029 returnValue = *((QSize*)args[0]);
8746 returnValue = *((QSize*)args[0]);
8030 }
8747 }
8031 }
8748 }
8032 }
8749 }
8033 if (result) { Py_DECREF(result); }
8750 if (result) { Py_DECREF(result); }
8034 Py_DECREF(obj);
8751 Py_DECREF(obj);
8035 return returnValue;
8752 return returnValue;
8753 } else {
8754 PyErr_Clear();
8036 }
8755 }
8037 }
8756 }
8038 return genericBinaryFileWidget::minimumSizeHint();
8757 return genericBinaryFileWidget::minimumSizeHint();
8039 }
8758 }
8040 void PythonQtShell_genericBinaryFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
8759 void PythonQtShell_genericBinaryFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
8041 {
8760 {
8042 if (_wrapper) {
8761 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8043 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
8762 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
8044 PyErr_Clear();
8763 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8045 if (obj && !PythonQtSlotFunction_Check(obj)) {
8764 if (obj) {
8046 static const char* argumentList[] ={"" , "QMouseEvent*"};
8765 static const char* argumentList[] ={"" , "QMouseEvent*"};
8047 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8766 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8048 void* args[2] = {NULL, (void*)&arg__1};
8767 void* args[2] = {NULL, (void*)&arg__1};
8049 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8768 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8050 if (result) { Py_DECREF(result); }
8769 if (result) { Py_DECREF(result); }
8051 Py_DECREF(obj);
8770 Py_DECREF(obj);
8052 return;
8771 return;
8772 } else {
8773 PyErr_Clear();
8053 }
8774 }
8054 }
8775 }
8055 genericBinaryFileWidget::mouseDoubleClickEvent(arg__1);
8776 genericBinaryFileWidget::mouseDoubleClickEvent(arg__1);
8056 }
8777 }
8057 void PythonQtShell_genericBinaryFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
8778 void PythonQtShell_genericBinaryFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
8058 {
8779 {
8059 if (_wrapper) {
8780 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8060 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
8781 static PyObject* name = PyString_FromString("mouseMoveEvent");
8061 PyErr_Clear();
8782 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8062 if (obj && !PythonQtSlotFunction_Check(obj)) {
8783 if (obj) {
8063 static const char* argumentList[] ={"" , "QMouseEvent*"};
8784 static const char* argumentList[] ={"" , "QMouseEvent*"};
8064 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8785 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8065 void* args[2] = {NULL, (void*)&arg__1};
8786 void* args[2] = {NULL, (void*)&arg__1};
8066 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8787 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8067 if (result) { Py_DECREF(result); }
8788 if (result) { Py_DECREF(result); }
8068 Py_DECREF(obj);
8789 Py_DECREF(obj);
8069 return;
8790 return;
8791 } else {
8792 PyErr_Clear();
8070 }
8793 }
8071 }
8794 }
8072 genericBinaryFileWidget::mouseMoveEvent(arg__1);
8795 genericBinaryFileWidget::mouseMoveEvent(arg__1);
8073 }
8796 }
8074 void PythonQtShell_genericBinaryFileWidget::mousePressEvent(QMouseEvent* arg__1)
8797 void PythonQtShell_genericBinaryFileWidget::mousePressEvent(QMouseEvent* arg__1)
8075 {
8798 {
8076 if (_wrapper) {
8799 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8077 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
8800 static PyObject* name = PyString_FromString("mousePressEvent");
8078 PyErr_Clear();
8801 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8079 if (obj && !PythonQtSlotFunction_Check(obj)) {
8802 if (obj) {
8080 static const char* argumentList[] ={"" , "QMouseEvent*"};
8803 static const char* argumentList[] ={"" , "QMouseEvent*"};
8081 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8804 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8082 void* args[2] = {NULL, (void*)&arg__1};
8805 void* args[2] = {NULL, (void*)&arg__1};
8083 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8806 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8084 if (result) { Py_DECREF(result); }
8807 if (result) { Py_DECREF(result); }
8085 Py_DECREF(obj);
8808 Py_DECREF(obj);
8086 return;
8809 return;
8810 } else {
8811 PyErr_Clear();
8087 }
8812 }
8088 }
8813 }
8089 genericBinaryFileWidget::mousePressEvent(arg__1);
8814 genericBinaryFileWidget::mousePressEvent(arg__1);
8090 }
8815 }
8091 void PythonQtShell_genericBinaryFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
8816 void PythonQtShell_genericBinaryFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
8092 {
8817 {
8093 if (_wrapper) {
8818 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8094 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
8819 static PyObject* name = PyString_FromString("mouseReleaseEvent");
8095 PyErr_Clear();
8820 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8096 if (obj && !PythonQtSlotFunction_Check(obj)) {
8821 if (obj) {
8097 static const char* argumentList[] ={"" , "QMouseEvent*"};
8822 static const char* argumentList[] ={"" , "QMouseEvent*"};
8098 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8823 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8099 void* args[2] = {NULL, (void*)&arg__1};
8824 void* args[2] = {NULL, (void*)&arg__1};
8100 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8825 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8101 if (result) { Py_DECREF(result); }
8826 if (result) { Py_DECREF(result); }
8102 Py_DECREF(obj);
8827 Py_DECREF(obj);
8103 return;
8828 return;
8829 } else {
8830 PyErr_Clear();
8104 }
8831 }
8105 }
8832 }
8106 genericBinaryFileWidget::mouseReleaseEvent(arg__1);
8833 genericBinaryFileWidget::mouseReleaseEvent(arg__1);
8107 }
8834 }
8108 void PythonQtShell_genericBinaryFileWidget::moveEvent(QMoveEvent* arg__1)
8835 void PythonQtShell_genericBinaryFileWidget::moveEvent(QMoveEvent* arg__1)
8109 {
8836 {
8110 if (_wrapper) {
8837 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8111 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
8838 static PyObject* name = PyString_FromString("moveEvent");
8112 PyErr_Clear();
8839 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8113 if (obj && !PythonQtSlotFunction_Check(obj)) {
8840 if (obj) {
8114 static const char* argumentList[] ={"" , "QMoveEvent*"};
8841 static const char* argumentList[] ={"" , "QMoveEvent*"};
8115 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8842 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8116 void* args[2] = {NULL, (void*)&arg__1};
8843 void* args[2] = {NULL, (void*)&arg__1};
8117 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8844 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8118 if (result) { Py_DECREF(result); }
8845 if (result) { Py_DECREF(result); }
8119 Py_DECREF(obj);
8846 Py_DECREF(obj);
8120 return;
8847 return;
8848 } else {
8849 PyErr_Clear();
8121 }
8850 }
8122 }
8851 }
8123 genericBinaryFileWidget::moveEvent(arg__1);
8852 genericBinaryFileWidget::moveEvent(arg__1);
8124 }
8853 }
8125 bool PythonQtShell_genericBinaryFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result)
8854 bool PythonQtShell_genericBinaryFileWidget::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
8126 {
8855 {
8127 if (_wrapper) {
8856 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8128 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
8857 static PyObject* name = PyString_FromString("nativeEvent");
8129 PyErr_Clear();
8858 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8130 if (obj && !PythonQtSlotFunction_Check(obj)) {
8859 if (obj) {
8131 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
8860 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
8132 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
8861 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
8133 bool returnValue;
8862 bool returnValue;
8134 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
8863 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
8135 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8864 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8136 if (result) {
8865 if (result) {
8137 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8866 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8138 if (args[0]!=&returnValue) {
8867 if (args[0]!=&returnValue) {
8139 if (args[0]==NULL) {
8868 if (args[0]==NULL) {
8140 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
8869 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
8141 } else {
8870 } else {
8142 returnValue = *((bool*)args[0]);
8871 returnValue = *((bool*)args[0]);
8143 }
8872 }
8144 }
8873 }
8145 }
8874 }
8146 if (result) { Py_DECREF(result); }
8875 if (result) { Py_DECREF(result); }
8147 Py_DECREF(obj);
8876 Py_DECREF(obj);
8148 return returnValue;
8877 return returnValue;
8149 }
8878 } else {
8150 }
8879 PyErr_Clear();
8151 return genericBinaryFileWidget::nativeEvent(eventType, message, result);
8880 }
8881 }
8882 return genericBinaryFileWidget::nativeEvent(eventType0, message1, result2);
8152 }
8883 }
8153 QPaintEngine* PythonQtShell_genericBinaryFileWidget::paintEngine() const
8884 QPaintEngine* PythonQtShell_genericBinaryFileWidget::paintEngine() const
8154 {
8885 {
8155 if (_wrapper) {
8886 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8156 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
8887 static PyObject* name = PyString_FromString("paintEngine");
8157 PyErr_Clear();
8888 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8158 if (obj && !PythonQtSlotFunction_Check(obj)) {
8889 if (obj) {
8159 static const char* argumentList[] ={"QPaintEngine*"};
8890 static const char* argumentList[] ={"QPaintEngine*"};
8160 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8891 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8161 QPaintEngine* returnValue;
8892 QPaintEngine* returnValue;
8162 void* args[1] = {NULL};
8893 void* args[1] = {NULL};
8163 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8894 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8164 if (result) {
8895 if (result) {
8165 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8896 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8166 if (args[0]!=&returnValue) {
8897 if (args[0]!=&returnValue) {
8167 if (args[0]==NULL) {
8898 if (args[0]==NULL) {
8168 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
8899 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
8169 } else {
8900 } else {
8170 returnValue = *((QPaintEngine**)args[0]);
8901 returnValue = *((QPaintEngine**)args[0]);
8171 }
8902 }
8172 }
8903 }
8173 }
8904 }
8174 if (result) { Py_DECREF(result); }
8905 if (result) { Py_DECREF(result); }
8175 Py_DECREF(obj);
8906 Py_DECREF(obj);
8176 return returnValue;
8907 return returnValue;
8908 } else {
8909 PyErr_Clear();
8177 }
8910 }
8178 }
8911 }
8179 return genericBinaryFileWidget::paintEngine();
8912 return genericBinaryFileWidget::paintEngine();
8180 }
8913 }
8181 void PythonQtShell_genericBinaryFileWidget::paintEvent(QPaintEvent* arg__1)
8914 void PythonQtShell_genericBinaryFileWidget::paintEvent(QPaintEvent* arg__1)
8182 {
8915 {
8183 if (_wrapper) {
8916 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8184 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
8917 static PyObject* name = PyString_FromString("paintEvent");
8185 PyErr_Clear();
8918 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8186 if (obj && !PythonQtSlotFunction_Check(obj)) {
8919 if (obj) {
8187 static const char* argumentList[] ={"" , "QPaintEvent*"};
8920 static const char* argumentList[] ={"" , "QPaintEvent*"};
8188 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8921 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8189 void* args[2] = {NULL, (void*)&arg__1};
8922 void* args[2] = {NULL, (void*)&arg__1};
8190 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8923 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8191 if (result) { Py_DECREF(result); }
8924 if (result) { Py_DECREF(result); }
8192 Py_DECREF(obj);
8925 Py_DECREF(obj);
8193 return;
8926 return;
8927 } else {
8928 PyErr_Clear();
8194 }
8929 }
8195 }
8930 }
8196 genericBinaryFileWidget::paintEvent(arg__1);
8931 genericBinaryFileWidget::paintEvent(arg__1);
8197 }
8932 }
8198 QPaintDevice* PythonQtShell_genericBinaryFileWidget::redirected(QPoint* offset) const
8933 QPaintDevice* PythonQtShell_genericBinaryFileWidget::redirected(QPoint* offset0) const
8199 {
8934 {
8200 if (_wrapper) {
8935 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8201 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
8936 static PyObject* name = PyString_FromString("redirected");
8202 PyErr_Clear();
8937 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8203 if (obj && !PythonQtSlotFunction_Check(obj)) {
8938 if (obj) {
8204 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
8939 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
8205 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8940 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8206 QPaintDevice* returnValue;
8941 QPaintDevice* returnValue;
8207 void* args[2] = {NULL, (void*)&offset};
8942 void* args[2] = {NULL, (void*)&offset0};
8208 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8943 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8209 if (result) {
8944 if (result) {
8210 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8945 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8211 if (args[0]!=&returnValue) {
8946 if (args[0]!=&returnValue) {
8212 if (args[0]==NULL) {
8947 if (args[0]==NULL) {
8213 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
8948 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
8214 } else {
8949 } else {
8215 returnValue = *((QPaintDevice**)args[0]);
8950 returnValue = *((QPaintDevice**)args[0]);
8216 }
8951 }
8217 }
8952 }
8218 }
8953 }
8219 if (result) { Py_DECREF(result); }
8954 if (result) { Py_DECREF(result); }
8220 Py_DECREF(obj);
8955 Py_DECREF(obj);
8221 return returnValue;
8956 return returnValue;
8222 }
8957 } else {
8223 }
8958 PyErr_Clear();
8224 return genericBinaryFileWidget::redirected(offset);
8959 }
8960 }
8961 return genericBinaryFileWidget::redirected(offset0);
8225 }
8962 }
8226 void PythonQtShell_genericBinaryFileWidget::resizeEvent(QResizeEvent* arg__1)
8963 void PythonQtShell_genericBinaryFileWidget::resizeEvent(QResizeEvent* arg__1)
8227 {
8964 {
8228 if (_wrapper) {
8965 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8229 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
8966 static PyObject* name = PyString_FromString("resizeEvent");
8230 PyErr_Clear();
8967 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8231 if (obj && !PythonQtSlotFunction_Check(obj)) {
8968 if (obj) {
8232 static const char* argumentList[] ={"" , "QResizeEvent*"};
8969 static const char* argumentList[] ={"" , "QResizeEvent*"};
8233 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8970 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8234 void* args[2] = {NULL, (void*)&arg__1};
8971 void* args[2] = {NULL, (void*)&arg__1};
8235 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8972 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8236 if (result) { Py_DECREF(result); }
8973 if (result) { Py_DECREF(result); }
8237 Py_DECREF(obj);
8974 Py_DECREF(obj);
8238 return;
8975 return;
8976 } else {
8977 PyErr_Clear();
8239 }
8978 }
8240 }
8979 }
8241 genericBinaryFileWidget::resizeEvent(arg__1);
8980 genericBinaryFileWidget::resizeEvent(arg__1);
8242 }
8981 }
8243 QPainter* PythonQtShell_genericBinaryFileWidget::sharedPainter() const
8982 QPainter* PythonQtShell_genericBinaryFileWidget::sharedPainter() const
8244 {
8983 {
8245 if (_wrapper) {
8984 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8246 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
8985 static PyObject* name = PyString_FromString("sharedPainter");
8247 PyErr_Clear();
8986 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8248 if (obj && !PythonQtSlotFunction_Check(obj)) {
8987 if (obj) {
8249 static const char* argumentList[] ={"QPainter*"};
8988 static const char* argumentList[] ={"QPainter*"};
8250 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8989 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8251 QPainter* returnValue;
8990 QPainter* returnValue;
8252 void* args[1] = {NULL};
8991 void* args[1] = {NULL};
8253 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8992 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8254 if (result) {
8993 if (result) {
8255 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8994 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8256 if (args[0]!=&returnValue) {
8995 if (args[0]!=&returnValue) {
8257 if (args[0]==NULL) {
8996 if (args[0]==NULL) {
8258 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
8997 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
8259 } else {
8998 } else {
8260 returnValue = *((QPainter**)args[0]);
8999 returnValue = *((QPainter**)args[0]);
8261 }
9000 }
8262 }
9001 }
8263 }
9002 }
8264 if (result) { Py_DECREF(result); }
9003 if (result) { Py_DECREF(result); }
8265 Py_DECREF(obj);
9004 Py_DECREF(obj);
8266 return returnValue;
9005 return returnValue;
9006 } else {
9007 PyErr_Clear();
8267 }
9008 }
8268 }
9009 }
8269 return genericBinaryFileWidget::sharedPainter();
9010 return genericBinaryFileWidget::sharedPainter();
8270 }
9011 }
8271 void PythonQtShell_genericBinaryFileWidget::showEvent(QShowEvent* arg__1)
9012 void PythonQtShell_genericBinaryFileWidget::showEvent(QShowEvent* arg__1)
8272 {
9013 {
8273 if (_wrapper) {
9014 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8274 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
9015 static PyObject* name = PyString_FromString("showEvent");
8275 PyErr_Clear();
9016 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8276 if (obj && !PythonQtSlotFunction_Check(obj)) {
9017 if (obj) {
8277 static const char* argumentList[] ={"" , "QShowEvent*"};
9018 static const char* argumentList[] ={"" , "QShowEvent*"};
8278 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9019 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8279 void* args[2] = {NULL, (void*)&arg__1};
9020 void* args[2] = {NULL, (void*)&arg__1};
8280 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9021 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8281 if (result) { Py_DECREF(result); }
9022 if (result) { Py_DECREF(result); }
8282 Py_DECREF(obj);
9023 Py_DECREF(obj);
8283 return;
9024 return;
9025 } else {
9026 PyErr_Clear();
8284 }
9027 }
8285 }
9028 }
8286 genericBinaryFileWidget::showEvent(arg__1);
9029 genericBinaryFileWidget::showEvent(arg__1);
8287 }
9030 }
8288 QSize PythonQtShell_genericBinaryFileWidget::sizeHint() const
9031 QSize PythonQtShell_genericBinaryFileWidget::sizeHint() const
8289 {
9032 {
8290 if (_wrapper) {
9033 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8291 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
9034 static PyObject* name = PyString_FromString("getSizeHint");
8292 PyErr_Clear();
9035 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8293 if (obj && !PythonQtSlotFunction_Check(obj)) {
9036 if (obj) {
8294 static const char* argumentList[] ={"QSize"};
9037 static const char* argumentList[] ={"QSize"};
8295 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9038 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8296 QSize returnValue;
9039 QSize returnValue;
8297 void* args[1] = {NULL};
9040 void* args[1] = {NULL};
8298 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9041 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8299 if (result) {
9042 if (result) {
8300 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9043 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8301 if (args[0]!=&returnValue) {
9044 if (args[0]!=&returnValue) {
8302 if (args[0]==NULL) {
9045 if (args[0]==NULL) {
8303 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
9046 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
8304 } else {
9047 } else {
8305 returnValue = *((QSize*)args[0]);
9048 returnValue = *((QSize*)args[0]);
8306 }
9049 }
8307 }
9050 }
8308 }
9051 }
8309 if (result) { Py_DECREF(result); }
9052 if (result) { Py_DECREF(result); }
8310 Py_DECREF(obj);
9053 Py_DECREF(obj);
8311 return returnValue;
9054 return returnValue;
9055 } else {
9056 PyErr_Clear();
8312 }
9057 }
8313 }
9058 }
8314 return genericBinaryFileWidget::sizeHint();
9059 return genericBinaryFileWidget::sizeHint();
8315 }
9060 }
8316 void PythonQtShell_genericBinaryFileWidget::tabletEvent(QTabletEvent* arg__1)
9061 void PythonQtShell_genericBinaryFileWidget::tabletEvent(QTabletEvent* arg__1)
8317 {
9062 {
8318 if (_wrapper) {
9063 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8319 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
9064 static PyObject* name = PyString_FromString("tabletEvent");
8320 PyErr_Clear();
9065 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8321 if (obj && !PythonQtSlotFunction_Check(obj)) {
9066 if (obj) {
8322 static const char* argumentList[] ={"" , "QTabletEvent*"};
9067 static const char* argumentList[] ={"" , "QTabletEvent*"};
8323 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9068 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8324 void* args[2] = {NULL, (void*)&arg__1};
9069 void* args[2] = {NULL, (void*)&arg__1};
8325 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9070 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8326 if (result) { Py_DECREF(result); }
9071 if (result) { Py_DECREF(result); }
8327 Py_DECREF(obj);
9072 Py_DECREF(obj);
8328 return;
9073 return;
9074 } else {
9075 PyErr_Clear();
8329 }
9076 }
8330 }
9077 }
8331 genericBinaryFileWidget::tabletEvent(arg__1);
9078 genericBinaryFileWidget::tabletEvent(arg__1);
8332 }
9079 }
8333 void PythonQtShell_genericBinaryFileWidget::timerEvent(QTimerEvent* arg__1)
9080 void PythonQtShell_genericBinaryFileWidget::timerEvent(QTimerEvent* arg__1)
8334 {
9081 {
8335 if (_wrapper) {
9082 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8336 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
9083 static PyObject* name = PyString_FromString("timerEvent");
8337 PyErr_Clear();
9084 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8338 if (obj && !PythonQtSlotFunction_Check(obj)) {
9085 if (obj) {
8339 static const char* argumentList[] ={"" , "QTimerEvent*"};
9086 static const char* argumentList[] ={"" , "QTimerEvent*"};
8340 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9087 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8341 void* args[2] = {NULL, (void*)&arg__1};
9088 void* args[2] = {NULL, (void*)&arg__1};
8342 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9089 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8343 if (result) { Py_DECREF(result); }
9090 if (result) { Py_DECREF(result); }
8344 Py_DECREF(obj);
9091 Py_DECREF(obj);
8345 return;
9092 return;
9093 } else {
9094 PyErr_Clear();
8346 }
9095 }
8347 }
9096 }
8348 genericBinaryFileWidget::timerEvent(arg__1);
9097 genericBinaryFileWidget::timerEvent(arg__1);
8349 }
9098 }
8350 void PythonQtShell_genericBinaryFileWidget::wheelEvent(QWheelEvent* arg__1)
9099 void PythonQtShell_genericBinaryFileWidget::wheelEvent(QWheelEvent* arg__1)
8351 {
9100 {
8352 if (_wrapper) {
9101 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8353 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
9102 static PyObject* name = PyString_FromString("wheelEvent");
8354 PyErr_Clear();
9103 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8355 if (obj && !PythonQtSlotFunction_Check(obj)) {
9104 if (obj) {
8356 static const char* argumentList[] ={"" , "QWheelEvent*"};
9105 static const char* argumentList[] ={"" , "QWheelEvent*"};
8357 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9106 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8358 void* args[2] = {NULL, (void*)&arg__1};
9107 void* args[2] = {NULL, (void*)&arg__1};
8359 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9108 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8360 if (result) { Py_DECREF(result); }
9109 if (result) { Py_DECREF(result); }
8361 Py_DECREF(obj);
9110 Py_DECREF(obj);
8362 return;
9111 return;
9112 } else {
9113 PyErr_Clear();
8363 }
9114 }
8364 }
9115 }
8365 genericBinaryFileWidget::wheelEvent(arg__1);
9116 genericBinaryFileWidget::wheelEvent(arg__1);
8366 }
9117 }
8367 genericBinaryFileWidget* PythonQtWrapper_genericBinaryFileWidget::new_genericBinaryFileWidget(QWidget* parent)
9118 genericBinaryFileWidget* PythonQtWrapper_genericBinaryFileWidget::new_genericBinaryFileWidget(QWidget* parent)
8368 {
9119 {
8369 return new PythonQtShell_genericBinaryFileWidget(parent); }
9120 return new PythonQtShell_genericBinaryFileWidget(parent); }
8370
9121
8371
9122
8372
9123
8373 PythonQtShell_srecFile::~PythonQtShell_srecFile() {
9124 PythonQtShell_srecFile::~PythonQtShell_srecFile() {
8374 PythonQtPrivate* priv = PythonQt::priv();
9125 PythonQtPrivate* priv = PythonQt::priv();
8375 if (priv) { priv->shellClassDeleted(this); }
9126 if (priv) { priv->shellClassDeleted(this); }
8376 }
9127 }
8377 int PythonQtShell_srecFile::closeFile()
9128 int PythonQtShell_srecFile::closeFile()
8378 {
9129 {
8379 if (_wrapper) {
9130 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8380 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
9131 static PyObject* name = PyString_FromString("closeFile");
8381 PyErr_Clear();
9132 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8382 if (obj && !PythonQtSlotFunction_Check(obj)) {
9133 if (obj) {
8383 static const char* argumentList[] ={"int"};
9134 static const char* argumentList[] ={"int"};
8384 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9135 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8385 int returnValue;
9136 int returnValue;
8386 void* args[1] = {NULL};
9137 void* args[1] = {NULL};
8387 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9138 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8388 if (result) {
9139 if (result) {
8389 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9140 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8390 if (args[0]!=&returnValue) {
9141 if (args[0]!=&returnValue) {
8391 if (args[0]==NULL) {
9142 if (args[0]==NULL) {
8392 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
9143 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
8393 } else {
9144 } else {
8394 returnValue = *((int*)args[0]);
9145 returnValue = *((int*)args[0]);
8395 }
9146 }
8396 }
9147 }
8397 }
9148 }
8398 if (result) { Py_DECREF(result); }
9149 if (result) { Py_DECREF(result); }
8399 Py_DECREF(obj);
9150 Py_DECREF(obj);
8400 return returnValue;
9151 return returnValue;
9152 } else {
9153 PyErr_Clear();
8401 }
9154 }
8402 }
9155 }
8403 return srecFile::closeFile();
9156 return srecFile::closeFile();
8404 }
9157 }
8405 QList<codeFragment* > PythonQtShell_srecFile::getFragments()
9158 QList<codeFragment* > PythonQtShell_srecFile::getFragments()
8406 {
9159 {
8407 if (_wrapper) {
9160 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8408 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
9161 static PyObject* name = PyString_FromString("getFragments");
8409 PyErr_Clear();
9162 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8410 if (obj && !PythonQtSlotFunction_Check(obj)) {
9163 if (obj) {
8411 static const char* argumentList[] ={"QList<codeFragment* >"};
9164 static const char* argumentList[] ={"QList<codeFragment* >"};
8412 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9165 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8413 QList<codeFragment* > returnValue;
9166 QList<codeFragment* > returnValue;
8414 void* args[1] = {NULL};
9167 void* args[1] = {NULL};
8415 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9168 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8416 if (result) {
9169 if (result) {
8417 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9170 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8418 if (args[0]!=&returnValue) {
9171 if (args[0]!=&returnValue) {
8419 if (args[0]==NULL) {
9172 if (args[0]==NULL) {
8420 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
9173 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
8421 } else {
9174 } else {
8422 returnValue = *((QList<codeFragment* >*)args[0]);
9175 returnValue = *((QList<codeFragment* >*)args[0]);
8423 }
9176 }
8424 }
9177 }
8425 }
9178 }
8426 if (result) { Py_DECREF(result); }
9179 if (result) { Py_DECREF(result); }
8427 Py_DECREF(obj);
9180 Py_DECREF(obj);
8428 return returnValue;
9181 return returnValue;
9182 } else {
9183 PyErr_Clear();
8429 }
9184 }
8430 }
9185 }
8431 return srecFile::getFragments();
9186 return srecFile::getFragments();
8432 }
9187 }
8433 bool PythonQtShell_srecFile::isopened()
9188 bool PythonQtShell_srecFile::isopened()
8434 {
9189 {
8435 if (_wrapper) {
9190 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8436 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
9191 static PyObject* name = PyString_FromString("isopened");
8437 PyErr_Clear();
9192 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8438 if (obj && !PythonQtSlotFunction_Check(obj)) {
9193 if (obj) {
8439 static const char* argumentList[] ={"bool"};
9194 static const char* argumentList[] ={"bool"};
8440 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9195 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8441 bool returnValue;
9196 bool returnValue;
8442 void* args[1] = {NULL};
9197 void* args[1] = {NULL};
8443 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9198 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8444 if (result) {
9199 if (result) {
8445 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9200 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8446 if (args[0]!=&returnValue) {
9201 if (args[0]!=&returnValue) {
8447 if (args[0]==NULL) {
9202 if (args[0]==NULL) {
8448 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
9203 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
8449 } else {
9204 } else {
8450 returnValue = *((bool*)args[0]);
9205 returnValue = *((bool*)args[0]);
8451 }
9206 }
8452 }
9207 }
8453 }
9208 }
8454 if (result) { Py_DECREF(result); }
9209 if (result) { Py_DECREF(result); }
8455 Py_DECREF(obj);
9210 Py_DECREF(obj);
8456 return returnValue;
9211 return returnValue;
9212 } else {
9213 PyErr_Clear();
8457 }
9214 }
8458 }
9215 }
8459 return srecFile::isopened();
9216 return srecFile::isopened();
8460 }
9217 }
8461 bool PythonQtShell_srecFile::openFile(const QString& File)
9218 bool PythonQtShell_srecFile::openFile(const QString& File0)
8462 {
9219 {
8463 if (_wrapper) {
9220 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8464 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
9221 static PyObject* name = PyString_FromString("openFile");
8465 PyErr_Clear();
9222 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8466 if (obj && !PythonQtSlotFunction_Check(obj)) {
9223 if (obj) {
8467 static const char* argumentList[] ={"bool" , "const QString&"};
9224 static const char* argumentList[] ={"bool" , "const QString&"};
8468 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9225 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8469 bool returnValue;
9226 bool returnValue;
8470 void* args[2] = {NULL, (void*)&File};
9227 void* args[2] = {NULL, (void*)&File0};
8471 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9228 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8472 if (result) {
9229 if (result) {
8473 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9230 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8474 if (args[0]!=&returnValue) {
9231 if (args[0]!=&returnValue) {
8475 if (args[0]==NULL) {
9232 if (args[0]==NULL) {
8476 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
9233 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
8477 } else {
9234 } else {
8478 returnValue = *((bool*)args[0]);
9235 returnValue = *((bool*)args[0]);
8479 }
9236 }
8480 }
9237 }
8481 }
9238 }
8482 if (result) { Py_DECREF(result); }
9239 if (result) { Py_DECREF(result); }
8483 Py_DECREF(obj);
9240 Py_DECREF(obj);
8484 return returnValue;
9241 return returnValue;
8485 }
9242 } else {
8486 }
9243 PyErr_Clear();
8487 return srecFile::openFile(File);
9244 }
8488 }
9245 }
8489 bool PythonQtShell_srecFile::toBinary(const QString& File)
9246 return srecFile::openFile(File0);
8490 {
9247 }
8491 if (_wrapper) {
9248 bool PythonQtShell_srecFile::toBinary(const QString& File0)
8492 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
9249 {
8493 PyErr_Clear();
9250 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8494 if (obj && !PythonQtSlotFunction_Check(obj)) {
9251 static PyObject* name = PyString_FromString("toBinary");
9252 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9253 if (obj) {
8495 static const char* argumentList[] ={"bool" , "const QString&"};
9254 static const char* argumentList[] ={"bool" , "const QString&"};
8496 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9255 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8497 bool returnValue;
9256 bool returnValue;
8498 void* args[2] = {NULL, (void*)&File};
9257 void* args[2] = {NULL, (void*)&File0};
8499 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9258 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8500 if (result) {
9259 if (result) {
8501 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9260 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8502 if (args[0]!=&returnValue) {
9261 if (args[0]!=&returnValue) {
8503 if (args[0]==NULL) {
9262 if (args[0]==NULL) {
8504 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
9263 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
8505 } else {
9264 } else {
8506 returnValue = *((bool*)args[0]);
9265 returnValue = *((bool*)args[0]);
8507 }
9266 }
8508 }
9267 }
8509 }
9268 }
8510 if (result) { Py_DECREF(result); }
9269 if (result) { Py_DECREF(result); }
8511 Py_DECREF(obj);
9270 Py_DECREF(obj);
8512 return returnValue;
9271 return returnValue;
8513 }
9272 } else {
8514 }
9273 PyErr_Clear();
8515 return srecFile::toBinary(File);
9274 }
8516 }
9275 }
8517 bool PythonQtShell_srecFile::toSrec(const QString& File)
9276 return srecFile::toBinary(File0);
8518 {
9277 }
8519 if (_wrapper) {
9278 bool PythonQtShell_srecFile::toSrec(const QString& File0)
8520 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
9279 {
8521 PyErr_Clear();
9280 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8522 if (obj && !PythonQtSlotFunction_Check(obj)) {
9281 static PyObject* name = PyString_FromString("toSrec");
9282 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9283 if (obj) {
8523 static const char* argumentList[] ={"bool" , "const QString&"};
9284 static const char* argumentList[] ={"bool" , "const QString&"};
8524 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9285 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8525 bool returnValue;
9286 bool returnValue;
8526 void* args[2] = {NULL, (void*)&File};
9287 void* args[2] = {NULL, (void*)&File0};
8527 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9288 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8528 if (result) {
9289 if (result) {
8529 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9290 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8530 if (args[0]!=&returnValue) {
9291 if (args[0]!=&returnValue) {
8531 if (args[0]==NULL) {
9292 if (args[0]==NULL) {
8532 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
9293 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
8533 } else {
9294 } else {
8534 returnValue = *((bool*)args[0]);
9295 returnValue = *((bool*)args[0]);
8535 }
9296 }
8536 }
9297 }
8537 }
9298 }
8538 if (result) { Py_DECREF(result); }
9299 if (result) { Py_DECREF(result); }
8539 Py_DECREF(obj);
9300 Py_DECREF(obj);
8540 return returnValue;
9301 return returnValue;
8541 }
9302 } else {
8542 }
9303 PyErr_Clear();
8543 return srecFile::toSrec(File);
9304 }
9305 }
9306 return srecFile::toSrec(File0);
8544 }
9307 }
8545 srecFile* PythonQtWrapper_srecFile::new_srecFile()
9308 srecFile* PythonQtWrapper_srecFile::new_srecFile()
8546 {
9309 {
8547 return new PythonQtShell_srecFile(); }
9310 return new PythonQtShell_srecFile(); }
8548
9311
8549 srecFile* PythonQtWrapper_srecFile::new_srecFile(const QString& File)
9312 srecFile* PythonQtWrapper_srecFile::new_srecFile(const QString& File)
8550 {
9313 {
8551 return new PythonQtShell_srecFile(File); }
9314 return new PythonQtShell_srecFile(File); }
8552
9315
8553 srecFile* PythonQtWrapper_srecFile::new_srecFile(const QStringList& Files)
9316 srecFile* PythonQtWrapper_srecFile::new_srecFile(const QStringList& Files)
8554 {
9317 {
8555 return new PythonQtShell_srecFile(Files); }
9318 return new PythonQtShell_srecFile(Files); }
8556
9319
8557 bool PythonQtWrapper_srecFile::static_srecFile_checkSum(const QString& line)
9320 bool PythonQtWrapper_srecFile::static_srecFile_checkSum(const QString& line)
8558 {
9321 {
8559 return (srecFile::checkSum(line));
9322 return (srecFile::checkSum(line));
8560 }
9323 }
8561
9324
8562 int PythonQtWrapper_srecFile::closeFile(srecFile* theWrappedObject)
9325 int PythonQtWrapper_srecFile::closeFile(srecFile* theWrappedObject)
8563 {
9326 {
8564 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_closeFile());
9327 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_closeFile());
8565 }
9328 }
8566
9329
8567 codeFragment* PythonQtWrapper_srecFile::getFragment(srecFile* theWrappedObject, int index)
9330 codeFragment* PythonQtWrapper_srecFile::getFragment(srecFile* theWrappedObject, int index)
8568 {
9331 {
8569 return ( theWrappedObject->getFragment(index));
9332 return ( theWrappedObject->getFragment(index));
8570 }
9333 }
8571
9334
8572 int PythonQtWrapper_srecFile::getFragmentAddress(srecFile* theWrappedObject, int index)
9335 int PythonQtWrapper_srecFile::getFragmentAddress(srecFile* theWrappedObject, int index)
8573 {
9336 {
8574 return ( theWrappedObject->getFragmentAddress(index));
9337 return ( theWrappedObject->getFragmentAddress(index));
8575 }
9338 }
8576
9339
8577 bool PythonQtWrapper_srecFile::getFragmentData(srecFile* theWrappedObject, int index, char** buffer)
9340 bool PythonQtWrapper_srecFile::getFragmentData(srecFile* theWrappedObject, int index, char** buffer)
8578 {
9341 {
8579 return ( theWrappedObject->getFragmentData(index, buffer));
9342 return ( theWrappedObject->getFragmentData(index, buffer));
8580 }
9343 }
8581
9344
8582 QString PythonQtWrapper_srecFile::getFragmentHeader(srecFile* theWrappedObject, int index)
9345 QString PythonQtWrapper_srecFile::getFragmentHeader(srecFile* theWrappedObject, int index)
8583 {
9346 {
8584 return ( theWrappedObject->getFragmentHeader(index));
9347 return ( theWrappedObject->getFragmentHeader(index));
8585 }
9348 }
8586
9349
8587 int PythonQtWrapper_srecFile::getFragmentSize(srecFile* theWrappedObject, int index)
9350 int PythonQtWrapper_srecFile::getFragmentSize(srecFile* theWrappedObject, int index)
8588 {
9351 {
8589 return ( theWrappedObject->getFragmentSize(index));
9352 return ( theWrappedObject->getFragmentSize(index));
8590 }
9353 }
8591
9354
8592 QList<codeFragment* > PythonQtWrapper_srecFile::getFragments(srecFile* theWrappedObject)
9355 QList<codeFragment* > PythonQtWrapper_srecFile::getFragments(srecFile* theWrappedObject)
8593 {
9356 {
8594 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_getFragments());
9357 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_getFragments());
8595 }
9358 }
8596
9359
8597 int PythonQtWrapper_srecFile::getFragmentsCount(srecFile* theWrappedObject)
9360 int PythonQtWrapper_srecFile::getFragmentsCount(srecFile* theWrappedObject)
8598 {
9361 {
8599 return ( theWrappedObject->getFragmentsCount());
9362 return ( theWrappedObject->getFragmentsCount());
8600 }
9363 }
8601
9364
8602 bool PythonQtWrapper_srecFile::isSREC(srecFile* theWrappedObject)
9365 bool PythonQtWrapper_srecFile::isSREC(srecFile* theWrappedObject)
8603 {
9366 {
8604 return ( theWrappedObject->isSREC());
9367 return ( theWrappedObject->isSREC());
8605 }
9368 }
8606
9369
8607 bool PythonQtWrapper_srecFile::static_srecFile_isSREC(const QString& File)
9370 bool PythonQtWrapper_srecFile::static_srecFile_isSREC(const QString& File)
8608 {
9371 {
8609 return (srecFile::isSREC(File));
9372 return (srecFile::isSREC(File));
8610 }
9373 }
8611
9374
8612 bool PythonQtWrapper_srecFile::isopened(srecFile* theWrappedObject)
9375 bool PythonQtWrapper_srecFile::isopened(srecFile* theWrappedObject)
8613 {
9376 {
8614 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_isopened());
9377 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_isopened());
8615 }
9378 }
8616
9379
8617 int PythonQtWrapper_srecFile::lineCount(srecFile* theWrappedObject)
9380 int PythonQtWrapper_srecFile::lineCount(srecFile* theWrappedObject)
8618 {
9381 {
8619 return ( theWrappedObject->lineCount());
9382 return ( theWrappedObject->lineCount());
8620 }
9383 }
8621
9384
8622 bool PythonQtWrapper_srecFile::mergingRecords(srecFile* theWrappedObject)
9385 bool PythonQtWrapper_srecFile::mergingRecords(srecFile* theWrappedObject)
8623 {
9386 {
8624 return ( theWrappedObject->mergingRecords());
9387 return ( theWrappedObject->mergingRecords());
8625 }
9388 }
8626
9389
8627 bool PythonQtWrapper_srecFile::openFile(srecFile* theWrappedObject, const QString& File)
9390 bool PythonQtWrapper_srecFile::openFile(srecFile* theWrappedObject, const QString& File)
8628 {
9391 {
8629 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_openFile(File));
9392 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_openFile(File));
8630 }
9393 }
8631
9394
8632 bool PythonQtWrapper_srecFile::openFiles(srecFile* theWrappedObject, const QStringList& Files)
9395 bool PythonQtWrapper_srecFile::openFiles(srecFile* theWrappedObject, const QStringList& Files)
8633 {
9396 {
8634 return ( theWrappedObject->openFiles(Files));
9397 return ( theWrappedObject->openFiles(Files));
8635 }
9398 }
8636
9399
8637 void PythonQtWrapper_srecFile::setMergingRecords(srecFile* theWrappedObject, bool enabled)
9400 void PythonQtWrapper_srecFile::setMergingRecords(srecFile* theWrappedObject, bool enabled)
8638 {
9401 {
8639 ( theWrappedObject->setMergingRecords(enabled));
9402 ( theWrappedObject->setMergingRecords(enabled));
8640 }
9403 }
8641
9404
8642 bool PythonQtWrapper_srecFile::toBinary(srecFile* theWrappedObject, const QString& File)
9405 bool PythonQtWrapper_srecFile::toBinary(srecFile* theWrappedObject, const QString& File)
8643 {
9406 {
8644 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_toBinary(File));
9407 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_toBinary(File));
8645 }
9408 }
8646
9409
8647 bool PythonQtWrapper_srecFile::static_srecFile_toSrec(QList<codeFragment* > fragments, const QString& File)
9410 bool PythonQtWrapper_srecFile::static_srecFile_toSrec(QList<codeFragment* > fragments, const QString& File)
8648 {
9411 {
8649 return (srecFile::toSrec(fragments, File));
9412 return (srecFile::toSrec(fragments, File));
8650 }
9413 }
8651
9414
8652 bool PythonQtWrapper_srecFile::toSrec(srecFile* theWrappedObject, const QString& File)
9415 bool PythonQtWrapper_srecFile::toSrec(srecFile* theWrappedObject, const QString& File)
8653 {
9416 {
8654 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_toSrec(File));
9417 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_toSrec(File));
8655 }
9418 }
8656
9419
8657
9420
8658
9421
8659 PythonQtShell_srecFileWidget::~PythonQtShell_srecFileWidget() {
9422 PythonQtShell_srecFileWidget::~PythonQtShell_srecFileWidget() {
8660 PythonQtPrivate* priv = PythonQt::priv();
9423 PythonQtPrivate* priv = PythonQt::priv();
8661 if (priv) { priv->shellClassDeleted(this); }
9424 if (priv) { priv->shellClassDeleted(this); }
8662 }
9425 }
8663 void PythonQtShell_srecFileWidget::reloadFile()
9426 void PythonQtShell_srecFileWidget::reloadFile()
8664 {
9427 {
8665 if (_wrapper) {
9428 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8666 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
9429 static PyObject* name = PyString_FromString("reloadFile");
8667 PyErr_Clear();
9430 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8668 if (obj && !PythonQtSlotFunction_Check(obj)) {
9431 if (obj) {
8669 static const char* argumentList[] ={""};
9432 static const char* argumentList[] ={""};
8670 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9433 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8671 void* args[1] = {NULL};
9434 void* args[1] = {NULL};
8672 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9435 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8673 if (result) { Py_DECREF(result); }
9436 if (result) { Py_DECREF(result); }
8674 Py_DECREF(obj);
9437 Py_DECREF(obj);
8675 return;
9438 return;
9439 } else {
9440 PyErr_Clear();
8676 }
9441 }
8677 }
9442 }
8678 srecFileWidget::reloadFile();
9443 srecFileWidget::reloadFile();
8679 }
9444 }
8680 void PythonQtShell_srecFileWidget::setFile(abstractBinFile* file)
9445 void PythonQtShell_srecFileWidget::setFile(abstractBinFile* file0)
8681 {
9446 {
8682 if (_wrapper) {
9447 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8683 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
9448 static PyObject* name = PyString_FromString("setFile");
8684 PyErr_Clear();
9449 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8685 if (obj && !PythonQtSlotFunction_Check(obj)) {
9450 if (obj) {
8686 static const char* argumentList[] ={"" , "abstractBinFile*"};
9451 static const char* argumentList[] ={"" , "abstractBinFile*"};
8687 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9452 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8688 void* args[2] = {NULL, (void*)&file};
9453 void* args[2] = {NULL, (void*)&file0};
8689 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9454 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8690 if (result) { Py_DECREF(result); }
9455 if (result) { Py_DECREF(result); }
8691 Py_DECREF(obj);
9456 Py_DECREF(obj);
8692 return;
9457 return;
8693 }
9458 } else {
8694 }
9459 PyErr_Clear();
8695 srecFileWidget::setFile(file);
9460 }
9461 }
9462 srecFileWidget::setFile(file0);
8696 }
9463 }
8697 srecFileWidget* PythonQtWrapper_srecFileWidget::new_srecFileWidget(QWidget* parent)
9464 srecFileWidget* PythonQtWrapper_srecFileWidget::new_srecFileWidget(QWidget* parent)
8698 {
9465 {
8699 return new PythonQtShell_srecFileWidget(parent); }
9466 return new PythonQtShell_srecFileWidget(parent); }
8700
9467
8701 void PythonQtWrapper_srecFileWidget::reloadFile(srecFileWidget* theWrappedObject)
9468 void PythonQtWrapper_srecFileWidget::reloadFile(srecFileWidget* theWrappedObject)
8702 {
9469 {
8703 ( ((PythonQtPublicPromoter_srecFileWidget*)theWrappedObject)->promoted_reloadFile());
9470 ( ((PythonQtPublicPromoter_srecFileWidget*)theWrappedObject)->promoted_reloadFile());
8704 }
9471 }
8705
9472
8706 void PythonQtWrapper_srecFileWidget::setFile(srecFileWidget* theWrappedObject, abstractBinFile* file)
9473 void PythonQtWrapper_srecFileWidget::setFile(srecFileWidget* theWrappedObject, abstractBinFile* file)
8707 {
9474 {
8708 ( ((PythonQtPublicPromoter_srecFileWidget*)theWrappedObject)->promoted_setFile(file));
9475 ( ((PythonQtPublicPromoter_srecFileWidget*)theWrappedObject)->promoted_setFile(file));
8709 }
9476 }
8710
9477
8711
9478
Show file before | Show file after | Hide comments
@@ -1,1090 +1,1121
1 #include <PythonQt.h>
1 #include <PythonQt.h>
2 #include <QIconEngine>
3 #include <QObject>
2 #include <QObject>
4 #include <QVariant>
3 #include <QVariant>
5 #include <SocExplorerPlot.h>
4 #include <SocExplorerPlot.h>
6 #include <abstractbinfile.h>
5 #include <abstractbinfile.h>
7 #include <binaryfile.h>
6 #include <binaryfile.h>
8 #include <binaryfilewidget.h>
7 #include <binaryfilewidget.h>
9 #include <elffile.h>
8 #include <elffile.h>
10 #include <elffilewidget.h>
9 #include <elffilewidget.h>
11 #include <elfinfowdgt.h>
10 #include <elfinfowdgt.h>
12 #include <elfparser.h>
11 #include <elfparser.h>
13 #include <genericbinaryfilewidget.h>
12 #include <genericbinaryfilewidget.h>
14 #include <memsizewdgt.h>
13 #include <memsizewdgt.h>
15 #include <qaction.h>
14 #include <qaction.h>
15 #include <qbackingstore.h>
16 #include <qbitmap.h>
16 #include <qbitmap.h>
17 #include <qbytearray.h>
17 #include <qbytearray.h>
18 #include <qcolor.h>
18 #include <qcolor.h>
19 #include <qcoreevent.h>
19 #include <qcoreevent.h>
20 #include <qcursor.h>
20 #include <qcursor.h>
21 #include <qevent.h>
21 #include <qevent.h>
22 #include <qfile.h>
22 #include <qfile.h>
23 #include <qfont.h>
23 #include <qfont.h>
24 #include <qgraphicseffect.h>
24 #include <qgraphicseffect.h>
25 #include <qgraphicsproxywidget.h>
25 #include <qgraphicsproxywidget.h>
26 #include <qhexedit.h>
26 #include <qhexedit.h>
27 #include <qhexspinbox.h>
27 #include <qhexspinbox.h>
28 #include <qicon.h>
28 #include <qkeysequence.h>
29 #include <qkeysequence.h>
29 #include <qlayout.h>
30 #include <qlayout.h>
30 #include <qlineedit.h>
31 #include <qlineedit.h>
31 #include <qlist.h>
32 #include <qlist.h>
32 #include <qlocale.h>
33 #include <qlocale.h>
33 #include <qmargins.h>
34 #include <qmargins.h>
35 #include <qmetaobject.h>
34 #include <qobject.h>
36 #include <qobject.h>
35 #include <qpaintdevice.h>
37 #include <qpaintdevice.h>
36 #include <qpaintengine.h>
38 #include <qpaintengine.h>
37 #include <qpainter.h>
39 #include <qpainter.h>
38 #include <qpalette.h>
40 #include <qpalette.h>
39 #include <qpen.h>
41 #include <qpen.h>
40 #include <qpixmap.h>
42 #include <qpixmap.h>
41 #include <qpoint.h>
43 #include <qpoint.h>
42 #include <qrect.h>
44 #include <qrect.h>
43 #include <qregion.h>
45 #include <qregion.h>
44 #include <qscrollarea.h>
46 #include <qscrollarea.h>
45 #include <qscrollbar.h>
47 #include <qscrollbar.h>
46 #include <qsize.h>
48 #include <qsize.h>
47 #include <qsizepolicy.h>
49 #include <qsizepolicy.h>
48 #include <qspinbox.h>
50 #include <qspinbox.h>
49 #include <qstringlist.h>
51 #include <qstringlist.h>
50 #include <qstyle.h>
52 #include <qstyle.h>
51 #include <qstyleoption.h>
53 #include <qstyleoption.h>
52 #include <qwidget.h>
54 #include <qwidget.h>
55 #include <qwindow.h>
53 #include <srecfile.h>
56 #include <srecfile.h>
54 #include <srecfilewidget.h>
57 #include <srecfilewidget.h>
55 #include <tcp_terminal_client.h>
58 #include <tcp_terminal_client.h>
56 #include <xbytearray.h>
59 #include <xbytearray.h>
57
60
58
61
59
62
60 class PythonQtShell_ElfFile : public ElfFile
63 class PythonQtShell_ElfFile : public ElfFile
61 {
64 {
62 public:
65 public:
63 PythonQtShell_ElfFile():ElfFile(),_wrapper(NULL) {};
66 PythonQtShell_ElfFile():ElfFile(),_wrapper(NULL) { };
64 PythonQtShell_ElfFile(const QString& File):ElfFile(File),_wrapper(NULL) {};
67 PythonQtShell_ElfFile(const QString& File):ElfFile(File),_wrapper(NULL) { };
65
68
66 ~PythonQtShell_ElfFile();
69 ~PythonQtShell_ElfFile();
67
70
68 virtual int closeFile();
71 virtual int closeFile();
69 virtual QList<codeFragment* > getFragments();
72 virtual QList<codeFragment* > getFragments();
70 virtual bool isopened();
73 virtual bool isopened();
71 virtual bool openFile(const QString& File);
74 virtual bool openFile(const QString& File);
72 virtual bool toBinary(const QString& File);
75 virtual bool toBinary(const QString& File);
73 virtual bool toSrec(const QString& File);
76 virtual bool toSrec(const QString& File);
74
77
75 PythonQtInstanceWrapper* _wrapper;
78 PythonQtInstanceWrapper* _wrapper;
76 };
79 };
77
80
78 class PythonQtPublicPromoter_ElfFile : public ElfFile
81 class PythonQtPublicPromoter_ElfFile : public ElfFile
79 { public:
82 { public:
80 inline int promoted_closeFile() { return ElfFile::closeFile(); }
83 inline int promoted_closeFile() { return ElfFile::closeFile(); }
81 inline QList<codeFragment* > promoted_getFragments() { return ElfFile::getFragments(); }
84 inline QList<codeFragment* > promoted_getFragments() { return ElfFile::getFragments(); }
82 inline bool promoted_isopened() { return ElfFile::isopened(); }
85 inline bool promoted_isopened() { return ElfFile::isopened(); }
83 inline bool promoted_openFile(const QString& File) { return ElfFile::openFile(File); }
86 inline bool promoted_openFile(const QString& File) { return ElfFile::openFile(File); }
84 inline bool promoted_toBinary(const QString& File) { return ElfFile::toBinary(File); }
87 inline bool promoted_toBinary(const QString& File) { return ElfFile::toBinary(File); }
85 inline bool promoted_toSrec(const QString& File) { return ElfFile::toSrec(File); }
88 inline bool promoted_toSrec(const QString& File) { return ElfFile::toSrec(File); }
86 };
89 };
87
90
88 class PythonQtWrapper_ElfFile : public QObject
91 class PythonQtWrapper_ElfFile : public QObject
89 { Q_OBJECT
92 { Q_OBJECT
90 public:
93 public:
91 public slots:
94 public slots:
92 ElfFile* new_ElfFile();
95 ElfFile* new_ElfFile();
93 ElfFile* new_ElfFile(const QString& File);
96 ElfFile* new_ElfFile(const QString& File);
94 void delete_ElfFile(ElfFile* obj) { delete obj; }
97 void delete_ElfFile(ElfFile* obj) { delete obj; }
95 int closeFile(ElfFile* theWrappedObject);
98 int closeFile(ElfFile* theWrappedObject);
96 QString getABI(ElfFile* theWrappedObject);
99 QString getABI(ElfFile* theWrappedObject);
97 QString getArchitecture(ElfFile* theWrappedObject);
100 QString getArchitecture(ElfFile* theWrappedObject);
98 QString getClass(ElfFile* theWrappedObject);
101 QString getClass(ElfFile* theWrappedObject);
99 QString getEndianness(ElfFile* theWrappedObject);
102 QString getEndianness(ElfFile* theWrappedObject);
100 qint64 getEntryPointAddress(ElfFile* theWrappedObject);
103 qint64 getEntryPointAddress(ElfFile* theWrappedObject);
101 QList<codeFragment* > getFragments(ElfFile* theWrappedObject);
104 QList<codeFragment* > getFragments(ElfFile* theWrappedObject);
102 QList<codeFragment* > getFragments(ElfFile* theWrappedObject, QStringList fragmentList);
105 QList<codeFragment* > getFragments(ElfFile* theWrappedObject, QStringList fragmentList);
103 int getSectionCount(ElfFile* theWrappedObject);
106 int getSectionCount(ElfFile* theWrappedObject);
104 bool getSectionData(ElfFile* theWrappedObject, int index, char** buffer);
107 bool getSectionData(ElfFile* theWrappedObject, int index, char** buffer);
105 qint64 getSectionDatasz(ElfFile* theWrappedObject, int index);
108 qint64 getSectionDatasz(ElfFile* theWrappedObject, int index);
106 int getSectionIndex(ElfFile* theWrappedObject, QString name);
109 int getSectionIndex(ElfFile* theWrappedObject, QString name);
107 qint64 getSectionMemsz(ElfFile* theWrappedObject, int index);
110 qint64 getSectionMemsz(ElfFile* theWrappedObject, int index);
108 QString getSectionName(ElfFile* theWrappedObject, int index);
111 QString getSectionName(ElfFile* theWrappedObject, int index);
109 qint64 getSectionPaddr(ElfFile* theWrappedObject, int index);
112 qint64 getSectionPaddr(ElfFile* theWrappedObject, int index);
110 QString getSectionType(ElfFile* theWrappedObject, int index);
113 QString getSectionType(ElfFile* theWrappedObject, int index);
111 int getSegmentCount(ElfFile* theWrappedObject);
114 int getSegmentCount(ElfFile* theWrappedObject);
112 qint64 getSegmentFilesz(ElfFile* theWrappedObject, int index);
115 qint64 getSegmentFilesz(ElfFile* theWrappedObject, int index);
113 QString getSegmentFlags(ElfFile* theWrappedObject, int index);
116 QString getSegmentFlags(ElfFile* theWrappedObject, int index);
114 qint64 getSegmentMemsz(ElfFile* theWrappedObject, int index);
117 qint64 getSegmentMemsz(ElfFile* theWrappedObject, int index);
115 qint64 getSegmentOffset(ElfFile* theWrappedObject, int index);
118 qint64 getSegmentOffset(ElfFile* theWrappedObject, int index);
116 qint64 getSegmentPaddr(ElfFile* theWrappedObject, int index);
119 qint64 getSegmentPaddr(ElfFile* theWrappedObject, int index);
117 QString getSegmentType(ElfFile* theWrappedObject, int index);
120 QString getSegmentType(ElfFile* theWrappedObject, int index);
118 qint64 getSegmentVaddr(ElfFile* theWrappedObject, int index);
121 qint64 getSegmentVaddr(ElfFile* theWrappedObject, int index);
119 quint64 getSymbolAddress(ElfFile* theWrappedObject, int index);
122 quint64 getSymbolAddress(ElfFile* theWrappedObject, int index);
120 int getSymbolCount(ElfFile* theWrappedObject);
123 int getSymbolCount(ElfFile* theWrappedObject);
121 QString getSymbolLinkType(ElfFile* theWrappedObject, int index);
124 QString getSymbolLinkType(ElfFile* theWrappedObject, int index);
122 QString getSymbolName(ElfFile* theWrappedObject, int index);
125 QString getSymbolName(ElfFile* theWrappedObject, int index);
123 int getSymbolSectionIndex(ElfFile* theWrappedObject, int index);
126 int getSymbolSectionIndex(ElfFile* theWrappedObject, int index);
124 QString getSymbolSectionName(ElfFile* theWrappedObject, int index);
127 QString getSymbolSectionName(ElfFile* theWrappedObject, int index);
125 quint64 getSymbolSize(ElfFile* theWrappedObject, int index);
128 quint64 getSymbolSize(ElfFile* theWrappedObject, int index);
126 QString getSymbolType(ElfFile* theWrappedObject, int index);
129 QString getSymbolType(ElfFile* theWrappedObject, int index);
127 QString getType(ElfFile* theWrappedObject);
130 QString getType(ElfFile* theWrappedObject);
128 qint64 getVersion(ElfFile* theWrappedObject);
131 qint64 getVersion(ElfFile* theWrappedObject);
132 bool isBigEndian(ElfFile* theWrappedObject);
129 bool static_ElfFile_isElf(const QString& File);
133 bool static_ElfFile_isElf(const QString& File);
134 bool isLitleEndian(ElfFile* theWrappedObject);
130 bool iself(ElfFile* theWrappedObject);
135 bool iself(ElfFile* theWrappedObject);
131 bool isopened(ElfFile* theWrappedObject);
136 bool isopened(ElfFile* theWrappedObject);
132 bool openFile(ElfFile* theWrappedObject, const QString& File);
137 bool openFile(ElfFile* theWrappedObject, const QString& File);
133 bool sectionIsNobits(ElfFile* theWrappedObject, int index);
138 bool sectionIsNobits(ElfFile* theWrappedObject, int index);
134 bool toBinary(ElfFile* theWrappedObject, const QString& File);
139 bool toBinary(ElfFile* theWrappedObject, const QString& File);
135 bool toSrec(ElfFile* theWrappedObject, const QString& File);
140 bool toSrec(ElfFile* theWrappedObject, const QString& File);
136 };
141 };
137
142
138
143
139
144
140
145
141
146
142 class PythonQtShell_MemSizeWdgt : public MemSizeWdgt
147 class PythonQtShell_MemSizeWdgt : public MemSizeWdgt
143 {
148 {
144 public:
149 public:
145 PythonQtShell_MemSizeWdgt(QWidget* parent = 0):MemSizeWdgt(parent),_wrapper(NULL) {};
150 PythonQtShell_MemSizeWdgt(QWidget* parent = 0):MemSizeWdgt(parent),_wrapper(NULL) { };
146 PythonQtShell_MemSizeWdgt(int defaultSize, QWidget* parent = 0):MemSizeWdgt(defaultSize, parent),_wrapper(NULL) {};
151 PythonQtShell_MemSizeWdgt(int defaultSize, QWidget* parent = 0):MemSizeWdgt(defaultSize, parent),_wrapper(NULL) { };
147
152
148 ~PythonQtShell_MemSizeWdgt();
153 ~PythonQtShell_MemSizeWdgt();
149
154
150 virtual void actionEvent(QActionEvent* arg__1);
155 virtual void actionEvent(QActionEvent* arg__1);
151 virtual void changeEvent(QEvent* arg__1);
156 virtual void changeEvent(QEvent* arg__1);
152 virtual void childEvent(QChildEvent* arg__1);
157 virtual void childEvent(QChildEvent* arg__1);
153 virtual void closeEvent(QCloseEvent* arg__1);
158 virtual void closeEvent(QCloseEvent* arg__1);
154 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
159 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
155 virtual void customEvent(QEvent* arg__1);
160 virtual void customEvent(QEvent* arg__1);
156 virtual int devType() const;
161 virtual int devType() const;
157 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
162 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
158 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
163 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
159 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
164 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
160 virtual void dropEvent(QDropEvent* arg__1);
165 virtual void dropEvent(QDropEvent* arg__1);
161 virtual void enterEvent(QEvent* arg__1);
166 virtual void enterEvent(QEvent* arg__1);
162 virtual bool event(QEvent* arg__1);
167 virtual bool event(QEvent* arg__1);
163 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
168 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
164 virtual void focusInEvent(QFocusEvent* arg__1);
169 virtual void focusInEvent(QFocusEvent* arg__1);
165 virtual bool focusNextPrevChild(bool next);
170 virtual bool focusNextPrevChild(bool next);
166 virtual void focusOutEvent(QFocusEvent* arg__1);
171 virtual void focusOutEvent(QFocusEvent* arg__1);
167 virtual bool hasHeightForWidth() const;
172 virtual bool hasHeightForWidth() const;
168 virtual int heightForWidth(int arg__1) const;
173 virtual int heightForWidth(int arg__1) const;
169 virtual void hideEvent(QHideEvent* arg__1);
174 virtual void hideEvent(QHideEvent* arg__1);
170 virtual void initPainter(QPainter* painter) const;
175 virtual void initPainter(QPainter* painter) const;
171 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
176 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
172 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
177 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
173 virtual void keyPressEvent(QKeyEvent* arg__1);
178 virtual void keyPressEvent(QKeyEvent* arg__1);
174 virtual void keyReleaseEvent(QKeyEvent* arg__1);
179 virtual void keyReleaseEvent(QKeyEvent* arg__1);
175 virtual void leaveEvent(QEvent* arg__1);
180 virtual void leaveEvent(QEvent* arg__1);
176 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
181 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
177 virtual QSize minimumSizeHint() const;
182 virtual QSize minimumSizeHint() const;
178 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
183 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
179 virtual void mouseMoveEvent(QMouseEvent* arg__1);
184 virtual void mouseMoveEvent(QMouseEvent* arg__1);
180 virtual void mousePressEvent(QMouseEvent* arg__1);
185 virtual void mousePressEvent(QMouseEvent* arg__1);
181 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
186 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
182 virtual void moveEvent(QMoveEvent* arg__1);
187 virtual void moveEvent(QMoveEvent* arg__1);
183 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
188 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
184 virtual QPaintEngine* paintEngine() const;
189 virtual QPaintEngine* paintEngine() const;
185 virtual void paintEvent(QPaintEvent* arg__1);
190 virtual void paintEvent(QPaintEvent* arg__1);
186 virtual QPaintDevice* redirected(QPoint* offset) const;
191 virtual QPaintDevice* redirected(QPoint* offset) const;
187 virtual void resizeEvent(QResizeEvent* arg__1);
192 virtual void resizeEvent(QResizeEvent* arg__1);
188 virtual QPainter* sharedPainter() const;
193 virtual QPainter* sharedPainter() const;
189 virtual void showEvent(QShowEvent* arg__1);
194 virtual void showEvent(QShowEvent* arg__1);
190 virtual QSize sizeHint() const;
195 virtual QSize sizeHint() const;
191 virtual void tabletEvent(QTabletEvent* arg__1);
196 virtual void tabletEvent(QTabletEvent* arg__1);
192 virtual void timerEvent(QTimerEvent* arg__1);
197 virtual void timerEvent(QTimerEvent* arg__1);
193 virtual void wheelEvent(QWheelEvent* arg__1);
198 virtual void wheelEvent(QWheelEvent* arg__1);
194
199
195 PythonQtInstanceWrapper* _wrapper;
200 PythonQtInstanceWrapper* _wrapper;
196 };
201 };
197
202
198 class PythonQtWrapper_MemSizeWdgt : public QObject
203 class PythonQtWrapper_MemSizeWdgt : public QObject
199 { Q_OBJECT
204 { Q_OBJECT
200 public:
205 public:
201 public slots:
206 public slots:
202 MemSizeWdgt* new_MemSizeWdgt(QWidget* parent = 0);
207 MemSizeWdgt* new_MemSizeWdgt(QWidget* parent = 0);
203 MemSizeWdgt* new_MemSizeWdgt(int defaultSize, QWidget* parent = 0);
208 MemSizeWdgt* new_MemSizeWdgt(int defaultSize, QWidget* parent = 0);
204 void delete_MemSizeWdgt(MemSizeWdgt* obj) { delete obj; }
209 void delete_MemSizeWdgt(MemSizeWdgt* obj) { delete obj; }
205 int getsize(MemSizeWdgt* theWrappedObject);
210 int getsize(MemSizeWdgt* theWrappedObject);
206 void setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max);
211 void setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max);
207 void show(MemSizeWdgt* theWrappedObject);
212 void show(MemSizeWdgt* theWrappedObject);
208 void updateSizeValue(MemSizeWdgt* theWrappedObject);
213 void updateSizeValue(MemSizeWdgt* theWrappedObject);
209 };
214 };
210
215
211
216
212
217
213
218
214
219
215 class PythonQtShell_QHexEdit : public QHexEdit
220 class PythonQtShell_QHexEdit : public QHexEdit
216 {
221 {
217 public:
222 public:
218 PythonQtShell_QHexEdit(QWidget* parent = 0):QHexEdit(parent),_wrapper(NULL) {};
223 PythonQtShell_QHexEdit(QWidget* parent = 0):QHexEdit(parent),_wrapper(NULL) { };
219
224
220 ~PythonQtShell_QHexEdit();
225 ~PythonQtShell_QHexEdit();
221
226
222 virtual void actionEvent(QActionEvent* arg__1);
227 virtual void actionEvent(QActionEvent* arg__1);
223 virtual void changeEvent(QEvent* arg__1);
228 virtual void changeEvent(QEvent* arg__1);
224 virtual void childEvent(QChildEvent* arg__1);
229 virtual void childEvent(QChildEvent* arg__1);
225 virtual void closeEvent(QCloseEvent* arg__1);
230 virtual void closeEvent(QCloseEvent* arg__1);
226 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
231 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
227 virtual void customEvent(QEvent* arg__1);
232 virtual void customEvent(QEvent* arg__1);
228 virtual int devType() const;
233 virtual int devType() const;
229 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
234 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
230 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
235 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
231 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
236 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
232 virtual void dropEvent(QDropEvent* arg__1);
237 virtual void dropEvent(QDropEvent* arg__1);
233 virtual void enterEvent(QEvent* arg__1);
238 virtual void enterEvent(QEvent* arg__1);
234 virtual bool event(QEvent* arg__1);
239 virtual bool event(QEvent* arg__1);
235 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
240 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
236 virtual void focusInEvent(QFocusEvent* arg__1);
241 virtual void focusInEvent(QFocusEvent* arg__1);
237 virtual bool focusNextPrevChild(bool next);
242 virtual bool focusNextPrevChild(bool next);
238 virtual void focusOutEvent(QFocusEvent* arg__1);
243 virtual void focusOutEvent(QFocusEvent* arg__1);
239 virtual bool hasHeightForWidth() const;
244 virtual bool hasHeightForWidth() const;
240 virtual int heightForWidth(int arg__1) const;
245 virtual int heightForWidth(int arg__1) const;
241 virtual void hideEvent(QHideEvent* arg__1);
246 virtual void hideEvent(QHideEvent* arg__1);
242 virtual void initPainter(QPainter* painter) const;
247 virtual void initPainter(QPainter* painter) const;
243 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
248 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
244 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
249 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
245 virtual void keyPressEvent(QKeyEvent* arg__1);
250 virtual void keyPressEvent(QKeyEvent* arg__1);
246 virtual void keyReleaseEvent(QKeyEvent* arg__1);
251 virtual void keyReleaseEvent(QKeyEvent* arg__1);
247 virtual void leaveEvent(QEvent* arg__1);
252 virtual void leaveEvent(QEvent* arg__1);
248 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
253 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
249 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
254 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
250 virtual void mouseMoveEvent(QMouseEvent* arg__1);
255 virtual void mouseMoveEvent(QMouseEvent* arg__1);
251 virtual void mousePressEvent(QMouseEvent* arg__1);
256 virtual void mousePressEvent(QMouseEvent* arg__1);
252 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
257 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
253 virtual void moveEvent(QMoveEvent* arg__1);
258 virtual void moveEvent(QMoveEvent* arg__1);
254 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
259 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
255 virtual QPaintEngine* paintEngine() const;
260 virtual QPaintEngine* paintEngine() const;
256 virtual void paintEvent(QPaintEvent* arg__1);
261 virtual void paintEvent(QPaintEvent* arg__1);
257 virtual QPaintDevice* redirected(QPoint* offset) const;
262 virtual QPaintDevice* redirected(QPoint* offset) const;
258 virtual void resizeEvent(QResizeEvent* arg__1);
263 virtual void resizeEvent(QResizeEvent* arg__1);
259 virtual void scrollContentsBy(int dx, int dy);
264 virtual void scrollContentsBy(int dx, int dy);
260 virtual void setupViewport(QWidget* viewport);
265 virtual void setupViewport(QWidget* viewport);
261 virtual QPainter* sharedPainter() const;
266 virtual QPainter* sharedPainter() const;
262 virtual void showEvent(QShowEvent* arg__1);
267 virtual void showEvent(QShowEvent* arg__1);
263 virtual void tabletEvent(QTabletEvent* arg__1);
268 virtual void tabletEvent(QTabletEvent* arg__1);
264 virtual void timerEvent(QTimerEvent* arg__1);
269 virtual void timerEvent(QTimerEvent* arg__1);
265 virtual bool viewportEvent(QEvent* arg__1);
270 virtual bool viewportEvent(QEvent* arg__1);
266 virtual QSize viewportSizeHint() const;
271 virtual QSize viewportSizeHint() const;
267 virtual void wheelEvent(QWheelEvent* arg__1);
272 virtual void wheelEvent(QWheelEvent* arg__1);
268
273
269 PythonQtInstanceWrapper* _wrapper;
274 PythonQtInstanceWrapper* _wrapper;
270 };
275 };
271
276
272 class PythonQtWrapper_QHexEdit : public QObject
277 class PythonQtWrapper_QHexEdit : public QObject
273 { Q_OBJECT
278 { Q_OBJECT
274 public:
279 public:
275 public slots:
280 public slots:
276 QHexEdit* new_QHexEdit(QWidget* parent = 0);
281 QHexEdit* new_QHexEdit(QWidget* parent = 0);
277 void delete_QHexEdit(QHexEdit* obj) { delete obj; }
282 void delete_QHexEdit(QHexEdit* obj) { delete obj; }
278 QColor addressAreaColor(QHexEdit* theWrappedObject);
283 QColor addressAreaColor(QHexEdit* theWrappedObject);
279 int addressOffset(QHexEdit* theWrappedObject);
284 int addressOffset(QHexEdit* theWrappedObject);
280 int cursorPosition(QHexEdit* theWrappedObject);
285 int cursorPosition(QHexEdit* theWrappedObject);
281 QByteArray data(QHexEdit* theWrappedObject);
286 QByteArray data(QHexEdit* theWrappedObject);
282 const QFont* font(QHexEdit* theWrappedObject) const;
287 const QFont* font(QHexEdit* theWrappedObject) const;
283 int getSelectionBegin(QHexEdit* theWrappedObject);
288 int getSelectionBegin(QHexEdit* theWrappedObject);
284 int getSelectionEnd(QHexEdit* theWrappedObject);
289 int getSelectionEnd(QHexEdit* theWrappedObject);
285 QColor highlightingColor(QHexEdit* theWrappedObject);
290 QColor highlightingColor(QHexEdit* theWrappedObject);
286 int indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
291 int indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
287 void insert(QHexEdit* theWrappedObject, int i, char ch);
292 void insert(QHexEdit* theWrappedObject, int i, char ch);
288 void insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba);
293 void insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba);
289 bool isReadOnly(QHexEdit* theWrappedObject);
294 bool isReadOnly(QHexEdit* theWrappedObject);
290 int lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
295 int lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
291 bool overwriteMode(QHexEdit* theWrappedObject);
296 bool overwriteMode(QHexEdit* theWrappedObject);
292 void remove(QHexEdit* theWrappedObject, int pos, int len = 1);
297 void remove(QHexEdit* theWrappedObject, int pos, int len = 1);
293 void replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after);
298 void replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after);
294 void resetSelection(QHexEdit* theWrappedObject);
299 void resetSelection(QHexEdit* theWrappedObject);
295 void resetSelection(QHexEdit* theWrappedObject, int pos);
300 void resetSelection(QHexEdit* theWrappedObject, int pos);
296 QColor selectionColor(QHexEdit* theWrappedObject);
301 QColor selectionColor(QHexEdit* theWrappedObject);
297 QString selectionToReadableString(QHexEdit* theWrappedObject);
302 QString selectionToReadableString(QHexEdit* theWrappedObject);
298 void setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color);
303 void setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color);
299 void setAddressOffset(QHexEdit* theWrappedObject, int offset);
304 void setAddressOffset(QHexEdit* theWrappedObject, int offset);
300 void setCursorPosition(QHexEdit* theWrappedObject, int cusorPos);
305 void setCursorPosition(QHexEdit* theWrappedObject, int cusorPos);
301 void setData(QHexEdit* theWrappedObject, const QByteArray& data);
306 void setData(QHexEdit* theWrappedObject, const QByteArray& data);
302 void setFont(QHexEdit* theWrappedObject, const QFont& arg__1);
307 void setFont(QHexEdit* theWrappedObject, const QFont& arg__1);
303 void setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color);
308 void setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color);
304 void setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1);
309 void setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1);
305 void setReadOnly(QHexEdit* theWrappedObject, bool arg__1);
310 void setReadOnly(QHexEdit* theWrappedObject, bool arg__1);
306 void setSelection(QHexEdit* theWrappedObject, int pos);
311 void setSelection(QHexEdit* theWrappedObject, int pos);
307 void setSelectionColor(QHexEdit* theWrappedObject, const QColor& color);
312 void setSelectionColor(QHexEdit* theWrappedObject, const QColor& color);
308 QString toReadableString(QHexEdit* theWrappedObject);
313 QString toReadableString(QHexEdit* theWrappedObject);
309 };
314 };
310
315
311
316
312
317
313
318
314
319
315 class PythonQtShell_QHexSpinBox : public QHexSpinBox
320 class PythonQtShell_QHexSpinBox : public QHexSpinBox
316 {
321 {
317 public:
322 public:
318 PythonQtShell_QHexSpinBox(QWidget* parent = 0):QHexSpinBox(parent),_wrapper(NULL) {};
323 PythonQtShell_QHexSpinBox(QWidget* parent = 0):QHexSpinBox(parent),_wrapper(NULL) { };
319
324
320 ~PythonQtShell_QHexSpinBox();
325 ~PythonQtShell_QHexSpinBox();
321
326
322 virtual void actionEvent(QActionEvent* arg__1);
327 virtual void actionEvent(QActionEvent* arg__1);
323 virtual void changeEvent(QEvent* event);
328 virtual void changeEvent(QEvent* event);
324 virtual void childEvent(QChildEvent* arg__1);
329 virtual void childEvent(QChildEvent* arg__1);
325 virtual void clear();
330 virtual void clear();
326 virtual void closeEvent(QCloseEvent* event);
331 virtual void closeEvent(QCloseEvent* event);
327 virtual void contextMenuEvent(QContextMenuEvent* event);
332 virtual void contextMenuEvent(QContextMenuEvent* event);
328 virtual void customEvent(QEvent* arg__1);
333 virtual void customEvent(QEvent* arg__1);
329 virtual int devType() const;
334 virtual int devType() const;
330 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
335 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
331 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
336 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
332 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
337 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
333 virtual void dropEvent(QDropEvent* arg__1);
338 virtual void dropEvent(QDropEvent* arg__1);
334 virtual void enterEvent(QEvent* arg__1);
339 virtual void enterEvent(QEvent* arg__1);
335 virtual bool event(QEvent* event);
340 virtual bool event(QEvent* event);
336 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
341 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
337 virtual void fixup(QString& str) const;
342 virtual void fixup(QString& str) const;
338 virtual void focusInEvent(QFocusEvent* event);
343 virtual void focusInEvent(QFocusEvent* event);
339 virtual bool focusNextPrevChild(bool next);
344 virtual bool focusNextPrevChild(bool next);
340 virtual void focusOutEvent(QFocusEvent* event);
345 virtual void focusOutEvent(QFocusEvent* event);
341 virtual bool hasHeightForWidth() const;
346 virtual bool hasHeightForWidth() const;
342 virtual int heightForWidth(int arg__1) const;
347 virtual int heightForWidth(int arg__1) const;
343 virtual void hideEvent(QHideEvent* event);
348 virtual void hideEvent(QHideEvent* event);
344 virtual void initPainter(QPainter* painter) const;
349 virtual void initPainter(QPainter* painter) const;
345 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
350 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
346 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
351 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
347 virtual void keyPressEvent(QKeyEvent* event);
352 virtual void keyPressEvent(QKeyEvent* event);
348 virtual void keyReleaseEvent(QKeyEvent* event);
353 virtual void keyReleaseEvent(QKeyEvent* event);
349 virtual void leaveEvent(QEvent* arg__1);
354 virtual void leaveEvent(QEvent* arg__1);
350 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
355 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
351 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
356 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
352 virtual void mouseMoveEvent(QMouseEvent* event);
357 virtual void mouseMoveEvent(QMouseEvent* event);
353 virtual void mousePressEvent(QMouseEvent* event);
358 virtual void mousePressEvent(QMouseEvent* event);
354 virtual void mouseReleaseEvent(QMouseEvent* event);
359 virtual void mouseReleaseEvent(QMouseEvent* event);
355 virtual void moveEvent(QMoveEvent* arg__1);
360 virtual void moveEvent(QMoveEvent* arg__1);
356 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
361 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
357 virtual QPaintEngine* paintEngine() const;
362 virtual QPaintEngine* paintEngine() const;
358 virtual void paintEvent(QPaintEvent* event);
363 virtual void paintEvent(QPaintEvent* event);
359 virtual QPaintDevice* redirected(QPoint* offset) const;
364 virtual QPaintDevice* redirected(QPoint* offset) const;
360 virtual void resizeEvent(QResizeEvent* event);
365 virtual void resizeEvent(QResizeEvent* event);
361 virtual QPainter* sharedPainter() const;
366 virtual QPainter* sharedPainter() const;
362 virtual void showEvent(QShowEvent* event);
367 virtual void showEvent(QShowEvent* event);
363 virtual void stepBy(int steps);
368 virtual void stepBy(int steps);
364 virtual QAbstractSpinBox::StepEnabled stepEnabled() const;
369 virtual QAbstractSpinBox::StepEnabled stepEnabled() const;
365 virtual void tabletEvent(QTabletEvent* arg__1);
370 virtual void tabletEvent(QTabletEvent* arg__1);
366 virtual QString textFromValue(int value) const;
371 virtual QString textFromValue(int value) const;
367 virtual void timerEvent(QTimerEvent* event);
372 virtual void timerEvent(QTimerEvent* event);
368 virtual QValidator::State validate(QString& input, int& pos) const;
373 virtual QValidator::State validate(QString& input, int& pos) const;
369 virtual int valueFromText(const QString& text) const;
374 virtual int valueFromText(const QString& text) const;
370 virtual void wheelEvent(QWheelEvent* event);
375 virtual void wheelEvent(QWheelEvent* event);
371
376
372 PythonQtInstanceWrapper* _wrapper;
377 PythonQtInstanceWrapper* _wrapper;
373 };
378 };
374
379
375 class PythonQtPublicPromoter_QHexSpinBox : public QHexSpinBox
380 class PythonQtPublicPromoter_QHexSpinBox : public QHexSpinBox
376 { public:
381 { public:
377 inline QString promoted_textFromValue(int value) const { return QHexSpinBox::textFromValue(value); }
382 inline QString promoted_textFromValue(int value) const { return QHexSpinBox::textFromValue(value); }
378 inline QValidator::State promoted_validate(QString& input, int& pos) const { return QHexSpinBox::validate(input, pos); }
383 inline QValidator::State promoted_validate(QString& input, int& pos) const { return QHexSpinBox::validate(input, pos); }
379 inline int promoted_valueFromText(const QString& text) const { return QHexSpinBox::valueFromText(text); }
384 inline int promoted_valueFromText(const QString& text) const { return QHexSpinBox::valueFromText(text); }
380 };
385 };
381
386
382 class PythonQtWrapper_QHexSpinBox : public QObject
387 class PythonQtWrapper_QHexSpinBox : public QObject
383 { Q_OBJECT
388 { Q_OBJECT
384 public:
389 public:
385 public slots:
390 public slots:
386 QHexSpinBox* new_QHexSpinBox(QWidget* parent = 0);
391 QHexSpinBox* new_QHexSpinBox(QWidget* parent = 0);
387 void delete_QHexSpinBox(QHexSpinBox* obj) { delete obj; }
392 void delete_QHexSpinBox(QHexSpinBox* obj) { delete obj; }
388 void show(QHexSpinBox* theWrappedObject);
393 void show(QHexSpinBox* theWrappedObject);
389 QString textFromValue(QHexSpinBox* theWrappedObject, int value) const;
394 QString textFromValue(QHexSpinBox* theWrappedObject, int value) const;
390 QValidator::State validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const;
395 QValidator::State validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const;
391 int valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const;
396 int valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const;
392 };
397 };
393
398
394
399
395
400
396
401
397
402
398 class PythonQtShell_SocExplorerPlot : public SocExplorerPlot
403 class PythonQtShell_SocExplorerPlot : public SocExplorerPlot
399 {
404 {
400 public:
405 public:
401 PythonQtShell_SocExplorerPlot(QWidget* parent = 0):SocExplorerPlot(parent),_wrapper(NULL) {};
406 PythonQtShell_SocExplorerPlot(QWidget* parent = 0):SocExplorerPlot(parent),_wrapper(NULL) { };
402
407
403 ~PythonQtShell_SocExplorerPlot();
408 ~PythonQtShell_SocExplorerPlot();
404
409
405 virtual void actionEvent(QActionEvent* arg__1);
410 virtual void actionEvent(QActionEvent* arg__1);
406 virtual void changeEvent(QEvent* arg__1);
411 virtual void changeEvent(QEvent* arg__1);
407 virtual void childEvent(QChildEvent* arg__1);
412 virtual void childEvent(QChildEvent* arg__1);
408 virtual void closeEvent(QCloseEvent* arg__1);
413 virtual void closeEvent(QCloseEvent* arg__1);
409 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
414 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
410 virtual void customEvent(QEvent* arg__1);
415 virtual void customEvent(QEvent* arg__1);
411 virtual int devType() const;
416 virtual int devType() const;
412 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
417 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
413 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
418 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
414 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
419 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
415 virtual void dropEvent(QDropEvent* arg__1);
420 virtual void dropEvent(QDropEvent* arg__1);
416 virtual void enterEvent(QEvent* arg__1);
421 virtual void enterEvent(QEvent* arg__1);
417 virtual bool event(QEvent* arg__1);
422 virtual bool event(QEvent* arg__1);
418 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
423 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
419 virtual void focusInEvent(QFocusEvent* arg__1);
424 virtual void focusInEvent(QFocusEvent* arg__1);
420 virtual bool focusNextPrevChild(bool next);
425 virtual bool focusNextPrevChild(bool next);
421 virtual void focusOutEvent(QFocusEvent* arg__1);
426 virtual void focusOutEvent(QFocusEvent* arg__1);
422 virtual bool hasHeightForWidth() const;
427 virtual bool hasHeightForWidth() const;
423 virtual int heightForWidth(int arg__1) const;
428 virtual int heightForWidth(int arg__1) const;
424 virtual void hideEvent(QHideEvent* arg__1);
429 virtual void hideEvent(QHideEvent* arg__1);
425 virtual void initPainter(QPainter* painter) const;
430 virtual void initPainter(QPainter* painter) const;
426 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
431 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
427 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
432 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
428 virtual void keyPressEvent(QKeyEvent* arg__1);
433 virtual void keyPressEvent(QKeyEvent* arg__1);
429 virtual void keyReleaseEvent(QKeyEvent* arg__1);
434 virtual void keyReleaseEvent(QKeyEvent* arg__1);
430 virtual void leaveEvent(QEvent* arg__1);
435 virtual void leaveEvent(QEvent* arg__1);
431 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
436 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
432 virtual QSize minimumSizeHint() const;
437 virtual QSize minimumSizeHint() const;
433 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
438 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
434 virtual void mouseMoveEvent(QMouseEvent* arg__1);
439 virtual void mouseMoveEvent(QMouseEvent* arg__1);
435 virtual void mousePressEvent(QMouseEvent* arg__1);
440 virtual void mousePressEvent(QMouseEvent* arg__1);
436 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
441 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
437 virtual void moveEvent(QMoveEvent* arg__1);
442 virtual void moveEvent(QMoveEvent* arg__1);
438 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
443 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
439 virtual QPaintEngine* paintEngine() const;
444 virtual QPaintEngine* paintEngine() const;
440 virtual void paintEvent(QPaintEvent* arg__1);
445 virtual void paintEvent(QPaintEvent* arg__1);
441 virtual QPaintDevice* redirected(QPoint* offset) const;
446 virtual QPaintDevice* redirected(QPoint* offset) const;
442 virtual void resizeEvent(QResizeEvent* arg__1);
447 virtual void resizeEvent(QResizeEvent* arg__1);
443 virtual QPainter* sharedPainter() const;
448 virtual QPainter* sharedPainter() const;
444 virtual void showEvent(QShowEvent* arg__1);
449 virtual void showEvent(QShowEvent* arg__1);
445 virtual QSize sizeHint() const;
450 virtual QSize sizeHint() const;
446 virtual void tabletEvent(QTabletEvent* arg__1);
451 virtual void tabletEvent(QTabletEvent* arg__1);
447 virtual void timerEvent(QTimerEvent* arg__1);
452 virtual void timerEvent(QTimerEvent* arg__1);
448 virtual void wheelEvent(QWheelEvent* arg__1);
453 virtual void wheelEvent(QWheelEvent* arg__1);
449
454
450 PythonQtInstanceWrapper* _wrapper;
455 PythonQtInstanceWrapper* _wrapper;
451 };
456 };
452
457
453 class PythonQtPublicPromoter_SocExplorerPlot : public SocExplorerPlot
458 class PythonQtPublicPromoter_SocExplorerPlot : public SocExplorerPlot
454 { public:
459 { public:
455 inline void promoted_keyPressEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyPressEvent(arg__1); }
460 inline void promoted_keyPressEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyPressEvent(arg__1); }
456 inline void promoted_keyReleaseEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyReleaseEvent(arg__1); }
461 inline void promoted_keyReleaseEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyReleaseEvent(arg__1); }
457 inline void promoted_mouseMoveEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseMoveEvent(arg__1); }
462 inline void promoted_mouseMoveEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseMoveEvent(arg__1); }
458 inline void promoted_mousePressEvent(QMouseEvent* arg__1) { SocExplorerPlot::mousePressEvent(arg__1); }
463 inline void promoted_mousePressEvent(QMouseEvent* arg__1) { SocExplorerPlot::mousePressEvent(arg__1); }
459 inline void promoted_mouseReleaseEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseReleaseEvent(arg__1); }
464 inline void promoted_mouseReleaseEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseReleaseEvent(arg__1); }
460 inline void promoted_wheelEvent(QWheelEvent* arg__1) { SocExplorerPlot::wheelEvent(arg__1); }
465 inline void promoted_wheelEvent(QWheelEvent* arg__1) { SocExplorerPlot::wheelEvent(arg__1); }
461 };
466 };
462
467
463 class PythonQtWrapper_SocExplorerPlot : public QObject
468 class PythonQtWrapper_SocExplorerPlot : public QObject
464 { Q_OBJECT
469 { Q_OBJECT
465 public:
470 public:
466 public slots:
471 public slots:
467 SocExplorerPlot* new_SocExplorerPlot(QWidget* parent = 0);
472 SocExplorerPlot* new_SocExplorerPlot(QWidget* parent = 0);
468 void delete_SocExplorerPlot(SocExplorerPlot* obj) { delete obj; }
473 void delete_SocExplorerPlot(SocExplorerPlot* obj) { delete obj; }
469 int addGraph(SocExplorerPlot* theWrappedObject);
474 int addGraph(SocExplorerPlot* theWrappedObject);
470 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
475 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
471 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y);
476 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y);
472 QPen getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex);
477 QPen getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex);
473 void keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
478 void keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
474 void keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
479 void keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
475 void mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
480 void mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
476 void mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
481 void mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
477 void mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
482 void mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
478 void rescaleAxis(SocExplorerPlot* theWrappedObject);
483 void rescaleAxis(SocExplorerPlot* theWrappedObject);
479 void setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable);
484 void setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable);
480 void setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
485 void setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
481 void setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle);
486 void setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle);
482 void setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name);
487 void setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name);
483 void setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen);
488 void setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen);
484 void setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle);
489 void setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle);
485 void setLegendFont(SocExplorerPlot* theWrappedObject, QFont font);
490 void setLegendFont(SocExplorerPlot* theWrappedObject, QFont font);
486 void setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font);
491 void setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font);
487 void setTitle(SocExplorerPlot* theWrappedObject, QString title);
492 void setTitle(SocExplorerPlot* theWrappedObject, QString title);
488 void setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
493 void setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
489 void setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
494 void setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
490 void setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
495 void setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
491 void setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
496 void setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
492 void show(SocExplorerPlot* theWrappedObject);
497 void show(SocExplorerPlot* theWrappedObject);
493 void wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1);
498 void wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1);
494 };
499 };
495
500
496
501
497
502
498
503
499
504
500 class PythonQtShell_TCP_Terminal_Client : public TCP_Terminal_Client
505 class PythonQtShell_TCP_Terminal_Client : public TCP_Terminal_Client
501 {
506 {
502 public:
507 public:
503 PythonQtShell_TCP_Terminal_Client(QObject* parent = 0):TCP_Terminal_Client(parent),_wrapper(NULL) {};
508 PythonQtShell_TCP_Terminal_Client(QObject* parent = 0):TCP_Terminal_Client(parent),_wrapper(NULL) { };
504
509
505 ~PythonQtShell_TCP_Terminal_Client();
510 ~PythonQtShell_TCP_Terminal_Client();
506
511
507 virtual void childEvent(QChildEvent* arg__1);
512 virtual void childEvent(QChildEvent* arg__1);
508 virtual void customEvent(QEvent* arg__1);
513 virtual void customEvent(QEvent* arg__1);
509 virtual bool event(QEvent* arg__1);
514 virtual bool event(QEvent* arg__1);
510 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
515 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
511 virtual void timerEvent(QTimerEvent* arg__1);
516 virtual void timerEvent(QTimerEvent* arg__1);
512
517
513 PythonQtInstanceWrapper* _wrapper;
518 PythonQtInstanceWrapper* _wrapper;
514 };
519 };
515
520
516 class PythonQtWrapper_TCP_Terminal_Client : public QObject
521 class PythonQtWrapper_TCP_Terminal_Client : public QObject
517 { Q_OBJECT
522 { Q_OBJECT
518 public:
523 public:
519 public slots:
524 public slots:
520 TCP_Terminal_Client* new_TCP_Terminal_Client(QObject* parent = 0);
525 TCP_Terminal_Client* new_TCP_Terminal_Client(QObject* parent = 0);
521 void delete_TCP_Terminal_Client(TCP_Terminal_Client* obj) { delete obj; }
526 void delete_TCP_Terminal_Client(TCP_Terminal_Client* obj) { delete obj; }
522 void connectToServer(TCP_Terminal_Client* theWrappedObject);
527 void connectToServer(TCP_Terminal_Client* theWrappedObject);
523 void connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port);
528 void connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port);
524 bool isConnected(TCP_Terminal_Client* theWrappedObject);
529 bool isConnected(TCP_Terminal_Client* theWrappedObject);
525 void sendText(TCP_Terminal_Client* theWrappedObject, const QString& text);
530 void sendText(TCP_Terminal_Client* theWrappedObject, const QString& text);
526 void startServer(TCP_Terminal_Client* theWrappedObject);
531 void startServer(TCP_Terminal_Client* theWrappedObject);
527 void startServer(TCP_Terminal_Client* theWrappedObject, int port);
532 void startServer(TCP_Terminal_Client* theWrappedObject, int port);
528 };
533 };
529
534
530
535
531
536
532
537
533
538
534 class PythonQtWrapper_XByteArray : public QObject
539 class PythonQtWrapper_XByteArray : public QObject
535 { Q_OBJECT
540 { Q_OBJECT
536 public:
541 public:
537 public slots:
542 public slots:
538 XByteArray* new_XByteArray();
543 XByteArray* new_XByteArray();
539 void delete_XByteArray(XByteArray* obj) { delete obj; }
544 void delete_XByteArray(XByteArray* obj) { delete obj; }
540 int addressOffset(XByteArray* theWrappedObject);
545 int addressOffset(XByteArray* theWrappedObject);
541 int addressWidth(XByteArray* theWrappedObject);
546 int addressWidth(XByteArray* theWrappedObject);
542 QChar asciiChar(XByteArray* theWrappedObject, int index);
547 QChar asciiChar(XByteArray* theWrappedObject, int index);
543 QByteArray* data(XByteArray* theWrappedObject);
548 QByteArray* data(XByteArray* theWrappedObject);
544 bool dataChanged(XByteArray* theWrappedObject, int i);
549 bool dataChanged(XByteArray* theWrappedObject, int i);
545 QByteArray dataChanged(XByteArray* theWrappedObject, int i, int len);
550 QByteArray dataChanged(XByteArray* theWrappedObject, int i, int len);
546 QByteArray* insert(XByteArray* theWrappedObject, int i, char ch);
551 QByteArray* insert(XByteArray* theWrappedObject, int i, char ch);
547 QByteArray* insert(XByteArray* theWrappedObject, int i, const QByteArray& ba);
552 QByteArray* insert(XByteArray* theWrappedObject, int i, const QByteArray& ba);
548 int realAddressNumbers(XByteArray* theWrappedObject);
553 int realAddressNumbers(XByteArray* theWrappedObject);
549 QByteArray* remove(XByteArray* theWrappedObject, int pos, int len);
554 QByteArray* remove(XByteArray* theWrappedObject, int pos, int len);
550 QByteArray* replace(XByteArray* theWrappedObject, int index, char ch);
555 QByteArray* replace(XByteArray* theWrappedObject, int index, char ch);
551 QByteArray* replace(XByteArray* theWrappedObject, int index, const QByteArray& ba);
556 QByteArray* replace(XByteArray* theWrappedObject, int index, const QByteArray& ba);
552 QByteArray* replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba);
557 QByteArray* replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba);
553 void setAddressOffset(XByteArray* theWrappedObject, int offset);
558 void setAddressOffset(XByteArray* theWrappedObject, int offset);
554 void setAddressWidth(XByteArray* theWrappedObject, int width);
559 void setAddressWidth(XByteArray* theWrappedObject, int width);
555 void setData(XByteArray* theWrappedObject, QByteArray data);
560 void setData(XByteArray* theWrappedObject, QByteArray data);
556 void setDataChanged(XByteArray* theWrappedObject, int i, bool state);
561 void setDataChanged(XByteArray* theWrappedObject, int i, bool state);
557 void setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state);
562 void setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state);
558 int size(XByteArray* theWrappedObject);
563 int size(XByteArray* theWrappedObject);
559 QString toRedableString(XByteArray* theWrappedObject, int start = 0, int end = -1);
564 QString toRedableString(XByteArray* theWrappedObject, int start = 0, int end = -1);
560 };
565 };
561
566
562
567
563
568
564
569
565
570
566 class PythonQtShell_abstractBinFile : public abstractBinFile
571 class PythonQtShell_abstractBinFile : public abstractBinFile
567 {
572 {
568 public:
573 public:
569 PythonQtShell_abstractBinFile():abstractBinFile(),_wrapper(NULL) {};
574 PythonQtShell_abstractBinFile():abstractBinFile(),_wrapper(NULL) { };
570
575
571 ~PythonQtShell_abstractBinFile();
576 ~PythonQtShell_abstractBinFile();
572
577
573 virtual void childEvent(QChildEvent* arg__1);
578 virtual void childEvent(QChildEvent* arg__1);
574 virtual int closeFile();
579 virtual int closeFile();
575 virtual void customEvent(QEvent* arg__1);
580 virtual void customEvent(QEvent* arg__1);
576 virtual bool event(QEvent* arg__1);
581 virtual bool event(QEvent* arg__1);
577 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
582 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
578 virtual QList<codeFragment* > getFragments();
583 virtual QList<codeFragment* > getFragments();
579 virtual bool isopened();
584 virtual bool isopened();
580 virtual bool openFile(const QString& File);
585 virtual bool openFile(const QString& File);
581 virtual void timerEvent(QTimerEvent* arg__1);
586 virtual void timerEvent(QTimerEvent* arg__1);
582 virtual bool toBinary(const QString& File);
587 virtual bool toBinary(const QString& File);
583 virtual bool toSrec(const QString& File);
588 virtual bool toSrec(const QString& File);
584
589
585 PythonQtInstanceWrapper* _wrapper;
590 PythonQtInstanceWrapper* _wrapper;
586 };
591 };
587
592
593 class PythonQtPublicPromoter_abstractBinFile : public abstractBinFile
594 { public:
595 inline int promoted_closeFile() { return closeFile(); }
596 inline QList<codeFragment* > promoted_getFragments() { return getFragments(); }
597 inline bool promoted_isopened() { return isopened(); }
598 inline bool promoted_openFile(const QString& File) { return openFile(File); }
599 inline bool promoted_toBinary(const QString& File) { return toBinary(File); }
600 inline bool promoted_toSrec(const QString& File) { return toSrec(File); }
601 };
602
588 class PythonQtWrapper_abstractBinFile : public QObject
603 class PythonQtWrapper_abstractBinFile : public QObject
589 { Q_OBJECT
604 { Q_OBJECT
590 public:
605 public:
591 public slots:
606 public slots:
592 abstractBinFile* new_abstractBinFile();
607 abstractBinFile* new_abstractBinFile();
593 void delete_abstractBinFile(abstractBinFile* obj) { delete obj; }
608 void delete_abstractBinFile(abstractBinFile* obj) { delete obj; }
609 int closeFile(abstractBinFile* theWrappedObject);
610 QList<codeFragment* > getFragments(abstractBinFile* theWrappedObject);
611 bool isopened(abstractBinFile* theWrappedObject);
612 bool openFile(abstractBinFile* theWrappedObject, const QString& File);
613 bool toBinary(abstractBinFile* theWrappedObject, const QString& File);
614 bool toSrec(abstractBinFile* theWrappedObject, const QString& File);
615 void py_set_litleendian(abstractBinFile* theWrappedObject, bool litleendian){ theWrappedObject->litleendian = litleendian; }
616 bool py_get_litleendian(abstractBinFile* theWrappedObject){ return theWrappedObject->litleendian; }
594 };
617 };
595
618
596
619
597
620
598
621
599
622
600 class PythonQtShell_abstractBinFileWidget : public abstractBinFileWidget
623 class PythonQtShell_abstractBinFileWidget : public abstractBinFileWidget
601 {
624 {
602 public:
625 public:
603 PythonQtShell_abstractBinFileWidget(QWidget* parent = 0):abstractBinFileWidget(parent),_wrapper(NULL) {};
626 PythonQtShell_abstractBinFileWidget(QWidget* parent = 0):abstractBinFileWidget(parent),_wrapper(NULL) { };
604
627
605 ~PythonQtShell_abstractBinFileWidget();
628 ~PythonQtShell_abstractBinFileWidget();
606
629
607 virtual void actionEvent(QActionEvent* arg__1);
630 virtual void actionEvent(QActionEvent* arg__1);
608 virtual void changeEvent(QEvent* arg__1);
631 virtual void changeEvent(QEvent* arg__1);
609 virtual void childEvent(QChildEvent* arg__1);
632 virtual void childEvent(QChildEvent* arg__1);
610 virtual void closeEvent(QCloseEvent* arg__1);
633 virtual void closeEvent(QCloseEvent* arg__1);
611 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
634 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
612 virtual void customEvent(QEvent* arg__1);
635 virtual void customEvent(QEvent* arg__1);
613 virtual int devType() const;
636 virtual int devType() const;
614 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
637 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
615 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
638 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
616 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
639 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
617 virtual void dropEvent(QDropEvent* arg__1);
640 virtual void dropEvent(QDropEvent* arg__1);
618 virtual void enterEvent(QEvent* arg__1);
641 virtual void enterEvent(QEvent* arg__1);
619 virtual bool event(QEvent* arg__1);
642 virtual bool event(QEvent* arg__1);
620 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
643 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
621 virtual void focusInEvent(QFocusEvent* arg__1);
644 virtual void focusInEvent(QFocusEvent* arg__1);
622 virtual bool focusNextPrevChild(bool next);
645 virtual bool focusNextPrevChild(bool next);
623 virtual void focusOutEvent(QFocusEvent* arg__1);
646 virtual void focusOutEvent(QFocusEvent* arg__1);
624 virtual bool hasHeightForWidth() const;
647 virtual bool hasHeightForWidth() const;
625 virtual int heightForWidth(int arg__1) const;
648 virtual int heightForWidth(int arg__1) const;
626 virtual void hideEvent(QHideEvent* arg__1);
649 virtual void hideEvent(QHideEvent* arg__1);
627 virtual void initPainter(QPainter* painter) const;
650 virtual void initPainter(QPainter* painter) const;
628 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
651 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
629 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
652 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
630 virtual void keyPressEvent(QKeyEvent* arg__1);
653 virtual void keyPressEvent(QKeyEvent* arg__1);
631 virtual void keyReleaseEvent(QKeyEvent* arg__1);
654 virtual void keyReleaseEvent(QKeyEvent* arg__1);
632 virtual void leaveEvent(QEvent* arg__1);
655 virtual void leaveEvent(QEvent* arg__1);
633 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
656 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
634 virtual QSize minimumSizeHint() const;
657 virtual QSize minimumSizeHint() const;
635 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
658 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
636 virtual void mouseMoveEvent(QMouseEvent* arg__1);
659 virtual void mouseMoveEvent(QMouseEvent* arg__1);
637 virtual void mousePressEvent(QMouseEvent* arg__1);
660 virtual void mousePressEvent(QMouseEvent* arg__1);
638 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
661 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
639 virtual void moveEvent(QMoveEvent* arg__1);
662 virtual void moveEvent(QMoveEvent* arg__1);
640 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
663 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
641 virtual QPaintEngine* paintEngine() const;
664 virtual QPaintEngine* paintEngine() const;
642 virtual void paintEvent(QPaintEvent* arg__1);
665 virtual void paintEvent(QPaintEvent* arg__1);
643 virtual QPaintDevice* redirected(QPoint* offset) const;
666 virtual QPaintDevice* redirected(QPoint* offset) const;
644 virtual void reloadFile();
667 virtual void reloadFile();
645 virtual void resizeEvent(QResizeEvent* arg__1);
668 virtual void resizeEvent(QResizeEvent* arg__1);
646 virtual void setFile(abstractBinFile* file);
669 virtual void setFile(abstractBinFile* file);
647 virtual QPainter* sharedPainter() const;
670 virtual QPainter* sharedPainter() const;
648 virtual void showEvent(QShowEvent* arg__1);
671 virtual void showEvent(QShowEvent* arg__1);
649 virtual QSize sizeHint() const;
672 virtual QSize sizeHint() const;
650 virtual void tabletEvent(QTabletEvent* arg__1);
673 virtual void tabletEvent(QTabletEvent* arg__1);
651 virtual void timerEvent(QTimerEvent* arg__1);
674 virtual void timerEvent(QTimerEvent* arg__1);
652 virtual void wheelEvent(QWheelEvent* arg__1);
675 virtual void wheelEvent(QWheelEvent* arg__1);
653
676
654 PythonQtInstanceWrapper* _wrapper;
677 PythonQtInstanceWrapper* _wrapper;
655 };
678 };
656
679
680 class PythonQtPublicPromoter_abstractBinFileWidget : public abstractBinFileWidget
681 { public:
682 inline void promoted_reloadFile() { reloadFile(); }
683 inline void promoted_setFile(abstractBinFile* file) { setFile(file); }
684 };
685
657 class PythonQtWrapper_abstractBinFileWidget : public QObject
686 class PythonQtWrapper_abstractBinFileWidget : public QObject
658 { Q_OBJECT
687 { Q_OBJECT
659 public:
688 public:
660 public slots:
689 public slots:
661 abstractBinFileWidget* new_abstractBinFileWidget(QWidget* parent = 0);
690 abstractBinFileWidget* new_abstractBinFileWidget(QWidget* parent = 0);
662 void delete_abstractBinFileWidget(abstractBinFileWidget* obj) { delete obj; }
691 void delete_abstractBinFileWidget(abstractBinFileWidget* obj) { delete obj; }
692 void reloadFile(abstractBinFileWidget* theWrappedObject);
693 void setFile(abstractBinFileWidget* theWrappedObject, abstractBinFile* file);
663 };
694 };
664
695
665
696
666
697
667
698
668
699
669 class PythonQtShell_binaryFile : public binaryFile
700 class PythonQtShell_binaryFile : public binaryFile
670 {
701 {
671 public:
702 public:
672 PythonQtShell_binaryFile():binaryFile(),_wrapper(NULL) {};
703 PythonQtShell_binaryFile():binaryFile(),_wrapper(NULL) { };
673 PythonQtShell_binaryFile(const QString& File):binaryFile(File),_wrapper(NULL) {};
704 PythonQtShell_binaryFile(const QString& File):binaryFile(File),_wrapper(NULL) { };
674 PythonQtShell_binaryFile(const QStringList& Files):binaryFile(Files),_wrapper(NULL) {};
705 PythonQtShell_binaryFile(const QStringList& Files):binaryFile(Files),_wrapper(NULL) { };
675
706
676 ~PythonQtShell_binaryFile();
707 ~PythonQtShell_binaryFile();
677
708
678 virtual int closeFile();
709 virtual int closeFile();
679 virtual QList<codeFragment* > getFragments();
710 virtual QList<codeFragment* > getFragments();
680 virtual bool isopened();
711 virtual bool isopened();
681 virtual bool openFile(const QString& File);
712 virtual bool openFile(const QString& File);
682 virtual bool toBinary(const QString& fileName);
713 virtual bool toBinary(const QString& fileName);
683 virtual bool toSrec(const QString& fileName);
714 virtual bool toSrec(const QString& fileName);
684
715
685 PythonQtInstanceWrapper* _wrapper;
716 PythonQtInstanceWrapper* _wrapper;
686 };
717 };
687
718
688 class PythonQtPublicPromoter_binaryFile : public binaryFile
719 class PythonQtPublicPromoter_binaryFile : public binaryFile
689 { public:
720 { public:
690 inline int promoted_closeFile() { return binaryFile::closeFile(); }
721 inline int promoted_closeFile() { return binaryFile::closeFile(); }
691 inline QList<codeFragment* > promoted_getFragments() { return binaryFile::getFragments(); }
722 inline QList<codeFragment* > promoted_getFragments() { return binaryFile::getFragments(); }
692 inline bool promoted_isopened() { return binaryFile::isopened(); }
723 inline bool promoted_isopened() { return binaryFile::isopened(); }
693 inline bool promoted_openFile(const QString& File) { return binaryFile::openFile(File); }
724 inline bool promoted_openFile(const QString& File) { return binaryFile::openFile(File); }
694 inline bool promoted_toBinary(const QString& fileName) { return binaryFile::toBinary(fileName); }
725 inline bool promoted_toBinary(const QString& fileName) { return binaryFile::toBinary(fileName); }
695 inline bool promoted_toSrec(const QString& fileName) { return binaryFile::toSrec(fileName); }
726 inline bool promoted_toSrec(const QString& fileName) { return binaryFile::toSrec(fileName); }
696 };
727 };
697
728
698 class PythonQtWrapper_binaryFile : public QObject
729 class PythonQtWrapper_binaryFile : public QObject
699 { Q_OBJECT
730 { Q_OBJECT
700 public:
731 public:
701 public slots:
732 public slots:
702 binaryFile* new_binaryFile();
733 binaryFile* new_binaryFile();
703 binaryFile* new_binaryFile(const QString& File);
734 binaryFile* new_binaryFile(const QString& File);
704 binaryFile* new_binaryFile(const QStringList& Files);
735 binaryFile* new_binaryFile(const QStringList& Files);
705 void delete_binaryFile(binaryFile* obj) { delete obj; }
736 void delete_binaryFile(binaryFile* obj) { delete obj; }
706 int closeFile(binaryFile* theWrappedObject);
737 int closeFile(binaryFile* theWrappedObject);
707 codeFragment* getFragment(binaryFile* theWrappedObject, int index);
738 codeFragment* getFragment(binaryFile* theWrappedObject, int index);
708 int getFragmentAddress(binaryFile* theWrappedObject, int index);
739 int getFragmentAddress(binaryFile* theWrappedObject, int index);
709 bool getFragmentData(binaryFile* theWrappedObject, int index, char** buffer);
740 bool getFragmentData(binaryFile* theWrappedObject, int index, char** buffer);
710 QString getFragmentHeader(binaryFile* theWrappedObject, int index);
741 QString getFragmentHeader(binaryFile* theWrappedObject, int index);
711 int getFragmentSize(binaryFile* theWrappedObject, int index);
742 int getFragmentSize(binaryFile* theWrappedObject, int index);
712 QList<codeFragment* > getFragments(binaryFile* theWrappedObject);
743 QList<codeFragment* > getFragments(binaryFile* theWrappedObject);
713 int getFragmentsCount(binaryFile* theWrappedObject);
744 int getFragmentsCount(binaryFile* theWrappedObject);
714 bool isopened(binaryFile* theWrappedObject);
745 bool isopened(binaryFile* theWrappedObject);
715 bool openFile(binaryFile* theWrappedObject, const QString& File);
746 bool openFile(binaryFile* theWrappedObject, const QString& File);
716 bool openFiles(binaryFile* theWrappedObject, const QStringList& Files);
747 bool openFiles(binaryFile* theWrappedObject, const QStringList& Files);
717 bool static_binaryFile_toBinary(QList<codeFragment* > fragments, const QString& File);
748 bool static_binaryFile_toBinary(QList<codeFragment* > fragments, const QString& File);
718 bool toBinary(binaryFile* theWrappedObject, const QString& fileName);
749 bool toBinary(binaryFile* theWrappedObject, const QString& fileName);
719 bool toSrec(binaryFile* theWrappedObject, const QString& fileName);
750 bool toSrec(binaryFile* theWrappedObject, const QString& fileName);
720 };
751 };
721
752
722
753
723
754
724
755
725
756
726 class PythonQtShell_binaryFileWidget : public binaryFileWidget
757 class PythonQtShell_binaryFileWidget : public binaryFileWidget
727 {
758 {
728 public:
759 public:
729 PythonQtShell_binaryFileWidget(QWidget* parent = 0):binaryFileWidget(parent),_wrapper(NULL) {};
760 PythonQtShell_binaryFileWidget(QWidget* parent = 0):binaryFileWidget(parent),_wrapper(NULL) { };
730
761
731 ~PythonQtShell_binaryFileWidget();
762 ~PythonQtShell_binaryFileWidget();
732
763
733 virtual void reloadFile();
764 virtual void reloadFile();
734 virtual void setFile(abstractBinFile* file);
765 virtual void setFile(abstractBinFile* file);
735
766
736 PythonQtInstanceWrapper* _wrapper;
767 PythonQtInstanceWrapper* _wrapper;
737 };
768 };
738
769
739 class PythonQtPublicPromoter_binaryFileWidget : public binaryFileWidget
770 class PythonQtPublicPromoter_binaryFileWidget : public binaryFileWidget
740 { public:
771 { public:
741 inline void promoted_reloadFile() { binaryFileWidget::reloadFile(); }
772 inline void promoted_reloadFile() { binaryFileWidget::reloadFile(); }
742 inline void promoted_setFile(abstractBinFile* file) { binaryFileWidget::setFile(file); }
773 inline void promoted_setFile(abstractBinFile* file) { binaryFileWidget::setFile(file); }
743 };
774 };
744
775
745 class PythonQtWrapper_binaryFileWidget : public QObject
776 class PythonQtWrapper_binaryFileWidget : public QObject
746 { Q_OBJECT
777 { Q_OBJECT
747 public:
778 public:
748 public slots:
779 public slots:
749 binaryFileWidget* new_binaryFileWidget(QWidget* parent = 0);
780 binaryFileWidget* new_binaryFileWidget(QWidget* parent = 0);
750 void delete_binaryFileWidget(binaryFileWidget* obj) { delete obj; }
781 void delete_binaryFileWidget(binaryFileWidget* obj) { delete obj; }
751 void reloadFile(binaryFileWidget* theWrappedObject);
782 void reloadFile(binaryFileWidget* theWrappedObject);
752 void setFile(binaryFileWidget* theWrappedObject, abstractBinFile* file);
783 void setFile(binaryFileWidget* theWrappedObject, abstractBinFile* file);
753 };
784 };
754
785
755
786
756
787
757
788
758
789
759 class PythonQtShell_codeFragment : public codeFragment
790 class PythonQtShell_codeFragment : public codeFragment
760 {
791 {
761 public:
792 public:
762 PythonQtShell_codeFragment():codeFragment(),_wrapper(NULL) {};
793 PythonQtShell_codeFragment():codeFragment(),_wrapper(NULL) { };
763 PythonQtShell_codeFragment(char* data, quint64 size, quint64 address):codeFragment(data, size, address),_wrapper(NULL) {};
794 PythonQtShell_codeFragment(char* data, quint64 size, quint64 address):codeFragment(data, size, address),_wrapper(NULL) { };
764
795
765 ~PythonQtShell_codeFragment();
796 ~PythonQtShell_codeFragment();
766
797
767
798
768 PythonQtInstanceWrapper* _wrapper;
799 PythonQtInstanceWrapper* _wrapper;
769 };
800 };
770
801
771 class PythonQtWrapper_codeFragment : public QObject
802 class PythonQtWrapper_codeFragment : public QObject
772 { Q_OBJECT
803 { Q_OBJECT
773 public:
804 public:
774 public slots:
805 public slots:
775 codeFragment* new_codeFragment();
806 codeFragment* new_codeFragment();
776 codeFragment* new_codeFragment(char* data, quint64 size, quint64 address);
807 codeFragment* new_codeFragment(char* data, quint64 size, quint64 address);
777 void delete_codeFragment(codeFragment* obj) { delete obj; }
808 void delete_codeFragment(codeFragment* obj) { delete obj; }
778 void py_set_size(codeFragment* theWrappedObject, quint64 size){ theWrappedObject->size = size; }
809 void py_set_address(codeFragment* theWrappedObject, quint64 address){ theWrappedObject->address = address; }
779 quint64 py_get_size(codeFragment* theWrappedObject){ return theWrappedObject->size; }
810 quint64 py_get_address(codeFragment* theWrappedObject){ return theWrappedObject->address; }
780 void py_set_data(codeFragment* theWrappedObject, char* data){ theWrappedObject->data = data; }
811 void py_set_data(codeFragment* theWrappedObject, char* data){ theWrappedObject->data = data; }
781 char* py_get_data(codeFragment* theWrappedObject){ return theWrappedObject->data; }
812 char* py_get_data(codeFragment* theWrappedObject){ return theWrappedObject->data; }
782 void py_set_address(codeFragment* theWrappedObject, quint64 address){ theWrappedObject->address = address; }
783 quint64 py_get_address(codeFragment* theWrappedObject){ return theWrappedObject->address; }
784 void py_set_header(codeFragment* theWrappedObject, QString header){ theWrappedObject->header = header; }
813 void py_set_header(codeFragment* theWrappedObject, QString header){ theWrappedObject->header = header; }
785 QString py_get_header(codeFragment* theWrappedObject){ return theWrappedObject->header; }
814 QString py_get_header(codeFragment* theWrappedObject){ return theWrappedObject->header; }
815 void py_set_size(codeFragment* theWrappedObject, quint64 size){ theWrappedObject->size = size; }
816 quint64 py_get_size(codeFragment* theWrappedObject){ return theWrappedObject->size; }
786 };
817 };
787
818
788
819
789
820
790
821
791
822
792 class PythonQtShell_elfFileWidget : public elfFileWidget
823 class PythonQtShell_elfFileWidget : public elfFileWidget
793 {
824 {
794 public:
825 public:
795 PythonQtShell_elfFileWidget(QWidget* parent = 0):elfFileWidget(parent),_wrapper(NULL) {};
826 PythonQtShell_elfFileWidget(QWidget* parent = 0):elfFileWidget(parent),_wrapper(NULL) { };
796
827
797 ~PythonQtShell_elfFileWidget();
828 ~PythonQtShell_elfFileWidget();
798
829
799 virtual void reloadFile();
830 virtual void reloadFile();
800 virtual void setFile(abstractBinFile* file);
831 virtual void setFile(abstractBinFile* file);
801
832
802 PythonQtInstanceWrapper* _wrapper;
833 PythonQtInstanceWrapper* _wrapper;
803 };
834 };
804
835
805 class PythonQtPublicPromoter_elfFileWidget : public elfFileWidget
836 class PythonQtPublicPromoter_elfFileWidget : public elfFileWidget
806 { public:
837 { public:
807 inline void promoted_reloadFile() { elfFileWidget::reloadFile(); }
838 inline void promoted_reloadFile() { elfFileWidget::reloadFile(); }
808 inline void promoted_setFile(abstractBinFile* file) { elfFileWidget::setFile(file); }
839 inline void promoted_setFile(abstractBinFile* file) { elfFileWidget::setFile(file); }
809 };
840 };
810
841
811 class PythonQtWrapper_elfFileWidget : public QObject
842 class PythonQtWrapper_elfFileWidget : public QObject
812 { Q_OBJECT
843 { Q_OBJECT
813 public:
844 public:
814 public slots:
845 public slots:
815 elfFileWidget* new_elfFileWidget(QWidget* parent = 0);
846 elfFileWidget* new_elfFileWidget(QWidget* parent = 0);
816 void delete_elfFileWidget(elfFileWidget* obj) { delete obj; }
847 void delete_elfFileWidget(elfFileWidget* obj) { delete obj; }
817 void reloadFile(elfFileWidget* theWrappedObject);
848 void reloadFile(elfFileWidget* theWrappedObject);
818 void setFile(elfFileWidget* theWrappedObject, abstractBinFile* file);
849 void setFile(elfFileWidget* theWrappedObject, abstractBinFile* file);
819 };
850 };
820
851
821
852
822
853
823
854
824
855
825 class PythonQtShell_elfInfoWdgt : public elfInfoWdgt
856 class PythonQtShell_elfInfoWdgt : public elfInfoWdgt
826 {
857 {
827 public:
858 public:
828 PythonQtShell_elfInfoWdgt(QWidget* parent = 0):elfInfoWdgt(parent),_wrapper(NULL) {};
859 PythonQtShell_elfInfoWdgt(QWidget* parent = 0):elfInfoWdgt(parent),_wrapper(NULL) { };
829
860
830 ~PythonQtShell_elfInfoWdgt();
861 ~PythonQtShell_elfInfoWdgt();
831
862
832 virtual void actionEvent(QActionEvent* arg__1);
863 virtual void actionEvent(QActionEvent* arg__1);
833 virtual void changeEvent(QEvent* arg__1);
864 virtual void changeEvent(QEvent* arg__1);
834 virtual void childEvent(QChildEvent* arg__1);
865 virtual void childEvent(QChildEvent* arg__1);
835 virtual void closeEvent(QCloseEvent* arg__1);
866 virtual void closeEvent(QCloseEvent* arg__1);
836 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
867 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
837 virtual void customEvent(QEvent* arg__1);
868 virtual void customEvent(QEvent* arg__1);
838 virtual int devType() const;
869 virtual int devType() const;
839 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
870 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
840 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
871 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
841 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
872 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
842 virtual void dropEvent(QDropEvent* arg__1);
873 virtual void dropEvent(QDropEvent* arg__1);
843 virtual void enterEvent(QEvent* arg__1);
874 virtual void enterEvent(QEvent* arg__1);
844 virtual bool event(QEvent* arg__1);
875 virtual bool event(QEvent* arg__1);
845 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
876 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
846 virtual void focusInEvent(QFocusEvent* arg__1);
877 virtual void focusInEvent(QFocusEvent* arg__1);
847 virtual bool focusNextPrevChild(bool next);
878 virtual bool focusNextPrevChild(bool next);
848 virtual void focusOutEvent(QFocusEvent* arg__1);
879 virtual void focusOutEvent(QFocusEvent* arg__1);
849 virtual bool hasHeightForWidth() const;
880 virtual bool hasHeightForWidth() const;
850 virtual int heightForWidth(int arg__1) const;
881 virtual int heightForWidth(int arg__1) const;
851 virtual void hideEvent(QHideEvent* arg__1);
882 virtual void hideEvent(QHideEvent* arg__1);
852 virtual void initPainter(QPainter* painter) const;
883 virtual void initPainter(QPainter* painter) const;
853 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
884 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
854 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
885 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
855 virtual void keyPressEvent(QKeyEvent* arg__1);
886 virtual void keyPressEvent(QKeyEvent* arg__1);
856 virtual void keyReleaseEvent(QKeyEvent* arg__1);
887 virtual void keyReleaseEvent(QKeyEvent* arg__1);
857 virtual void leaveEvent(QEvent* arg__1);
888 virtual void leaveEvent(QEvent* arg__1);
858 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
889 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
859 virtual QSize minimumSizeHint() const;
890 virtual QSize minimumSizeHint() const;
860 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
891 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
861 virtual void mouseMoveEvent(QMouseEvent* arg__1);
892 virtual void mouseMoveEvent(QMouseEvent* arg__1);
862 virtual void mousePressEvent(QMouseEvent* arg__1);
893 virtual void mousePressEvent(QMouseEvent* arg__1);
863 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
894 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
864 virtual void moveEvent(QMoveEvent* arg__1);
895 virtual void moveEvent(QMoveEvent* arg__1);
865 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
896 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
866 virtual QPaintEngine* paintEngine() const;
897 virtual QPaintEngine* paintEngine() const;
867 virtual void paintEvent(QPaintEvent* arg__1);
898 virtual void paintEvent(QPaintEvent* arg__1);
868 virtual QPaintDevice* redirected(QPoint* offset) const;
899 virtual QPaintDevice* redirected(QPoint* offset) const;
869 virtual void resizeEvent(QResizeEvent* arg__1);
900 virtual void resizeEvent(QResizeEvent* arg__1);
870 virtual QPainter* sharedPainter() const;
901 virtual QPainter* sharedPainter() const;
871 virtual void showEvent(QShowEvent* arg__1);
902 virtual void showEvent(QShowEvent* arg__1);
872 virtual QSize sizeHint() const;
903 virtual QSize sizeHint() const;
873 virtual void tabletEvent(QTabletEvent* arg__1);
904 virtual void tabletEvent(QTabletEvent* arg__1);
874 virtual void timerEvent(QTimerEvent* arg__1);
905 virtual void timerEvent(QTimerEvent* arg__1);
875 virtual void wheelEvent(QWheelEvent* arg__1);
906 virtual void wheelEvent(QWheelEvent* arg__1);
876
907
877 PythonQtInstanceWrapper* _wrapper;
908 PythonQtInstanceWrapper* _wrapper;
878 };
909 };
879
910
880 class PythonQtWrapper_elfInfoWdgt : public QObject
911 class PythonQtWrapper_elfInfoWdgt : public QObject
881 { Q_OBJECT
912 { Q_OBJECT
882 public:
913 public:
883 public slots:
914 public slots:
884 elfInfoWdgt* new_elfInfoWdgt(QWidget* parent = 0);
915 elfInfoWdgt* new_elfInfoWdgt(QWidget* parent = 0);
885 void delete_elfInfoWdgt(elfInfoWdgt* obj) { delete obj; }
916 void delete_elfInfoWdgt(elfInfoWdgt* obj) { delete obj; }
886 };
917 };
887
918
888
919
889
920
890
921
891
922
892 class PythonQtWrapper_elfparser : public QObject
923 class PythonQtWrapper_elfparser : public QObject
893 { Q_OBJECT
924 { Q_OBJECT
894 public:
925 public:
895 public slots:
926 public slots:
896 elfparser* new_elfparser();
927 elfparser* new_elfparser();
897 void delete_elfparser(elfparser* obj) { delete obj; }
928 void delete_elfparser(elfparser* obj) { delete obj; }
898 int closeFile(elfparser* theWrappedObject);
929 int closeFile(elfparser* theWrappedObject);
899 QString getABI(elfparser* theWrappedObject);
930 QString getABI(elfparser* theWrappedObject);
900 QString getArchitecture(elfparser* theWrappedObject);
931 QString getArchitecture(elfparser* theWrappedObject);
901 QString getClass(elfparser* theWrappedObject);
932 QString getClass(elfparser* theWrappedObject);
902 QString getEndianness(elfparser* theWrappedObject);
933 QString getEndianness(elfparser* theWrappedObject);
903 qint64 getEntryPointAddress(elfparser* theWrappedObject);
934 qint64 getEntryPointAddress(elfparser* theWrappedObject);
904 bool getSectionData(elfparser* theWrappedObject, int index, char** buffer);
935 bool getSectionData(elfparser* theWrappedObject, int index, char** buffer);
905 qint64 getSectionDatasz(elfparser* theWrappedObject, int index);
936 qint64 getSectionDatasz(elfparser* theWrappedObject, int index);
906 qint64 getSectionMemsz(elfparser* theWrappedObject, int index);
937 qint64 getSectionMemsz(elfparser* theWrappedObject, int index);
907 QString getSectionName(elfparser* theWrappedObject, int index);
938 QString getSectionName(elfparser* theWrappedObject, int index);
908 qint64 getSectionPaddr(elfparser* theWrappedObject, int index);
939 qint64 getSectionPaddr(elfparser* theWrappedObject, int index);
909 QString getSectionType(elfparser* theWrappedObject, int index);
940 QString getSectionType(elfparser* theWrappedObject, int index);
910 int getSectioncount(elfparser* theWrappedObject);
941 int getSectioncount(elfparser* theWrappedObject);
911 qint64 getSegmentFilesz(elfparser* theWrappedObject, int index);
942 qint64 getSegmentFilesz(elfparser* theWrappedObject, int index);
912 QString getSegmentFlags(elfparser* theWrappedObject, int index);
943 QString getSegmentFlags(elfparser* theWrappedObject, int index);
913 qint64 getSegmentMemsz(elfparser* theWrappedObject, int index);
944 qint64 getSegmentMemsz(elfparser* theWrappedObject, int index);
914 qint64 getSegmentOffset(elfparser* theWrappedObject, int index);
945 qint64 getSegmentOffset(elfparser* theWrappedObject, int index);
915 qint64 getSegmentPaddr(elfparser* theWrappedObject, int index);
946 qint64 getSegmentPaddr(elfparser* theWrappedObject, int index);
916 QString getSegmentType(elfparser* theWrappedObject, int index);
947 QString getSegmentType(elfparser* theWrappedObject, int index);
917 qint64 getSegmentVaddr(elfparser* theWrappedObject, int index);
948 qint64 getSegmentVaddr(elfparser* theWrappedObject, int index);
918 int getSegmentcount(elfparser* theWrappedObject);
949 int getSegmentcount(elfparser* theWrappedObject);
919 QString getType(elfparser* theWrappedObject);
950 QString getType(elfparser* theWrappedObject);
920 qint64 getVersion(elfparser* theWrappedObject);
951 qint64 getVersion(elfparser* theWrappedObject);
921 bool static_elfparser_isElf(const QString& File);
952 bool static_elfparser_isElf(const QString& File);
922 bool iself(elfparser* theWrappedObject);
953 bool iself(elfparser* theWrappedObject);
923 bool isopened(elfparser* theWrappedObject);
954 bool isopened(elfparser* theWrappedObject);
924 int setFilename(elfparser* theWrappedObject, const QString& name);
955 int setFilename(elfparser* theWrappedObject, const QString& name);
925 };
956 };
926
957
927
958
928
959
929
960
930
961
931 class PythonQtShell_genericBinaryFileWidget : public genericBinaryFileWidget
962 class PythonQtShell_genericBinaryFileWidget : public genericBinaryFileWidget
932 {
963 {
933 public:
964 public:
934 PythonQtShell_genericBinaryFileWidget(QWidget* parent = 0):genericBinaryFileWidget(parent),_wrapper(NULL) {};
965 PythonQtShell_genericBinaryFileWidget(QWidget* parent = 0):genericBinaryFileWidget(parent),_wrapper(NULL) { };
935
966
936 ~PythonQtShell_genericBinaryFileWidget();
967 ~PythonQtShell_genericBinaryFileWidget();
937
968
938 virtual void actionEvent(QActionEvent* arg__1);
969 virtual void actionEvent(QActionEvent* arg__1);
939 virtual void changeEvent(QEvent* arg__1);
970 virtual void changeEvent(QEvent* arg__1);
940 virtual void childEvent(QChildEvent* arg__1);
971 virtual void childEvent(QChildEvent* arg__1);
941 virtual void closeEvent(QCloseEvent* arg__1);
972 virtual void closeEvent(QCloseEvent* arg__1);
942 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
973 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
943 virtual void customEvent(QEvent* arg__1);
974 virtual void customEvent(QEvent* arg__1);
944 virtual int devType() const;
975 virtual int devType() const;
945 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
976 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
946 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
977 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
947 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
978 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
948 virtual void dropEvent(QDropEvent* arg__1);
979 virtual void dropEvent(QDropEvent* arg__1);
949 virtual void enterEvent(QEvent* arg__1);
980 virtual void enterEvent(QEvent* arg__1);
950 virtual bool event(QEvent* arg__1);
981 virtual bool event(QEvent* arg__1);
951 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
982 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
952 virtual void focusInEvent(QFocusEvent* arg__1);
983 virtual void focusInEvent(QFocusEvent* arg__1);
953 virtual bool focusNextPrevChild(bool next);
984 virtual bool focusNextPrevChild(bool next);
954 virtual void focusOutEvent(QFocusEvent* arg__1);
985 virtual void focusOutEvent(QFocusEvent* arg__1);
955 virtual bool hasHeightForWidth() const;
986 virtual bool hasHeightForWidth() const;
956 virtual int heightForWidth(int arg__1) const;
987 virtual int heightForWidth(int arg__1) const;
957 virtual void hideEvent(QHideEvent* arg__1);
988 virtual void hideEvent(QHideEvent* arg__1);
958 virtual void initPainter(QPainter* painter) const;
989 virtual void initPainter(QPainter* painter) const;
959 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
990 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
960 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
991 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
961 virtual void keyPressEvent(QKeyEvent* arg__1);
992 virtual void keyPressEvent(QKeyEvent* arg__1);
962 virtual void keyReleaseEvent(QKeyEvent* arg__1);
993 virtual void keyReleaseEvent(QKeyEvent* arg__1);
963 virtual void leaveEvent(QEvent* arg__1);
994 virtual void leaveEvent(QEvent* arg__1);
964 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
995 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
965 virtual QSize minimumSizeHint() const;
996 virtual QSize minimumSizeHint() const;
966 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
997 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
967 virtual void mouseMoveEvent(QMouseEvent* arg__1);
998 virtual void mouseMoveEvent(QMouseEvent* arg__1);
968 virtual void mousePressEvent(QMouseEvent* arg__1);
999 virtual void mousePressEvent(QMouseEvent* arg__1);
969 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
1000 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
970 virtual void moveEvent(QMoveEvent* arg__1);
1001 virtual void moveEvent(QMoveEvent* arg__1);
971 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
1002 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
972 virtual QPaintEngine* paintEngine() const;
1003 virtual QPaintEngine* paintEngine() const;
973 virtual void paintEvent(QPaintEvent* arg__1);
1004 virtual void paintEvent(QPaintEvent* arg__1);
974 virtual QPaintDevice* redirected(QPoint* offset) const;
1005 virtual QPaintDevice* redirected(QPoint* offset) const;
975 virtual void resizeEvent(QResizeEvent* arg__1);
1006 virtual void resizeEvent(QResizeEvent* arg__1);
976 virtual QPainter* sharedPainter() const;
1007 virtual QPainter* sharedPainter() const;
977 virtual void showEvent(QShowEvent* arg__1);
1008 virtual void showEvent(QShowEvent* arg__1);
978 virtual QSize sizeHint() const;
1009 virtual QSize sizeHint() const;
979 virtual void tabletEvent(QTabletEvent* arg__1);
1010 virtual void tabletEvent(QTabletEvent* arg__1);
980 virtual void timerEvent(QTimerEvent* arg__1);
1011 virtual void timerEvent(QTimerEvent* arg__1);
981 virtual void wheelEvent(QWheelEvent* arg__1);
1012 virtual void wheelEvent(QWheelEvent* arg__1);
982
1013
983 PythonQtInstanceWrapper* _wrapper;
1014 PythonQtInstanceWrapper* _wrapper;
984 };
1015 };
985
1016
986 class PythonQtWrapper_genericBinaryFileWidget : public QObject
1017 class PythonQtWrapper_genericBinaryFileWidget : public QObject
987 { Q_OBJECT
1018 { Q_OBJECT
988 public:
1019 public:
989 public slots:
1020 public slots:
990 genericBinaryFileWidget* new_genericBinaryFileWidget(QWidget* parent = 0);
1021 genericBinaryFileWidget* new_genericBinaryFileWidget(QWidget* parent = 0);
991 void delete_genericBinaryFileWidget(genericBinaryFileWidget* obj) { delete obj; }
1022 void delete_genericBinaryFileWidget(genericBinaryFileWidget* obj) { delete obj; }
992 };
1023 };
993
1024
994
1025
995
1026
996
1027
997
1028
998 class PythonQtShell_srecFile : public srecFile
1029 class PythonQtShell_srecFile : public srecFile
999 {
1030 {
1000 public:
1031 public:
1001 PythonQtShell_srecFile():srecFile(),_wrapper(NULL) {};
1032 PythonQtShell_srecFile():srecFile(),_wrapper(NULL) { };
1002 PythonQtShell_srecFile(const QString& File):srecFile(File),_wrapper(NULL) {};
1033 PythonQtShell_srecFile(const QString& File):srecFile(File),_wrapper(NULL) { };
1003 PythonQtShell_srecFile(const QStringList& Files):srecFile(Files),_wrapper(NULL) {};
1034 PythonQtShell_srecFile(const QStringList& Files):srecFile(Files),_wrapper(NULL) { };
1004
1035
1005 ~PythonQtShell_srecFile();
1036 ~PythonQtShell_srecFile();
1006
1037
1007 virtual int closeFile();
1038 virtual int closeFile();
1008 virtual QList<codeFragment* > getFragments();
1039 virtual QList<codeFragment* > getFragments();
1009 virtual bool isopened();
1040 virtual bool isopened();
1010 virtual bool openFile(const QString& File);
1041 virtual bool openFile(const QString& File);
1011 virtual bool toBinary(const QString& File);
1042 virtual bool toBinary(const QString& File);
1012 virtual bool toSrec(const QString& File);
1043 virtual bool toSrec(const QString& File);
1013
1044
1014 PythonQtInstanceWrapper* _wrapper;
1045 PythonQtInstanceWrapper* _wrapper;
1015 };
1046 };
1016
1047
1017 class PythonQtPublicPromoter_srecFile : public srecFile
1048 class PythonQtPublicPromoter_srecFile : public srecFile
1018 { public:
1049 { public:
1019 inline int promoted_closeFile() { return srecFile::closeFile(); }
1050 inline int promoted_closeFile() { return srecFile::closeFile(); }
1020 inline QList<codeFragment* > promoted_getFragments() { return srecFile::getFragments(); }
1051 inline QList<codeFragment* > promoted_getFragments() { return srecFile::getFragments(); }
1021 inline bool promoted_isopened() { return srecFile::isopened(); }
1052 inline bool promoted_isopened() { return srecFile::isopened(); }
1022 inline bool promoted_openFile(const QString& File) { return srecFile::openFile(File); }
1053 inline bool promoted_openFile(const QString& File) { return srecFile::openFile(File); }
1023 inline bool promoted_toBinary(const QString& File) { return srecFile::toBinary(File); }
1054 inline bool promoted_toBinary(const QString& File) { return srecFile::toBinary(File); }
1024 inline bool promoted_toSrec(const QString& File) { return srecFile::toSrec(File); }
1055 inline bool promoted_toSrec(const QString& File) { return srecFile::toSrec(File); }
1025 };
1056 };
1026
1057
1027 class PythonQtWrapper_srecFile : public QObject
1058 class PythonQtWrapper_srecFile : public QObject
1028 { Q_OBJECT
1059 { Q_OBJECT
1029 public:
1060 public:
1030 public slots:
1061 public slots:
1031 srecFile* new_srecFile();
1062 srecFile* new_srecFile();
1032 srecFile* new_srecFile(const QString& File);
1063 srecFile* new_srecFile(const QString& File);
1033 srecFile* new_srecFile(const QStringList& Files);
1064 srecFile* new_srecFile(const QStringList& Files);
1034 void delete_srecFile(srecFile* obj) { delete obj; }
1065 void delete_srecFile(srecFile* obj) { delete obj; }
1035 bool static_srecFile_checkSum(const QString& line);
1066 bool static_srecFile_checkSum(const QString& line);
1036 int closeFile(srecFile* theWrappedObject);
1067 int closeFile(srecFile* theWrappedObject);
1037 codeFragment* getFragment(srecFile* theWrappedObject, int index);
1068 codeFragment* getFragment(srecFile* theWrappedObject, int index);
1038 int getFragmentAddress(srecFile* theWrappedObject, int index);
1069 int getFragmentAddress(srecFile* theWrappedObject, int index);
1039 bool getFragmentData(srecFile* theWrappedObject, int index, char** buffer);
1070 bool getFragmentData(srecFile* theWrappedObject, int index, char** buffer);
1040 QString getFragmentHeader(srecFile* theWrappedObject, int index);
1071 QString getFragmentHeader(srecFile* theWrappedObject, int index);
1041 int getFragmentSize(srecFile* theWrappedObject, int index);
1072 int getFragmentSize(srecFile* theWrappedObject, int index);
1042 QList<codeFragment* > getFragments(srecFile* theWrappedObject);
1073 QList<codeFragment* > getFragments(srecFile* theWrappedObject);
1043 int getFragmentsCount(srecFile* theWrappedObject);
1074 int getFragmentsCount(srecFile* theWrappedObject);
1044 bool isSREC(srecFile* theWrappedObject);
1075 bool isSREC(srecFile* theWrappedObject);
1045 bool static_srecFile_isSREC(const QString& File);
1076 bool static_srecFile_isSREC(const QString& File);
1046 bool isopened(srecFile* theWrappedObject);
1077 bool isopened(srecFile* theWrappedObject);
1047 int lineCount(srecFile* theWrappedObject);
1078 int lineCount(srecFile* theWrappedObject);
1048 bool mergingRecords(srecFile* theWrappedObject);
1079 bool mergingRecords(srecFile* theWrappedObject);
1049 bool openFile(srecFile* theWrappedObject, const QString& File);
1080 bool openFile(srecFile* theWrappedObject, const QString& File);
1050 bool openFiles(srecFile* theWrappedObject, const QStringList& Files);
1081 bool openFiles(srecFile* theWrappedObject, const QStringList& Files);
1051 void setMergingRecords(srecFile* theWrappedObject, bool enabled);
1082 void setMergingRecords(srecFile* theWrappedObject, bool enabled);
1052 bool toBinary(srecFile* theWrappedObject, const QString& File);
1083 bool toBinary(srecFile* theWrappedObject, const QString& File);
1053 bool static_srecFile_toSrec(QList<codeFragment* > fragments, const QString& File);
1084 bool static_srecFile_toSrec(QList<codeFragment* > fragments, const QString& File);
1054 bool toSrec(srecFile* theWrappedObject, const QString& File);
1085 bool toSrec(srecFile* theWrappedObject, const QString& File);
1055 };
1086 };
1056
1087
1057
1088
1058
1089
1059
1090
1060
1091
1061 class PythonQtShell_srecFileWidget : public srecFileWidget
1092 class PythonQtShell_srecFileWidget : public srecFileWidget
1062 {
1093 {
1063 public:
1094 public:
1064 PythonQtShell_srecFileWidget(QWidget* parent = 0):srecFileWidget(parent),_wrapper(NULL) {};
1095 PythonQtShell_srecFileWidget(QWidget* parent = 0):srecFileWidget(parent),_wrapper(NULL) { };
1065
1096
1066 ~PythonQtShell_srecFileWidget();
1097 ~PythonQtShell_srecFileWidget();
1067
1098
1068 virtual void reloadFile();
1099 virtual void reloadFile();
1069 virtual void setFile(abstractBinFile* file);
1100 virtual void setFile(abstractBinFile* file);
1070
1101
1071 PythonQtInstanceWrapper* _wrapper;
1102 PythonQtInstanceWrapper* _wrapper;
1072 };
1103 };
1073
1104
1074 class PythonQtPublicPromoter_srecFileWidget : public srecFileWidget
1105 class PythonQtPublicPromoter_srecFileWidget : public srecFileWidget
1075 { public:
1106 { public:
1076 inline void promoted_reloadFile() { srecFileWidget::reloadFile(); }
1107 inline void promoted_reloadFile() { srecFileWidget::reloadFile(); }
1077 inline void promoted_setFile(abstractBinFile* file) { srecFileWidget::setFile(file); }
1108 inline void promoted_setFile(abstractBinFile* file) { srecFileWidget::setFile(file); }
1078 };
1109 };
1079
1110
1080 class PythonQtWrapper_srecFileWidget : public QObject
1111 class PythonQtWrapper_srecFileWidget : public QObject
1081 { Q_OBJECT
1112 { Q_OBJECT
1082 public:
1113 public:
1083 public slots:
1114 public slots:
1084 srecFileWidget* new_srecFileWidget(QWidget* parent = 0);
1115 srecFileWidget* new_srecFileWidget(QWidget* parent = 0);
1085 void delete_srecFileWidget(srecFileWidget* obj) { delete obj; }
1116 void delete_srecFileWidget(srecFileWidget* obj) { delete obj; }
1086 void reloadFile(srecFileWidget* theWrappedObject);
1117 void reloadFile(srecFileWidget* theWrappedObject);
1087 void setFile(srecFileWidget* theWrappedObject, abstractBinFile* file);
1118 void setFile(srecFileWidget* theWrappedObject, abstractBinFile* file);
1088 };
1119 };
1089
1120
1090
1121
Show file before | Show file after | Hide comments
@@ -1,31 +1,34
1 #include <PythonQt.h>
1 #include <PythonQt.h>
2 #include <PythonQtConversion.h>
2 #include "PySocExplorer0.h"
3 #include "PySocExplorer0.h"
3
4
4
5
6
5 void PythonQt_init_PySocExplorer(PyObject* module) {
7 void PythonQt_init_PySocExplorer(PyObject* module) {
6 PythonQt::priv()->registerClass(&ElfFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_ElfFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_ElfFile>, module, 0);
8 PythonQt::priv()->registerClass(&ElfFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_ElfFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_ElfFile>, module, 0);
7 PythonQt::self()->addParentClass("ElfFile", "abstractBinFile",PythonQtUpcastingOffset<ElfFile,abstractBinFile>());
9 PythonQt::self()->addParentClass("ElfFile", "abstractBinFile",PythonQtUpcastingOffset<ElfFile,abstractBinFile>());
8 PythonQt::priv()->registerClass(&MemSizeWdgt::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_MemSizeWdgt>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_MemSizeWdgt>, module, 0);
10 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);
11 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);
12 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);
13 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);
14 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);
15 PythonQt::priv()->registerCPPClass("XByteArray", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_XByteArray>, NULL, module, 0);
14 PythonQt::priv()->registerClass(&abstractBinFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_abstractBinFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_abstractBinFile>, module, 0);
16 PythonQt::priv()->registerClass(&abstractBinFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_abstractBinFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_abstractBinFile>, module, 0);
15 PythonQt::priv()->registerClass(&abstractBinFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_abstractBinFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_abstractBinFileWidget>, module, 0);
17 PythonQt::priv()->registerClass(&abstractBinFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_abstractBinFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_abstractBinFileWidget>, module, 0);
16 PythonQt::priv()->registerClass(&binaryFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_binaryFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_binaryFile>, module, 0);
18 PythonQt::priv()->registerClass(&binaryFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_binaryFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_binaryFile>, module, 0);
17 PythonQt::self()->addParentClass("binaryFile", "abstractBinFile",PythonQtUpcastingOffset<binaryFile,abstractBinFile>());
19 PythonQt::self()->addParentClass("binaryFile", "abstractBinFile",PythonQtUpcastingOffset<binaryFile,abstractBinFile>());
18 PythonQt::priv()->registerClass(&binaryFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_binaryFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_binaryFileWidget>, module, 0);
20 PythonQt::priv()->registerClass(&binaryFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_binaryFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_binaryFileWidget>, module, 0);
19 PythonQt::self()->addParentClass("binaryFileWidget", "abstractBinFileWidget",PythonQtUpcastingOffset<binaryFileWidget,abstractBinFileWidget>());
21 PythonQt::self()->addParentClass("binaryFileWidget", "abstractBinFileWidget",PythonQtUpcastingOffset<binaryFileWidget,abstractBinFileWidget>());
20 PythonQt::priv()->registerCPPClass("codeFragment", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_codeFragment>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_codeFragment>, module, 0);
22 PythonQt::priv()->registerCPPClass("codeFragment", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_codeFragment>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_codeFragment>, module, 0);
21 PythonQt::priv()->registerClass(&elfFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_elfFileWidget>, module, 0);
23 PythonQt::priv()->registerClass(&elfFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_elfFileWidget>, module, 0);
22 PythonQt::self()->addParentClass("elfFileWidget", "abstractBinFileWidget",PythonQtUpcastingOffset<elfFileWidget,abstractBinFileWidget>());
24 PythonQt::self()->addParentClass("elfFileWidget", "abstractBinFileWidget",PythonQtUpcastingOffset<elfFileWidget,abstractBinFileWidget>());
23 PythonQt::priv()->registerClass(&elfInfoWdgt::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfInfoWdgt>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_elfInfoWdgt>, module, 0);
25 PythonQt::priv()->registerClass(&elfInfoWdgt::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfInfoWdgt>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_elfInfoWdgt>, module, 0);
24 PythonQt::priv()->registerCPPClass("elfparser", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfparser>, NULL, module, 0);
26 PythonQt::priv()->registerCPPClass("elfparser", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfparser>, NULL, module, 0);
25 PythonQt::priv()->registerClass(&genericBinaryFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_genericBinaryFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_genericBinaryFileWidget>, module, 0);
27 PythonQt::priv()->registerClass(&genericBinaryFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_genericBinaryFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_genericBinaryFileWidget>, module, 0);
26 PythonQt::priv()->registerClass(&srecFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_srecFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_srecFile>, module, 0);
28 PythonQt::priv()->registerClass(&srecFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_srecFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_srecFile>, module, 0);
27 PythonQt::self()->addParentClass("srecFile", "abstractBinFile",PythonQtUpcastingOffset<srecFile,abstractBinFile>());
29 PythonQt::self()->addParentClass("srecFile", "abstractBinFile",PythonQtUpcastingOffset<srecFile,abstractBinFile>());
28 PythonQt::priv()->registerClass(&srecFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_srecFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_srecFileWidget>, module, 0);
30 PythonQt::priv()->registerClass(&srecFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_srecFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_srecFileWidget>, module, 0);
29 PythonQt::self()->addParentClass("srecFileWidget", "abstractBinFileWidget",PythonQtUpcastingOffset<srecFileWidget,abstractBinFileWidget>());
31 PythonQt::self()->addParentClass("srecFileWidget", "abstractBinFileWidget",PythonQtUpcastingOffset<srecFileWidget,abstractBinFileWidget>());
30
32
33
31 }
34 }
Show file before | Show file after | Hide comments
@@ -1,71 +1,75
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) 2011, Plasma Physics Laboratory - CNRS
3 -- Copyright (C) 2011, 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@lpp.polytechnique.fr
20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
21 ----------------------------------------------------------------------------*/
21 ----------------------------------------------------------------------------*/
22 #include <QApplication>
22 #include <QApplication>
23 #include "mainwindow.h"
23 #include "mainwindow.h"
24 #include <PythonQt.h>
24 #include <PythonQt.h>
25 #include <PythonQt_QtAll.h>
25 #include <PythonQt_QtAll.h>
26 #include <gui/PythonQtScriptingConsole.h>
26 #include <gui/PythonQtScriptingConsole.h>
27 #include <socexplorerplugin.h>
27 #include <socexplorerplugin.h>
28 #include <QStyle>
28 #include <QStyle>
29 #include <QStyleFactory>
29 #include <QStyleFactory>
30 #include <QStringList>
30 #include <QStringList>
31 #include <QFile>
31 #include <QFile>
32
32
33 void usage();
33
34
34 int main(int argc, char *argv[])
35 int main(int argc, char *argv[])
35 {
36 {
36 // Q_INIT_RESOURCE(socexplorer);
37 #ifdef Q_OS_LINUX
38 // QApplication::setGraphicsSystem("raster");
39 #endif
40 QApplication a(argc, argv);
37 QApplication a(argc, argv);
41 QString scriptToEval;
38 QString scriptToEval;
42 QStringList args= a.arguments();
39 QStringList args= a.arguments();
43 for(int i=0;i<args.count()-1;i++)
40 for(int i=0;i<args.count()-1;i++)
44 {
41 {
45 if((args.at(i).compare("-e")==0) || (args.at(i).compare("--execute")==0))
42 if((args.at(i).compare("-e")==0) || (args.at(i).compare("--execute")==0))
46 {
43 {
47 scriptToEval = args.at(i+1);
44 scriptToEval = args.at(i+1);
48 if(!QFile::exists(scriptToEval))
45 if(!QFile::exists(scriptToEval))
49 {
46 {
50 scriptToEval.clear();
47 scriptToEval.clear();
51 }
48 }
52 else
49 else
53 qDebug() << "Will execute" << scriptToEval;
50 qDebug() << "Will execute" << scriptToEval;
54 break;
51 break;
55 }
52 }
56 if((args.at(i).compare("-d")==0) || (args.at(i).compare("--debug-level")==0))
53 if((args.at(i).compare("-d")==0) || (args.at(i).compare("--debug-level")==0))
57 {
54 {
58 bool success;
55 bool success;
59 int lvl;
56 int lvl;
60 lvl = args.at(i+1).toInt(&success,10);
57 lvl = args.at(i+1).toInt(&success,10);
61 if(success)
58 if(success)
62 {
59 {
63 SocExplorerEngine::setLogLevel(lvl);
60 SocExplorerEngine::setLogLevel(lvl);
64 }
61 }
65 }
62 }
66 }
63 }
67
64
68 SocExplorerMainWindow w(scriptToEval);
65 SocExplorerMainWindow w(scriptToEval);
69 w.show();
66 w.show();
70 return a.exec();
67 return a.exec();
71 }
68 }
69
70
71 void usage()
72 {
73 // TODO respect usual Linux Cli interface, socexplore [OPTION]...FILES...
74 // TODO write an usage helper.
75 }
Show file before | Show file after | Hide comments
@@ -1,242 +1,242
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) 2011, Plasma Physics Laboratory - CNRS
3 -- Copyright (C) 2011, 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@lpp.polytechnique.fr
20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
21 ----------------------------------------------------------------------------*/
21 ----------------------------------------------------------------------------*/
22 #include "mainwindow.h"
22 #include "mainwindow.h"
23 #include <QDockWidget>
23 #include <QDockWidget>
24
24
25 SocExplorerMainWindow::SocExplorerMainWindow(QString ScriptToEval, QWidget *parent)
25 SocExplorerMainWindow::SocExplorerMainWindow(QString ScriptToEval, QWidget *parent)
26 : QMainWindow(parent)
26 : QMainWindow(parent)
27 {
27 {
28 QCoreApplication::setApplicationName("SocExplorer");
28 QCoreApplication::setApplicationName("SocExplorer");
29 QCoreApplication::setOrganizationName("LPP");
29 QCoreApplication::setOrganizationName("LPP");
30 QCoreApplication::setOrganizationDomain("lpp.fr");
30 QCoreApplication::setOrganizationDomain("lpp.fr");
31 this->makeObjects(ScriptToEval);
31 this->makeObjects(ScriptToEval);
32 this->makeLayout();
32 this->makeLayout();
33 this->makeMenu();
33 this->makeMenu();
34 this->makeConnections();
34 this->makeConnections();
35 this->setWindowIcon(QIcon(tr(":/images/icon.png")));
35 this->setWindowIcon(QIcon(":/images/icon.png"));
36 this->setAcceptDrops(true);
36 this->setAcceptDrops(true);
37 this->pluginManager->setRootLoadable(true);
37 this->pluginManager->setRootLoadable(true);
38 this->PythonConsoleInst->pyConsoleRunFile(ScriptToEval);
38 this->PythonConsoleInst->pyConsoleRunFile(ScriptToEval);
39 QFile file(":/styles/SocExplorer.css");
39 QFile file(":/styles/SocExplorer.css");
40 if(file.open(QIODevice::ReadOnly | QIODevice::Text))
40 if(file.open(QIODevice::ReadOnly | QIODevice::Text))
41 {
41 {
42 qApp->setStyleSheet(file.readAll());
42 qApp->setStyleSheet(file.readAll());
43 file.close();
43 file.close();
44 }
44 }
45 }
45 }
46
46
47
47
48 void SocExplorerMainWindow::makeObjects(QString ScriptToEval)
48 void SocExplorerMainWindow::makeObjects(QString ScriptToEval)
49 {
49 {
50 Q_UNUSED(ScriptToEval)
50 Q_UNUSED(ScriptToEval)
51 this->p_pluginGUIlist = new QList<QDockWidget*>();
51 this->p_pluginGUIlist = new QList<QDockWidget*>();
52 pluginsDockContainer = new QMainWindow;
52 pluginsDockContainer = new QMainWindow;
53 pluginsDockContainer->setWindowFlags(Qt::Widget);
53 pluginsDockContainer->setWindowFlags(Qt::Widget);
54 pluginsDockContainer->setDockNestingEnabled(true);
54 pluginsDockContainer->setDockNestingEnabled(true);
55 this->mainWidget = new QSplitter(Qt::Vertical);
55 this->mainWidget = new QSplitter(Qt::Vertical);
56 this->appTranslator = new QTranslator;
56 this->appTranslator = new QTranslator;
57 this->Quit = new QAction(tr("&Quit"),this);
57 this->Quit = new QAction(tr("&Quit"),this);
58 this->Quit->setShortcut(tr("CTRL+Q"));
58 this->Quit->setShortcut(tr("CTRL+Q"));
59 this->ManagePlugins = new QAction(tr("&Manage Plugins"),this);
59 this->ManagePlugins = new QAction(tr("&Manage Plugins"),this);
60 this->ManagePlugins->setShortcut(tr("CTRL+P"));
60 this->ManagePlugins->setShortcut(tr("CTRL+P"));
61 this->regsManager = new QAction(tr("&Manage registers"),this);
61 this->regsManager = new QAction(tr("&Manage registers"),this);
62 this->exploreRegs = new QAction(tr("&Explore registers"),this);
62 this->exploreRegs = new QAction(tr("&Explore registers"),this);
63 this->help = new QAction(tr("&Help"),this);
63 this->help = new QAction(tr("&Help"),this);
64 this->help->setShortcut(tr("CTRL+H"));
64 this->help->setShortcut(tr("CTRL+H"));
65 this->about = new QAction(tr("&About"),this);
65 this->about = new QAction(tr("&About"),this);
66 socexplorerproxy::setMainWindow(this);
66 socexplorerproxy::setMainWindow(this);
67 SocExplorerEngine::setMainWindow(this);
67 SocExplorerEngine::setMainWindow(this);
68 SocExplorerEngine::xmlModel()->scanXmlFiles();
68 SocExplorerEngine::xmlModel()->scanXmlFiles();
69 this->regExplorer = new regsExplorer();
69 this->regExplorer = new regsExplorer();
70 this->regExplorer->setAllowedAreas(Qt::AllDockWidgetAreas);
70 this->regExplorer->setAllowedAreas(Qt::AllDockWidgetAreas);
71 this->addPluginInterface(this->regExplorer);
71 this->addPluginInterface(this->regExplorer);
72 this->PythonConsoleInst = new PythonConsole(socexplorerproxy::self());
72 this->PythonConsoleInst = new PythonConsole(socexplorerproxy::self());
73 this->PythonConsoleInst->addObject("SocExplorerEngine",SocExplorerEngine::self());
73 this->PythonConsoleInst->addObject("SocExplorerEngine",SocExplorerEngine::self());
74 this->pluginManager = new dockablePluginManager();
74 this->pluginManager = new dockablePluginManager();
75 this->toolpane = new toolBar;
75 this->toolpane = new toolBar;
76 this->p_about = new aboutsocexplorer();
76 this->p_about = new aboutsocexplorer();
77
77
78 }
78 }
79
79
80 void SocExplorerMainWindow::makeLayout()
80 void SocExplorerMainWindow::makeLayout()
81 {
81 {
82 this->mainWidget->addWidget(pluginsDockContainer);
82 this->mainWidget->addWidget(pluginsDockContainer);
83 this->mainWidget->addWidget(this->PythonConsoleInst);
83 this->mainWidget->addWidget(this->PythonConsoleInst);
84 this->toolpane->setAllowedAreas(Qt::RightDockWidgetArea|Qt::LeftDockWidgetArea);
84 this->toolpane->setAllowedAreas(Qt::RightDockWidgetArea|Qt::LeftDockWidgetArea);
85 this->addDockWidget(Qt::LeftDockWidgetArea,this->toolpane);
85 this->addDockWidget(Qt::LeftDockWidgetArea,this->toolpane);
86 this->toolpane->addTool(this->pluginManager);
86 this->toolpane->addTool(this->pluginManager);
87 this->setCentralWidget(this->mainWidget);
87 this->setCentralWidget(this->mainWidget);
88 }
88 }
89
89
90
90
91 void SocExplorerMainWindow::makeConnections()
91 void SocExplorerMainWindow::makeConnections()
92 {
92 {
93 connect(socexplorerproxy::self(),SIGNAL(clearMenu()),this,SLOT(clearMenu()));
93 connect(socexplorerproxy::self(),SIGNAL(clearMenu()),this,SLOT(clearMenu()));
94 connect(this,SIGNAL(translateSig()),socexplorerproxy::self(),SLOT(updateText()));
94 connect(this,SIGNAL(translateSig()),socexplorerproxy::self(),SLOT(updateText()));
95 connect(socexplorerproxy::self(),SIGNAL(addPluginGUI(QDockWidget*)),this,SLOT(addPluginInterface(QDockWidget*)));
95 connect(socexplorerproxy::self(),SIGNAL(addPluginGUI(QDockWidget*)),this,SLOT(addPluginInterface(QDockWidget*)));
96 connect(socexplorerproxy::self(),SIGNAL(removePluginGUI(QDockWidget*)),this,SLOT(removePluginInterface(QDockWidget*)));
96 connect(socexplorerproxy::self(),SIGNAL(removePluginGUI(QDockWidget*)),this,SLOT(removePluginInterface(QDockWidget*)));
97 connect(this->ManagePlugins,SIGNAL(triggered()),this,SLOT(launchPluginManager()));
97 connect(this->ManagePlugins,SIGNAL(triggered()),this,SLOT(launchPluginManager()));
98 connect(this->Quit,SIGNAL(triggered()),qApp,SLOT(quit()));
98 connect(this->Quit,SIGNAL(triggered()),qApp,SLOT(quit()));
99 connect(this,SIGNAL(registerObject(QObject*,QString)),this->PythonConsoleInst,SLOT(registerObject(QObject*,QString)));
99 connect(this,SIGNAL(registerObject(QObject*,QString)),this->PythonConsoleInst,SLOT(registerObject(QObject*,QString)));
100 connect(socexplorerproxy::self(),SIGNAL(registerObject(QObject*,QString)),this,SIGNAL(registerObject(QObject*,QString)));
100 connect(socexplorerproxy::self(),SIGNAL(registerObject(QObject*,QString)),this,SIGNAL(registerObject(QObject*,QString)));
101 connect(this->pluginManager,SIGNAL(geteplugintree()),socexplorerproxy::self(),SLOT(geteplugintree()));
101 connect(this->pluginManager,SIGNAL(geteplugintree()),socexplorerproxy::self(),SLOT(geteplugintree()));
102 connect(socexplorerproxy::self(),SIGNAL(treeChanged(QList<socexplorerplugin*>)),this->pluginManager,SIGNAL(treeChanged(QList<socexplorerplugin*>)));
102 connect(socexplorerproxy::self(),SIGNAL(treeChanged(QList<socexplorerplugin*>)),this->pluginManager,SIGNAL(treeChanged(QList<socexplorerplugin*>)));
103 connect(this->pluginManager,SIGNAL(changeSysDriverInstName(QString,QString)),socexplorerproxy::self(),SLOT(changeSysDriverInstName(QString,QString)));
103 connect(this->pluginManager,SIGNAL(changeSysDriverInstName(QString,QString)),socexplorerproxy::self(),SLOT(changeSysDriverInstName(QString,QString)));
104 connect(this->pluginManager,SIGNAL(changeSysDriverInstName(QString,QString)),this->PythonConsoleInst,SLOT(changeSysDriverInstName(QString,QString)));
104 connect(this->pluginManager,SIGNAL(changeSysDriverInstName(QString,QString)),this->PythonConsoleInst,SLOT(changeSysDriverInstName(QString,QString)));
105 connect(this->pluginManager,SIGNAL(closeSysDriver(QString)),socexplorerproxy::self(),SLOT(closeSysDriver(QString)));
105 connect(this->pluginManager,SIGNAL(closeSysDriver(QString)),socexplorerproxy::self(),SLOT(closeSysDriver(QString)));
106 connect(this->pluginManager,SIGNAL(closeSysDriver(QString)),this->PythonConsoleInst,SLOT(removeDriver(QString)));
106 connect(this->pluginManager,SIGNAL(closeSysDriver(QString)),this->PythonConsoleInst,SLOT(removeDriver(QString)));
107 connect(this->pluginManager,SIGNAL(pluginselected(QString)),this,SLOT(pluginselected(QString)));
107 connect(this->pluginManager,SIGNAL(pluginselected(QString)),this,SLOT(pluginselected(QString)));
108 connect(this->about,SIGNAL(triggered()),this,SLOT(showAboutBox()));
108 connect(this->about,SIGNAL(triggered()),this,SLOT(showAboutBox()));
109 connect(this->exploreRegs,SIGNAL(triggered()),this->regExplorer,SLOT(show()));
109 connect(this->exploreRegs,SIGNAL(triggered()),this->regExplorer,SLOT(show()));
110
110
111 this->pluginManager->connect(this->pluginManager,SIGNAL(loadSysDrviver(QString)),socexplorerproxy::self(),SLOT(loadSysDriver(QString)));
111 this->pluginManager->connect(this->pluginManager,SIGNAL(loadSysDrviver(QString)),socexplorerproxy::self(),SLOT(loadSysDriver(QString)));
112 this->pluginManager->connect(this->pluginManager,SIGNAL(loadSysDriverToParent(QString,QString)),socexplorerproxy::self(),SLOT(loadSysDriverToParent(QString,QString)));
112 this->pluginManager->connect(this->pluginManager,SIGNAL(loadSysDriverToParent(QString,QString)),socexplorerproxy::self(),SLOT(loadSysDriverToParent(QString,QString)));
113
113
114 }
114 }
115
115
116
116
117 void SocExplorerMainWindow::launchPluginManager()
117 void SocExplorerMainWindow::launchPluginManager()
118 {
118 {
119
119
120 if(this->pluginManager->isHidden())
120 if(this->pluginManager->isHidden())
121 {
121 {
122 this->pluginManager->setHidden(false);
122 this->pluginManager->setHidden(false);
123 }
123 }
124
124
125 }
125 }
126
126
127
127
128 void SocExplorerMainWindow::addPluginInterface(QDockWidget *plugin)
128 void SocExplorerMainWindow::addPluginInterface(QDockWidget *plugin)
129 {
129 {
130 plugin->setAllowedAreas(Qt::AllDockWidgetAreas);
130 plugin->setAllowedAreas(Qt::AllDockWidgetAreas);
131 this->pluginsDockContainer->addDockWidget(Qt::TopDockWidgetArea,plugin);
131 this->pluginsDockContainer->addDockWidget(Qt::TopDockWidgetArea,plugin);
132 if(p_pluginGUIlist->count()!=0)
132 if(p_pluginGUIlist->count()!=0)
133 this->pluginsDockContainer->tabifyDockWidget(p_pluginGUIlist->last(),plugin);
133 this->pluginsDockContainer->tabifyDockWidget(p_pluginGUIlist->last(),plugin);
134 p_pluginGUIlist->append(plugin);
134 p_pluginGUIlist->append(plugin);
135
135
136 }
136 }
137
137
138 void SocExplorerMainWindow::removePluginInterface(QDockWidget *plugin)
138 void SocExplorerMainWindow::removePluginInterface(QDockWidget *plugin)
139 {
139 {
140 p_pluginGUIlist->removeOne(plugin);
140 p_pluginGUIlist->removeOne(plugin);
141 this->pluginsDockContainer->removeDockWidget(plugin);
141 this->pluginsDockContainer->removeDockWidget(plugin);
142 }
142 }
143
143
144
144
145 void SocExplorerMainWindow::clearMenu()
145 void SocExplorerMainWindow::clearMenu()
146 {
146 {
147 this->menuBar()->clear();
147 this->menuBar()->clear();
148 this->makeMenu();
148 this->makeMenu();
149 }
149 }
150
150
151
151
152 void SocExplorerMainWindow::makeMenu()
152 void SocExplorerMainWindow::makeMenu()
153 {
153 {
154 this->FileMenu = menuBar()->addMenu(tr("&File"));
154 this->FileMenu = menuBar()->addMenu(tr("&File"));
155 this->PluginsMenu = menuBar()->addMenu(tr("&Plugins"));
155 this->PluginsMenu = menuBar()->addMenu(tr("&Plugins"));
156 this->ToolsMenu = menuBar()->addMenu(tr("&Tools"));
156 this->ToolsMenu = menuBar()->addMenu(tr("&Tools"));
157 this->ToolsMenu->addAction(this->exploreRegs);
157 this->ToolsMenu->addAction(this->exploreRegs);
158 this->FileMenu->addAction(this->Quit);
158 this->FileMenu->addAction(this->Quit);
159 socexplorerproxy::self()->makeMenu(this->PluginsMenu);
159 socexplorerproxy::self()->makeMenu(this->PluginsMenu);
160 this->PluginsMenu->addAction(this->ManagePlugins);
160 this->PluginsMenu->addAction(this->ManagePlugins);
161
161
162 this->helpMenu = menuBar()->addMenu(tr("Help"));
162 this->helpMenu = menuBar()->addMenu(tr("Help"));
163 this->helpMenu->addAction(this->help);
163 this->helpMenu->addAction(this->help);
164 this->helpMenu->addAction(this->about);
164 this->helpMenu->addAction(this->about);
165
165
166 }
166 }
167
167
168
168
169 SocExplorerMainWindow::~SocExplorerMainWindow()
169 SocExplorerMainWindow::~SocExplorerMainWindow()
170 {
170 {
171 }
171 }
172
172
173
173
174 void SocExplorerMainWindow::setLangage(QAction *action)
174 void SocExplorerMainWindow::setLangage(QAction *action)
175 {
175 {
176 QString local = action->data().toString();
176 QString local = action->data().toString();
177 QString qmPath = QDir(QString("translations")).absolutePath();
177 QString qmPath = QDir(QString("translations")).absolutePath();
178 appTranslator->load(qmPath+"/socexplorer_"+local+".qm");
178 appTranslator->load(qmPath+"/socexplorer_"+local+".qm");
179 qApp->installTranslator(appTranslator);
179 qApp->installTranslator(appTranslator);
180 emit this->translateSig();
180 emit this->translateSig();
181 }
181 }
182
182
183
183
184 void SocExplorerMainWindow::createLangMenu()
184 void SocExplorerMainWindow::createLangMenu()
185 {
185 {
186 this->langMenu = menuBar()->addMenu(tr("&Langue"));
186 this->langMenu = menuBar()->addMenu(tr("&Langue"));
187 this->langActionGrp = new QActionGroup(this);
187 this->langActionGrp = new QActionGroup(this);
188 connect(this->langActionGrp,SIGNAL(triggered(QAction*)),this,SLOT(setLangage(QAction*)));
188 connect(this->langActionGrp,SIGNAL(triggered(QAction*)),this,SLOT(setLangage(QAction*)));
189 QDir* qmDir = new QDir(QString("translations"));
189 QDir* qmDir = new QDir(QString("translations"));
190 QStringList LangFiles = qmDir->entryList(QStringList("socexplorer_*.qm"));
190 QStringList LangFiles = qmDir->entryList(QStringList("socexplorer_*.qm"));
191 for(int i=0;i<LangFiles.size();++i)
191 for(int i=0;i<LangFiles.size();++i)
192 {
192 {
193 QString Local = LangFiles[i];
193 QString Local = LangFiles[i];
194 Local.remove(0,Local.indexOf('_')+1);
194 Local.remove(0,Local.indexOf('_')+1);
195 Local.chop(3);
195 Local.chop(3);
196 QTranslator translator;
196 QTranslator translator;
197 translator.load(LangFiles[i],qmDir->absolutePath());
197 translator.load(LangFiles[i],qmDir->absolutePath());
198 QString langage = translator.translate("MainWindow","English");
198 QString langage = translator.translate("MainWindow","English");
199 QAction *action = new QAction(tr("&%1 %2").arg(i+1).arg(langage),this);
199 QAction *action = new QAction(tr("&%1 %2").arg(i+1).arg(langage),this);
200 action->setCheckable(true);
200 action->setCheckable(true);
201 action->setData(Local);
201 action->setData(Local);
202 langMenu->addAction(action);
202 langMenu->addAction(action);
203 langActionGrp->addAction(action);
203 langActionGrp->addAction(action);
204 if(langage==tr("English"))
204 if(langage==tr("English"))
205 action->setChecked(true);
205 action->setChecked(true);
206 }
206 }
207 }
207 }
208
208
209
209
210 void SocExplorerMainWindow::updateText()
210 void SocExplorerMainWindow::updateText()
211 {
211 {
212 emit this->translateSig();
212 emit this->translateSig();
213 }
213 }
214
214
215
215
216
216
217 void SocExplorerMainWindow::showAboutBox()
217 void SocExplorerMainWindow::showAboutBox()
218 {
218 {
219 p_about->show();
219 p_about->show();
220 }
220 }
221
221
222 void SocExplorerMainWindow::pluginselected(const QString &instanceName)
222 void SocExplorerMainWindow::pluginselected(const QString &instanceName)
223 {
223 {
224 socexplorerplugin* drv=socexplorerproxy::self()->getSysDriver(instanceName);
224 socexplorerplugin* drv=socexplorerproxy::self()->getSysDriver(instanceName);
225 if(drv)
225 if(drv)
226 drv->raise();
226 drv->raise();
227 }
227 }
228
228
229
229
230
230
231 void SocExplorerMainWindow::closeEvent(QCloseEvent *event)
231 void SocExplorerMainWindow::closeEvent(QCloseEvent *event)
232 {
232 {
233 socexplorerproxy::self()->close();
233 socexplorerproxy::self()->close();
234 qApp->closeAllWindows();
234 qApp->closeAllWindows();
235 event->accept();
235 event->accept();
236 }
236 }
237
237
238
238
239
239
240
240
241
241
242
242
General Comments 0
You need to be logged in to leave comments. Login now