##// 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 1 2c82d72694590cbc2aebb946667f11f60ea89afe src/SocExplorerEngine/PeripheralWidget
2 e0f25227d6283e833fbb70c5fc1bdc6c3ca8060e src/common/genericBinaryFiles
2 cc958c79ba0939809a70e63b8bac798930160243 src/common/genericBinaryFiles
3 3 2dce25b198558be573f56c1cf337aa95ddd666d6 src/common/lppserial
4 4 923afde9cc96bb419cf898560d080ec96991aeca src/common/qhexedit
Show file before | Show file after | Hide comments
@@ -1,22 +1,23
1 1
2 2 QT += core gui xml svg network
3 3 contains(QT_MAJOR_VERSION, 5) {
4 4 QT += widgets
5 5 QT += printsupport
6 QT += multimedia multimediawidgets
6 7 }
7 8
8 9 SOCEXPLORER_SDK_BUILD="SOCEXPLORER_SDK_BUILD"
9 10 DEFINES += SOCEXPLORER_SDK_BUILD
10 11
11 12 MOC_DIR = moc
12 13 RCC_DIR = resources
13 14 OBJECTS_DIR = obj
14 15
15 16 win32:DESTDIR = $${SOCEXPLORER_ROOT}/bin/win32/
16 17 unix:DESTDIR = $${SOCEXPLORER_ROOT}/bin/linux/
17 18
18 19
19 20 metrics_cccc.target = metrics_cccc
20 21 metrics_cccc.commands = cccc $(SOURCES) $(HEADERS)
21 22
22 23 QMAKE_EXTRA_TARGETS += metrics_cccc
Show file before | Show file after | Hide comments
@@ -1,112 +1,118
1 1 /*------------------------------------------------------------------------------
2 2 -- This file is a part of the SocExplorer Software
3 3 -- Copyright (C) 2013, Plasma Physics Laboratory - CNRS
4 4 --
5 5 -- This program is free software; you can redistribute it and/or modify
6 6 -- it under the terms of the GNU General Public License as published by
7 7 -- the Free Software Foundation; either version 2 of the License, or
8 8 -- (at your option) any later version.
9 9 --
10 10 -- This program is distributed in the hope that it will be useful,
11 11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 13 -- GNU General Public License for more details.
14 14 --
15 15 -- You should have received a copy of the GNU General Public License
16 16 -- along with this program; if not, write to the Free Software
17 17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 18 -------------------------------------------------------------------------------*/
19 19 /*-- Author : Alexis Jeandet
20 20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
21 21 ----------------------------------------------------------------------------*/
22 22 #include "socmodel.h"
23 23 #include <socexplorerenumdevice.h>
24 24
25 25
26 26 SOCModel::SOCModel(socexplorerplugin *rootDev, QObject *parent):
27 27 QObject(parent)
28 28 {
29 29 p_rootDev = rootDev;
30 p_litleEndian = false;
30 31 }
31 32
32 33 qint32 SOCModel::getEnumDeviceBaseAddress(int VID, int PID, int count)
33 34 {
34 35 for(int i=0;i<p_enumeratedDevices.count();i++)
35 36 {
36 37 if((p_enumeratedDevices.at(i)->VID()==VID) && (p_enumeratedDevices.at(i)->PID()==PID))
37 38 {
38 39 if(count==0)
39 40 {
40 41 return p_enumeratedDevices.at(i)->baseAddress();
41 42 }
42 43 count--;
43 44 }
44 45 }
45 46 return -1;
46 47 }
47 48
48 49 qint32 SOCModel::getEnumDeviceCount(int VID, int PID)
49 50 {
50 51 qint32 count =0;
51 52 for(int i=0;i<p_enumeratedDevices.count();i++)
52 53 {
53 54 if((p_enumeratedDevices.at(i)->VID()==VID) && (p_enumeratedDevices.at(i)->PID()==PID))
54 55 {
55 56 count++;
56 57 }
57 58 }
58 59 return count;
59 60 }
60 61
61 62 socExplorerEnumDevice *SOCModel::addEnumDevice( int VID, int PID, qint32 baseAddress, const QString &name)
62 63 {
63 64 if(enumDeviceExists(baseAddress))
64 65 return getEnumDevice(baseAddress);
65 66 socExplorerEnumDevice* device= new socExplorerEnumDevice(this,VID,PID,baseAddress,name);
66 67 p_enumeratedDevices.append(device);
67 68 return device;
68 69 }
69 70
70 71 int SOCModel::addEnumDevice(socExplorerEnumDevice *device)
71 72 {
72 73 if(enumDeviceExists(device->baseAddress()))
73 74 return 0;
74 75 p_enumeratedDevices.append(device);
75 76 return 1;
76 77 }
77 78
78 79
79 80
80 81 bool SOCModel::enumDeviceExists(qint32 baseAddress)
81 82 {
82 83 for(int i=0;i<p_enumeratedDevices.count();i++)
83 84 {
84 85 if(p_enumeratedDevices.at(i)->baseAddress()==baseAddress)
85 86 return true;
86 87 }
87 88 return false;
88 89 }
89 90
90 91 socExplorerEnumDevice *SOCModel::getEnumDevice(qint32 baseAddress)
91 92 {
92 93 for(int i=0;i<p_enumeratedDevices.count();i++)
93 94 {
94 95 if(p_enumeratedDevices.at(i)->baseAddress()==baseAddress)
95 96 return p_enumeratedDevices.at(i);
96 97 }
97 98 return NULL;
98 99 }
99 100
100 101
101 102 void SOCModel::writeReg(qint32 address, qint32 value)
102 103 {
103 104 uint valueInt=value,addressInt=address;
104 105 p_rootDev->Write(&valueInt,1,addressInt);
105 106 }
106 107
107 108 qint32 SOCModel::readReg(qint32 address)
108 109 {
109 110 uint valueInt=0,addressInt=address;
110 111 p_rootDev->Read(&valueInt,1,addressInt);
111 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 2 -- This file is a part of the SocExplorer Software
3 3 -- Copyright (C) 2013, Plasma Physics Laboratory - CNRS
4 4 --
5 5 -- This program is free software; you can redistribute it and/or modify
6 6 -- it under the terms of the GNU General Public License as published by
7 7 -- the Free Software Foundation; either version 2 of the License, or
8 8 -- (at your option) any later version.
9 9 --
10 10 -- This program is distributed in the hope that it will be useful,
11 11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 13 -- GNU General Public License for more details.
14 14 --
15 15 -- You should have received a copy of the GNU General Public License
16 16 -- along with this program; if not, write to the Free Software
17 17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 18 -------------------------------------------------------------------------------*/
19 19 /*-- Author : Alexis Jeandet
20 20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
21 21 ----------------------------------------------------------------------------*/
22 22
23 23 #ifndef REGISTERSMODEL_H
24 24 #define REGISTERSMODEL_H
25 25 #include <QString>
26 26 #include <QList>
27 27 #include <QObject>
28 28 #include <QDomDocument>
29 29 #include <QDomElement>
30 30 #include "registerdata.h"
31 31 #include <socclk.h>
32 32 #include <socexplorerplugin.h>
33 33 class socExplorerEnumDevice;
34 34
35 35 class registerBitFieldModel
36 36 {
37 37 public:
38 38 registerBitFieldModel(const QString& name,const QString& description,
39 39 int size, int offset, bool rw)
40 40 {
41 41 this->name = name;
42 42 this->description = description;
43 43 this->size = size;
44 44 this->offset = offset;
45 45 this->rw = rw;
46 46 }
47 47 QString name;
48 48 QString description;
49 49 int size;
50 50 int offset;
51 51 bool rw;
52 52 };
53 53
54 54 class registerModel
55 55 {
56 56 public:
57 57 registerModel(const QString& name,qint32 offset)
58 58 {
59 59 this->name = name;
60 60 this->offset = offset;
61 61 }
62 62 QString name;
63 63 qint32 offset;
64 64 QList<registerBitFieldModel> bitfields;
65 65 };
66 66
67 67 class peripheralModel
68 68 {
69 69 public:
70 70 peripheralModel(const QString& name)
71 71 {
72 72 this->name = name;
73 73 }
74 74 QString name;
75 75 QList<registerModel> registers;
76 76 };
77 77
78 78
79 79 class SOCEXPLORER_EXPORT SOCModel :public QObject
80 80 {
81 81 Q_OBJECT
82 82 public:
83 83 SOCModel(socexplorerplugin* rootDev,QObject* parent=0);
84 84 bool isRootDev(socexplorerplugin* rootDev)
85 85 {
86 86 return rootDev==p_rootDev;
87 87 }
88 88 bool enumDeviceExists(qint32 baseAddress);
89 89 socExplorerEnumDevice *getEnumDevice(qint32 baseAddress);
90 90 public slots:
91 91 qint32 getEnumDeviceBaseAddress(int VID,int PID,int count=0);
92 92 qint32 getEnumDeviceCount(int VID,int PID);
93 93 socExplorerEnumDevice* addEnumDevice(int VID, int PID, qint32 baseAddress, const QString& name);
94 94 int addEnumDevice(socExplorerEnumDevice* device);
95 95 void writeReg(qint32 address,qint32 value);
96 96 qint32 readReg(qint32 address);
97 bool isLitleEndian();
97 98 private:
98 99 socexplorerplugin* p_rootDev;
99 100 QList<socExplorerEnumDevice*> p_enumeratedDevices;
100 101 QList<SOCclk*> clktree;
102 bool p_litleEndian;
101 103 };
102 104
103 105
104 106
105 107
106 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 1 SOCEXPLORER_ROOT = \"$${PWD}/../..\"
2 2
3 3 include($${PWD}/../../build_cfg/socexplorer.pri)
4 4
5 5 TARGET = socexplorerengine$${DEBUG_EXT}
6 6 TEMPLATE = lib
7 7
8 8 #more verbose plugin loader to debug plugin loading issues such as dependencies issues
9 9 SOCEXPLORER_PLUGIN_LOADER="custom"
10 10
11 11 SOCEXPLORER_CHAGESETNUM=$$system(hg id)
12 12 isEmpty(SOCEXPLORER_CHAGESETNUM){
13 13 SOCEXPLORER_CHAGESETNUM=6e5eaa13fad9
14 14 }
15 15 SOCEXPLORER_CHAGESETNUMSTR = '\\"$${SOCEXPLORER_CHAGESETNUM}\\"'
16 16 SOCEXPLORER_BRANCH=$$system(hg branch)
17 17 isEmpty(SOCEXPLORER_BRANCH){
18 18 SOCEXPLORER_BRANCH=default
19 19 }
20 20 SOCEXPLORER_BRANCHSTR = '\\"$${SOCEXPLORER_BRANCH}\\"'
21 21
22 22 DEFINES += SOCEXPLORER_VERSION="\"\\\"0.4.4"\\\"\"
23 23 DEFINES += SOCEXPLORER_CHAGESET=\"$${SOCEXPLORER_CHAGESETNUMSTR}\"
24 24 DEFINES += SOCEXPLORER_BRANCH=\"$${SOCEXPLORER_BRANCHSTR}\"
25 25
26 26
27 27 message("Building SOCEXPLORER changeset $${SOCEXPLORER_CHAGESETNUM}")
28 28
29 29 DEFINES += SOCEXPLORER_EXPORTS
30 30
31 31 include ( plugins/socexplorerplugin.prf )
32 32 include ( PeripheralWidget/PeripheralWidget.pri)
33 33
34 34 win32:CONFIG += dll
35 35 win32:CONFIG -= static
36 36 win32:LIBS+=-L$${SOCEXPLORER_ROOT}/bin/win32 -lsocexplorercommon$${DEBUG_EXT}
37 37
38 38 contains(SOCEXPLORER_PLUGIN_LOADER,"custom")
39 39 {
40 40 unix:LIBS+= -ldl
41 41 unix:DEFINES += SOCEXPLORER_CUSTOM_PLUGIN_LOADER
42 42 unix:HEADERS += \
43 43 pluginloader/unix/unixpluginloader.h
44 44 unix:SOURCES += \
45 45 pluginloader/unix/unixpluginloader.cpp
46 46 }
47 47
48 48 target.path = $$[QT_INSTALL_LIBS]
49 49 isEmpty(target.path) {
50 50 error(can\'t get QT_INSTALL_LIBS)
51 51 }
52 52
53 53 header.path = $$[QT_INSTALL_HEADERS]/SocExplorer
54 54 header.files = engine/socexplorerengine.h \
55 55 pluginloader/pluginscache.h \
56 56 plugins/socexplorerplugin.h \
57 57 proxy/socexplorerproxy.h \
58 58 engine/socexplorerxmlfile.h \
59 59 SOC/socexplorerenumdevice.h \
60 60 plugins/genericPySysdriver.h \
61 61 XmlEngine/XMLmodel.h \
62 62 XmlEngine/XMLdata.h \
63 63 XmlEngine/xmldriver.h \
64 64 SOC/socmodel.h \
65 65 SOC/registerdata.h \
66 66 SOC/socclk.h \
67 67 PeripheralWidget/src/peripheralwidget.h \
68 68 PeripheralWidget/src/registerwidget.h \
69 69 PeripheralWidget/src/socregsviewer.h
70 70
71 71
72 72
73 73 isEmpty(header.path) {
74 74 error(can\'t get QT_INSTALL_HEADERS)
75 75 }
76 76
77 77 pluginif.files = pluginsInterface/*.h \
78 78 pluginsInterface/*.cpp
79 79
80 80 pluginif.path = $$[QT_INSTALL_HEADERS]/SocExplorer/pluginsInterface
81 81
82 82
83 83 INSTALLS += target header pluginif
84 84
85 85 INCLUDEPATH += engine \
86 86 pluginloader \
87 87 pluginsInterface \
88 88 proxy \
89 89 plugins \
90 90 pluginManagerWdgt \
91 91 ../common \
92 ../common/genericBinaryFiles \
92 93 ../ \
93 94 RegisterMVS \
94 95 XmlEngine \
95 96 SOC \
96 97 PeripheralWidget/src
97 98
98 99
99 100 HEADERS += \
100 101 pluginloader/pluginscache.h \
101 102 pluginloader/pluginloader.h \
102 103 plugins/genericPySysdriver.h \
103 104 pluginManagerWdgt/plugintree.h \
104 105 pluginManagerWdgt/pluginmanagerWDGT.h \
105 106 pluginManagerWdgt/pluginlist.h \
106 107 pluginManagerWdgt/plugininfoswdgt.h \
107 108 XmlEngine/XMLmodel.h \
108 109 XmlEngine/XMLdata.h \
109 110 SOC/socmodel.h \
110 111 SOC/registerdata.h \
111 112 XmlEngine/xmldriver.h \
112 113 PeripheralWidget/src/peripheralwidget.h \
113 114 PeripheralWidget/src/registerwidget.h \
114 115 PeripheralWidget/src/socregsviewer.h \
115 116 SOC/socclk.h \
116 117 engine/socexplorerengine.h \
117 118 engine/socexplorerxmlfile.h \
118 119 plugins/socexplorerplugin.h \
119 120 pluginsInterface/socexplorerplugininterface.h \
120 121 pluginsInterface/socexplorerplugininterface_global.h \
121 122 proxy/socexplorerproxy.h \
122 123 SOC/socexplorerenumdevice.h \
123 124 PySocExplorerEngine.h
124 125
125 126
126 127
127 128
128 129
129 130
130 131 SOURCES += \
131 132 pluginloader/pluginscache.cpp \
132 133 pluginloader/pluginloader.cpp \
133 134 pluginManagerWdgt/plugintree.cpp \
134 135 pluginManagerWdgt/pluginmanagerWDGT.cpp \
135 136 pluginManagerWdgt/pluginlist.cpp \
136 137 pluginManagerWdgt/plugininfoswdgt.cpp \
137 138 XmlEngine/XMLmodel.cpp \
138 139 XmlEngine/XMLdata.cpp \
139 140 SOC/socmodel.cpp \
140 141 SOC/registerdata.cpp \
141 142 XmlEngine/xmldriver.cpp \
142 143 PeripheralWidget/src/peripheralwidget.cpp \
143 144 PeripheralWidget/src/registerwidget.cpp \
144 145 PeripheralWidget/src/socregsviewer.cpp \
145 146 SOC/socclk.cpp \
146 147 plugins/genericPySysdriver.cpp \
147 148 engine/socexplorerengine.cpp \
148 149 engine/socexplorerxmlfile.cpp \
149 150 proxy/socexplorerproxy.cpp \
150 151 SOC/socexplorerenumdevice.cpp \
151 152 plugins/socexplorerplugin.cpp
152 153
153 154
154 155 OTHER_FILES += \
155 156 plugins/socexplorerplugin.cpp \
156 157 pluginsInterface/socexplorerplugininterface.cpp \
157 158 plugins/socexplorerplugin.prf \
158 159 pythongenerator.sh \
159 160 pythonQtgeneratorCfg.txt
160 161
161 162
Show file before | Show file after | Hide comments
@@ -1,285 +1,290
1 1 /*------------------------------------------------------------------------------
2 2 -- This file is a part of the SocExplorer Software
3 3 -- Copyright (C) 2012, Plasma Physics Laboratory - CNRS
4 4 --
5 5 -- This program is free software; you can redistribute it and/or modify
6 6 -- it under the terms of the GNU General Public License as published by
7 7 -- the Free Software Foundation; either version 2 of the License, or
8 8 -- (at your option) any later version.
9 9 --
10 10 -- This program is distributed in the hope that it will be useful,
11 11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 13 -- GNU General Public License for more details.
14 14 --
15 15 -- You should have received a copy of the GNU General Public License
16 16 -- along with this program; if not, write to the Free Software
17 17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 18 -------------------------------------------------------------------------------*/
19 19 /*-- Author : Alexis Jeandet
20 20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
21 21 ----------------------------------------------------------------------------*/
22 22 #include "socexplorerengine.h"
23 23 #include <proxy/socexplorerproxy.h>
24 24
25 25 SocExplorerEngine* SocExplorerEngine::_self = NULL;
26 26 socExplorerXmlModel* SocExplorerEngine::p_xmlmodel=NULL;
27 27 QMainWindow* SocExplorerEngine::mainWindow=NULL;
28 28 QList<SOCModel*>* SocExplorerEngine::SOCs=NULL;
29 29 int SocExplorerEngine::loglvl=1;
30 30
31 31 SocExplorerEngine::SocExplorerEngine(QObject *parent) :
32 32 QObject(parent)
33 33 {
34 34 if(SOCs==NULL)
35 35 {
36 36 SOCs = new QList<SOCModel*>;
37 37 }
38 38
39 39 }
40 40
41 41
42 42 void SocExplorerEngine::init()
43 43 {
44 44 QDir dir;
45 45 if(!_self)
46 46 {
47 47 _self= new SocExplorerEngine;
48 48 }
49 49 if(!dir.exists(configFolder()))
50 50 dir.mkdir(configFolder());
51 51 p_xmlmodel = new socExplorerXmlModel(_self);
52 52 p_xmlmodel->updateSOClist();
53 53 }
54 54
55 55 QString SocExplorerEngine::configFolder()
56 56 {
57 57 return QString(SOCEXPLORER_CONFIG_PATH);
58 58 }
59 59
60 60 QStringList SocExplorerEngine::pluginFolders()
61 61 {
62 62 if(!_self)
63 63 init();
64 64 QStringList folders;
65 65 QDir pluginFolders(QString(SOCEXPLORER_CONFIG_PATH)+"/plugin.conf.d");
66 66 if(pluginFolders.exists())
67 67 {
68 68 pluginFolders.setFilter(QDir::Files | QDir::NoSymLinks);
69 69 QFileInfoList list = pluginFolders.entryInfoList();
70 70 for (int i = 0; i < list.size(); ++i)
71 71 {
72 72 QFileInfo fileInfo = list.at(i);
73 73 if(fileInfo.suffix()=="conf")
74 74 {
75 75 QFile confFile(fileInfo.absoluteFilePath());
76 76 if(confFile.open(QIODevice::ReadOnly))
77 77 {
78 78 while (!confFile.atEnd())
79 79 {
80 80 QString line = confFile.readLine();
81 81 QDir plugDir(line.remove("\n"));
82 82 if(plugDir.exists() && !folders.contains(plugDir.absolutePath()))
83 83 {
84 84 folders.append(plugDir.absolutePath());
85 85 }
86 86 }
87 87 }
88 88 }
89 89 }
90 90 }
91 91 return folders;
92 92 }
93 93
94 94 SOCModel *SocExplorerEngine::plugin2Soc(socexplorerplugin *plugin)
95 95 {
96 96 if(!_self)
97 97 init();
98 98 if(plugin)
99 99 {
100 100 while (plugin->parent!=NULL) {
101 101 plugin = plugin->parent;
102 102 }
103 103 for(int i=0;i<SOCs->count();i++)
104 104 {
105 105 if(SOCs->at(i)->isRootDev(plugin))
106 106 return SOCs->at(i);
107 107 }
108 108 //no soc found so create a new one
109 109 SOCModel* soc=new SOCModel(plugin);
110 110 SOCs->append(soc);
111 111 return soc;
112 112 }
113 113 return NULL;
114 114 }
115 115
116 116
117 117 int SocExplorerEngine::addEnumDevice(socexplorerplugin* rootPlugin,int VID, int PID, qint32 baseAddress, const QString &name)
118 118 {
119 119 if(!_self)
120 120 init();
121 121 SOCModel* soc = plugin2Soc(rootPlugin);
122 122 if(soc && !soc->enumDeviceExists(baseAddress))
123 123 {
124 124 emit _self->enumDeviceAdded(soc->addEnumDevice(VID,PID,baseAddress,name));
125 125 return 1;
126 126 }
127 127 return 0;
128 128 }
129 129
130 130 QList<SOCModel *> *SocExplorerEngine::getSOCs()
131 131 {
132 132 if(!_self)
133 133 init();
134 134 return SOCs;
135 135 }
136 136
137 137 qint32 SocExplorerEngine::getEnumDeviceBaseAddress(const QString& rootPlugin,int VID, int PID, int count)
138 138 {
139 139 socexplorerplugin* plugin = socexplorerproxy::findPlugin(rootPlugin);
140 140 if(plugin==NULL)return -1;
141 141 SOCModel* soc = plugin2Soc(plugin);
142 142 if(soc==NULL)
143 143 return -1;
144 144 return soc->getEnumDeviceBaseAddress(VID,PID,count);
145 145 }
146 146
147 147 qint32 SocExplorerEngine::getEnumDeviceBaseAddress(socexplorerplugin *plugin, int VID, int PID, int count)
148 148 {
149 149 if(plugin==NULL)return -1;
150 150 SOCModel* soc = plugin2Soc(plugin);
151 151 if(soc==NULL)
152 152 return -1;
153 153 return soc->getEnumDeviceBaseAddress(VID,PID,count);
154 154 }
155 155
156 156 qint32 SocExplorerEngine::getEnumDeviceCount(socexplorerplugin *plugin, int VID, int PID)
157 157 {
158 158 if(plugin==NULL)return 0;
159 159 SOCModel* soc = plugin2Soc(plugin);
160 160 if(soc==NULL)
161 161 return 0;
162 162 return soc->getEnumDeviceCount(VID,PID);
163 163 }
164 164
165 165 qint32 SocExplorerEngine::getEnumDeviceCount(const QString &rootPlugin, int VID, int PID)
166 166 {
167 167 socexplorerplugin* plugin = socexplorerproxy::findPlugin(rootPlugin);
168 168 if(plugin==NULL)return 0;
169 169 SOCModel* soc = plugin2Soc(plugin);
170 170 if(soc==NULL)
171 171 return 0;
172 172 return soc->getEnumDeviceCount(VID,PID);
173 173 }
174 174
175 175 int SocExplorerEngine::addEnumDevice(const QString &rootPlugin, int VID, int PID, qint32 baseAddress, const QString &name)
176 176 {
177 177 socexplorerplugin* plugin = socexplorerproxy::findPlugin(rootPlugin);
178 178 if(plugin==NULL)return -1;
179 179 SOCModel* soc = plugin2Soc(plugin);
180 180 if(soc==NULL)
181 181 return -1;
182 182 soc->addEnumDevice(VID,PID,baseAddress,name);
183 183 return 1;
184 184 }
185 185
186 186
187 187 QString SocExplorerEngine::getDevName(int VID, int PID)
188 188 {
189 189 QList<QDomNodeList> list=p_xmlmodel->getAllNodes("peripheral");
190 190 for(int i=0;i<list.count();i++)
191 191 {
192 192 QDomNodeList nodes=list.at(i);
193 193 for(int l=0;l<nodes.count();l++)
194 194 {
195 195 QDomElement node=nodes.at(l).toElement();
196 196 int nodeVID=node.attribute("vid","0").toInt();
197 197 int nodePID=node.attribute("pid","0").toInt();
198 198 if((nodeVID==VID)&&(nodePID==PID))
199 199 {
200 200 return node.attribute("name","Unknow device");
201 201 }
202 202 }
203 203 }
204 204 return QString("Unknow device");
205 205 }
206 206
207 207 QString SocExplorerEngine::SocExplorerVersion(){return QString(SOCEXPLORER_VERSION);}
208 208
209 209 QString SocExplorerEngine::SocExplorerChangeset(){return QString(SOCEXPLORER_CHAGESET).split(" ").at(0);}
210 210
211 211 QString SocExplorerEngine::SocExplorerBranch(){return QString(SOCEXPLORER_BRANCH);}
212 212
213 213 socExplorerXmlModel *SocExplorerEngine::xmlModel()
214 214 {
215 215 if(!_self)
216 216 init();
217 217 return p_xmlmodel;
218 218 }
219 219
220 220 void SocExplorerEngine::setMainWindow(QMainWindow *Mainwindow)
221 221 {
222 222 if(!_self)
223 223 init();
224 224 mainWindow=Mainwindow;
225 225 }
226 226
227 227 QProgressBar *SocExplorerEngine::getProgressBar(const QString& format, int max)
228 228 {
229 229 if(!_self)
230 230 init();
231 231 QProgressBar* progressBar;
232 232 if(mainWindow!=NULL)
233 233 {
234 234 progressBar = new QProgressBar(mainWindow);
235 235 mainWindow->statusBar()->addWidget(progressBar);
236 236 }
237 237 else
238 238 {
239 239 progressBar = new QProgressBar();
240 240 }
241 241 progressBar->setMaximum(max);
242 242 progressBar->setFormat(format);
243 243 return progressBar;
244 244 }
245 245
246 246 void SocExplorerEngine::deleteProgressBar(QProgressBar *progressBar)
247 247 {
248 248 if(mainWindow!=NULL)
249 249 {
250 250 mainWindow->statusBar()->removeWidget(progressBar);
251 251 }
252 252 delete progressBar;
253 253 }
254 254
255 255 void SocExplorerEngine::addSOC(socexplorerplugin *rootPlugin)
256 256 {
257 257 plugin2Soc(rootPlugin);
258 258 }
259 259
260 260 void SocExplorerEngine::removeSOC(socexplorerplugin *rootPlugin)
261 261 {
262 262 SOCModel* soc=plugin2Soc(rootPlugin);
263 263 SOCs->removeAll(soc);
264 264 delete soc;
265 265 }
266 266
267 267 void SocExplorerEngine::message(socexplorerplugin *sender, const QString &message, int debugLevel)
268 268 {
269 269 // TODO add multi output message manager IE also log in files
270 270 if(!_self)
271 271 init();
272 272 if(loglvl>=debugLevel)
273 273 qDebug()<< QTime::currentTime().toString()+" " + sender->instanceName()+":"+message;
274 274 }
275 275
276 276 void SocExplorerEngine::setLogLevel(int level)
277 277 {
278 278 if(!_self)
279 279 init();
280 280 printf("Set log level to %d\n",level);
281 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 2 -- This file is a part of the SocExplorer Software
3 3 -- Copyright (C) 2012, Plasma Physics Laboratory - CNRS
4 4 --
5 5 -- This program is free software; you can redistribute it and/or modify
6 6 -- it under the terms of the GNU General Public License as published by
7 7 -- the Free Software Foundation; either version 2 of the License, or
8 8 -- (at your option) any later version.
9 9 --
10 10 -- This program is distributed in the hope that it will be useful,
11 11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 13 -- GNU General Public License for more details.
14 14 --
15 15 -- You should have received a copy of the GNU General Public License
16 16 -- along with this program; if not, write to the Free Software
17 17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 18 -------------------------------------------------------------------------------*/
19 19 /*-- Author : Alexis Jeandet
20 20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
21 21 ----------------------------------------------------------------------------*/
22 22 #ifndef SOCEXPLORERENGINE_H
23 23 #define SOCEXPLORERENGINE_H
24 24
25 25 #include <stdint.h>
26 26 #include <QObject>
27 27 #include <QtWidgets>
28 28 #include <QStringList>
29 29 #include <QDomDocument>
30 30 #include <QDomElement>
31 31 #include <QDomNodeList>
32 32 #include <QFile>
33 33 #include <QTextStream>
34 34 #include <QDir>
35 35 #include <QApplication>
36 36 #include <QtCore/qglobal.h>
37 37 #include <QFileDialog>
38 38 #include <socexplorerxmlfile.h>
39 39 #include <socexplorerenumdevice.h>
40 40 #include <XMLmodel.h>
41 41 #include <peripheralwidget.h>
42 42 #include <registerwidget.h>
43 43 #include <socmodel.h>
44 44
45 45 #if defined(SOCEXPLORER_SDK_BUILD)
46 46 # define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
47 47 #else
48 48 # define SOCEXPLORER_SDK_EXPORT Q_DECL_IMPORT
49 49 #endif
50 50
51 51
52 52 class SOCEXPLORER_SDK_EXPORT SocExplorerAutoProgressBar
53 53 {
54 54 public:
55 55 SocExplorerAutoProgressBar(QProgressBar* progressBar=NULL)
56 56 {
57 57 this->p_progressbar=progressBar;
58 58 }
59 59 ~SocExplorerAutoProgressBar()
60 60 {
61 61 if(p_progressbar)
62 62 {
63 63 delete p_progressbar;
64 64 }
65 65 }
66 66 void setProgressBar(QProgressBar* progressBar)
67 67 {
68 68 this->p_progressbar=progressBar;
69 69 }
70 70 void setValue(int value)
71 71 {
72 72 p_progressbar->setValue(value);
73 73 }
74 74 private:
75 75 QProgressBar* p_progressbar;
76 76 };
77 77
78 78 //! SocExplorerEngine is a pure static class which aims to provide services for both SocExplorer software and plugins.
79 79
80 80 class SOCEXPLORER_SDK_EXPORT SocExplorerEngine : public QObject
81 81 {
82 82 Q_OBJECT
83 83 private:
84 84 static SocExplorerEngine* _self;
85 85 SocExplorerEngine(QObject *parent = 0);
86 86 static void init();
87 87
88 88 public:
89 89 static SocExplorerEngine* self(){ if(!_self){_self= new SocExplorerEngine;}return _self;}
90 90 //! Return the configuration folder path, OS dependant.
91 91 SOCEXPLORER_SDK_EXPORT static QString configFolder();
92 92 //! Return the default plugin folder path, OS dependant.
93 93 static QStringList pluginFolders();
94 94 static QString configPath(){return QString(SOCEXPLORER_CONFIG_PATH);}
95 95 static QString sharePath(){return QString(SOCEXPLORER_SHARE_PATH);}
96 96 static int addEnumDevice(socexplorerplugin* rootPlugin,int VID,int PID,qint32 baseAddress,const QString& name);
97 97 static QList<SOCModel*>* getSOCs();
98 98 static QString getDevName(int VID, int PID);
99 99 static QString SocExplorerVersion();
100 100 static QString SocExplorerChangeset();
101 101 static QString SocExplorerBranch();
102 102 static socExplorerXmlModel* xmlModel();
103 103 static void setMainWindow(QMainWindow* Mainwindow);
104 104 static QProgressBar* getProgressBar(const QString &format, int max);
105 105 static void deleteProgressBar(QProgressBar* progressBar);
106 106 static void addSOC(socexplorerplugin* rootPlugin);
107 107 static void removeSOC(socexplorerplugin* rootPlugin);
108 108 static void message(socexplorerplugin* sender,const QString& message,int debugLevel=0);
109 109 static void setLogLevel(int level);
110 static bool isSocLitleEndian(socexplorerplugin* plugin);
110 111 signals:
111 112 void enumDeviceAdded(socExplorerEnumDevice* device);
112 113 public slots:
113 114 QString getSocExplorerVersion(){return SocExplorerEngine::SocExplorerVersion();}
114 115 QString getSocExplorerChangeset(){return SocExplorerEngine::SocExplorerChangeset();}
115 116 QString getSocExplorerBranch(){return SocExplorerEngine::SocExplorerBranch();}
116 117 qint32 getEnumDeviceBaseAddress(const QString& rootPlugin,int VID,int PID,int count=0);
117 118 qint32 getEnumDeviceBaseAddress(socexplorerplugin* plugin,int VID,int PID,int count=0);
118 119 qint32 getEnumDeviceCount(socexplorerplugin* plugin,int VID,int PID);
119 120 qint32 getEnumDeviceCount(const QString& rootPlugin,int VID,int PID);
120 121 int addEnumDevice(const QString& rootPlugin,int VID,int PID,qint32 baseAddress,const QString& name);
121 122
122 123 private:
123 124 static SOCModel* plugin2Soc(socexplorerplugin* plugin);
124 125 static socExplorerXmlModel* p_xmlmodel;
125 126 static QMainWindow* mainWindow;
126 127 static QList<SOCModel*>* SOCs;
127 128 static int loglvl;
128 129 };
129 130
130 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 2 #include <genericPySysdriver.h>
3 3 #include <socexplorerplugin.h>
4 4 #ifdef WIN32
5 5 #include <stdlib.h>
6 6 #define socexplorerBswap32(X) _byteswap_ulong(X)
7 7 #else
8 8 #ifdef UNIX
9 9 #include <byteswap.h>
10 10 #define socexplorerBswap32(X) bswap_32(X)
11 11 #endif
12 12 #endif
13 13
14
14 #include <socexplorerengine.h>
15 15
16 16
17 17 genericPySysdriver::genericPySysdriver(socexplorerplugin* plugin,QObject* parent):
18 18 QObject(parent)
19 19 {
20 20 Q_UNUSED(parent)
21 21 this->plugin = plugin;
22 22 }
23 23
24 24 QVariantList genericPySysdriver::Read(unsigned int address,unsigned int count)
25 25 {
26 26 unsigned int data[count];
27 27 QVariantList result;
28 28 this->plugin->Read(data,count,address);
29 29 for(unsigned int i = 0;i<count;i++)
30 30 {
31 31 result.append(QVariant((int)data[i]));
32 32 }
33 33 return result;
34 34 }
35 35 void genericPySysdriver::Write(unsigned int address,QList<QVariant> dataList)
36 36 {
37 37 unsigned int data[dataList.count()];
38 38 for(int i = 0;i<dataList.count();i++)
39 39 {
40 40 data[i] = (unsigned int)dataList.at(i).toUInt();
41 41 }
42 42 this->plugin->Write(data,dataList.count(),address);
43 43 }
44 44
45 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));
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;
47 return this->plugin->dumpMemory(address,count,file);
63 48 }
64 49
65 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));
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;
52 return this->plugin->memSet(address,value,count);
76 53 }
77 54
78 55 bool genericPySysdriver::loadbin(unsigned int address,QString file)
79 56 {
80 QFile infile(file);
81 if (!infile.open(QIODevice::ReadOnly))
82 return false;
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;
57 return this->plugin->loadbin(address,file);
58
59 }
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 71 QString genericPySysdriver::instance()
100 72 {
101 73 return plugin->instanceName();
102 74 }
103 75
Show file before | Show file after | Hide comments
@@ -1,58 +1,61
1 1 /*------------------------------------------------------------------------------
2 2 -- This file is a part of the SocExplorer Software
3 3 -- Copyright (C) 2011, Plasma Physics Laboratory - CNRS
4 4 --
5 5 -- This program is free software; you can redistribute it and/or modify
6 6 -- it under the terms of the GNU General Public License as published by
7 7 -- the Free Software Foundation; either version 2 of the License, or
8 8 -- (at your option) any later version.
9 9 --
10 10 -- This program is distributed in the hope that it will be useful,
11 11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 13 -- GNU General Public License for more details.
14 14 --
15 15 -- You should have received a copy of the GNU General Public License
16 16 -- along with this program; if not, write to the Free Software
17 17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 18 -------------------------------------------------------------------------------*/
19 19 /*-- Author : Alexis Jeandet
20 20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
21 21 ----------------------------------------------------------------------------*/
22 22 #ifndef GENERICPYSYSDRIVER_H
23 23 #define GENERICPYSYSDRIVER_H
24 24 #include <QObject>
25 25 #include <QVariant>
26 26 #include <QVariantList>
27 27 #include <malloc.h>
28 28 #include <QFile>
29 29 #include <stdint.h>
30 30 #include <QTextStream>
31 #include <abstractbinfile.h>
31 32 #if defined(SOCEXPLORER_SDK_BUILD)
32 33 # define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
33 34 #else
34 35 # define SOCEXPLORER_SDK_EXPORT Q_DECL_IMPORT
35 36 #endif
36 37 class socexplorerplugin;
37 38
38 39 class SOCEXPLORER_SDK_EXPORT genericPySysdriver : public QObject
39 40 {
40 41 Q_OBJECT
41 42
42 43 public:
43 44
44 45 explicit genericPySysdriver(socexplorerplugin* plugin,QObject* parent=0);
45 46 signals:
46 47 public slots:
47 48 QVariantList Read(unsigned int address,unsigned int count);
48 49 void Write(unsigned int address,QList<QVariant> dataList);
49 50 bool dumpMemory(unsigned int address,unsigned int count,QString file);
50 51 bool memSet(unsigned int address,int value, unsigned int count);
51 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 55 QString instance();
53 56 private:
54 57 socexplorerplugin* plugin;
55 58
56 59 };
57 60
58 61 #endif // GENERICPYSYSDRIVER_H
Show file before | Show file after | Hide comments
@@ -1,91 +1,244
1 1 /*------------------------------------------------------------------------------
2 2 -- This file is a part of the SocExplorer Software
3 3 -- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
4 4 --
5 5 -- This program is free software; you can redistribute it and/or modify
6 6 -- it under the terms of the GNU General Public License as published by
7 7 -- the Free Software Foundation; either version 2 of the License, or
8 8 -- (at your option) any later version.
9 9 --
10 10 -- This program is distributed in the hope that it will be useful,
11 11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 13 -- GNU General Public License for more details.
14 14 --
15 15 -- You should have received a copy of the GNU General Public License
16 16 -- along with this program; if not, write to the Free Software
17 17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 18 -------------------------------------------------------------------------------*/
19 19 /*-- Author : Alexis Jeandet
20 20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
21 21 ----------------------------------------------------------------------------*/
22 22
23 23 #include <socexplorerplugin.h>
24
24 #include <abstractbinfile.h>
25 #include <srec/srecfile.h>
26 #include <BinFile/binaryfile.h>
25 27
26 28 int socexplorerplugin::isConnected(){return this->Connected;}
27 29
28 30 QString socexplorerplugin::baseName(){return *_Name;}
29 31
30 32 int socexplorerplugin::baseAddress(){return this->BaseAddress;}
31 33
32 34 void socexplorerplugin::setBaseAddress(unsigned int baseAddress){this->BaseAddress = baseAddress;}
33 35
34 36 QString socexplorerplugin::instanceName()
35 37 {
36 return this->_instanceName;
38 return this->_instanceName;
37 39 }
38 40
39 41 int socexplorerplugin::registermenu(QMenu *menu)
40 42 {
41 this->menu = menu->addMenu(this->_instanceName);
42 this->closeAction = this->menu->addAction(tr("Close plugin"));
43 QObject::connect(this->closeAction,SIGNAL(triggered()),this,SLOT(closeMe()));
44 this->ChildsMenu = this->menu->addMenu(QString("Childs"));
45 for(int i=0;i<this->childs.count();i++)
43 this->menu = menu->addMenu(this->_instanceName);
44 this->closeAction = this->menu->addAction(tr("Close plugin"));
45 QObject::connect(this->closeAction,SIGNAL(triggered()),this,SLOT(closeMe()));
46 this->ChildsMenu = this->menu->addMenu(QString("Childs"));
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());
50 return 0;
51 if(this->pyObject!=NULL)emit this->registerObject((QObject*)this->pyObject,this->instanceName());
52 return 0;
51 53 }
52 54
53 55 void socexplorerplugin::postInstantiationTrigger()
54 56 {
55 return;
57 return;
56 58 }
57 59
58 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 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 78 void socexplorerplugin::closeMe(){emit this->closePlugin(this);}
77 79
78 80 void socexplorerplugin::activate(bool flag){this->setEnabled(flag);emit this->activateSig(flag);}
79 81
80 82 void socexplorerplugin::setInstanceName(const QString &newName)
81 83 {
82 this->_instanceName = newName;
83 if(this->menu)
84 this->menu->setTitle(this->_instanceName);
85 this->setWindowTitle(newName);
84 this->_instanceName = newName;
85 if(this->menu)
86 this->menu->setTitle(this->_instanceName);
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 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 9 -- This file is a part of the SOC Explorer Software
10 10 -- Copyright (C) 2011, Plasma Physics Laboratory - CNRS
11 11 --
12 12 -- This program is free software; you can redistribute it and/or modify
13 13 -- it under the terms of the GNU General Public License as published by
14 14 -- the Free Software Foundation; either version 2 of the License, or
15 15 -- (at your option) any later version.
16 16 --
17 17 -- This program is distributed in the hope that it will be useful,
18 18 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
19 19 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 20 -- GNU General Public License for more details.
21 21 --
22 22 -- You should have received a copy of the GNU General Public License
23 23 -- along with this program; if not, write to the Free Software
24 24 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 -------------------------------------------------------------------------------*/
26 26 /*-- Author : Alexis Jeandet
27 27 -- Mail : alexis.jeandet@lpp.polytechnique.fr
28 28 ----------------------------------------------------------------------------*/
29 29 #ifndef SOCEXPLORERPLUGIN_H
30 30 #define SOCEXPLORERPLUGIN_H
31 31 #include <QWidget>
32 32 #include <QAction>
33 33 #include <QDockWidget>
34 34 #include <QMainWindow>
35 35 #include <QList>
36 36 #include <QMenu>
37 37 #include <socexplorer.h>
38 38 #include <QObject>
39 39 #include <QVariant>
40 40 #include <QVariantList>
41 41 #include <malloc.h>
42 42 #include <QFile>
43 43 #include <stdint.h>
44 44 #include <QTextStream>
45 45 #include <genericPySysdriver.h>
46 #include <abstractbinfile.h>
46 47 #ifndef driver_Name
47 48 #define driver_Name "Plugin"
48 49 #endif
49 50 #ifndef driver_Author
50 51 #define driver_Author "No Author"
51 52 #endif
52 53 #ifndef driver_Version
53 54 #define driver_Version "0.0.0"
54 55 #endif
55 56 #ifndef driver_Description
56 57 #define driver_Description "No description."
57 58 #endif
58 59 #ifndef driver_can_be_root
59 60 #define driver_can_be_root 0
60 61 #endif
61 62 #ifndef driver_can_be_child
62 63 #define driver_can_be_child 0
63 64 #endif
64 65 #ifndef driver_VID
65 66 #define driver_VID 0
66 67 #endif
67 68 #ifndef driver_PID
68 69 #define driver_PID 0
69 70 #endif
70 71
71 72 #if defined(SOCEXPLORER_SDK_BUILD)
72 73 # define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
73 74 #else
74 75 # define SOCEXPLORER_SDK_EXPORT Q_DECL_IMPORT
75 76 #endif
76 77
77 78 class genericPySysdriver;
78 79
79 80 //! socexplorerplugin is the base class for any SocExplorer plugin, it gives a standard interface to communicate
80 81 //! between each plugins and to interact with SocExplorer software.
81 82
82 83 class SOCEXPLORER_SDK_EXPORT socexplorerplugin : public QDockWidget
83 84 {
84 85 Q_OBJECT
85 86 public:
86 87 //! Default plugin constructor, any plugin should call this constructor. This constructor creates a
87 88 //! default python wrapper instance. If you want to connect your own python wrapper, you have to clear
88 89 //! createPyObject option and instanciate your own genericPySysdriver derivated object.
89 90 socexplorerplugin(QWidget *parent = 0,bool createPyObject=true):QDockWidget(parent)
90 91 {
91 92 closeAction=NULL;
92 93 menu=NULL;
93 94 ChildsMenu=NULL;
94 95 this->Connected = false;
95 96 this->setFeatures(QDockWidget::DockWidgetMovable|QDockWidget::DockWidgetFloatable|QDockWidget::DockWidgetVerticalTitleBar);
96 97 _Name = new QString(driver_Name);
97 98 _Author = new QString(driver_Author);
98 99 _Version = new QString(driver_Version);
99 100 _Description = new QString(driver_Description);
100 101 _canBeChild = driver_can_be_child;
101 102 _canBeRoot = driver_can_be_root;
102 103 _VID = driver_VID;
103 104 _PID = driver_PID;
104 105 if(createPyObject)
105 106 {
106 107 this->makeGenericPyWrapper();
107 108 }
108 109 }
109 110 //! Tells if the plugin is connected, it is used to enable or disable all childrens interfaces.
110 111 virtual int isConnected();
111 112 //! Gives the associated Vendor IDentifier, usefull to automatically associate plugins with found
112 113 //! hardware while board enumeration.
113 114 virtual int VID(){return _PID;}
114 115 //! Gives the associated Product IDentifier, usefull to automatically associate plugins with found
115 116 //! hardware while board enumeration.
116 117 virtual int PID(){return _VID;}
117 118 //! Gives the plugin's base name, usefull to automatically generate instance name.
118 119 virtual QString baseName();
119 120 //! Gives the base address of the current instance, for example if your plugin is supposed to drive
120 121 //! an UART it will correspond to the address of it's first register. This address have at least to
121 122 //! be set by SocExplorer and it can be user accessible if you want.
122 123 virtual int baseAddress();
123 124 //! Sets the base address of the current instance, for example if your plugin is supposed to drive
124 125 //! an UART it will correspond to the address of it's first register. This address have at least to
125 126 //! be set by SocExplorer and it can be user accessible if you want.
126 127 virtual void setBaseAddress(unsigned int baseAddress);
127 128
128 129 genericPySysdriver* getPyObjectWrapper(){return this->pyObject;}
129 130 QList<socexplorerplugin*> childs;
130 131 socexplorerplugin* parent;
131 132 QAction* closeAction;
132 133 QString instanceName();
133 134 QMenu* menu;
134 135 QMenu* ChildsMenu;
135 136
136 137 signals:
137 138 //! Signal emited each time the plugin is about to be closed.
138 139 void closePlugin(socexplorerplugin* driver);
139 140 void activateSig(bool flag);
140 141 void registerObject(QObject* object,const QString& instanceName);
141 142
142 143 public slots:
143 144 virtual int registermenu(QMenu* menu);
144 145 virtual void postInstantiationTrigger();
145 146 //! Write slot this is the way your children plugins ask you for writing data.
146 147 //! If your plugin is supposed to have childern drivers you should implement this methode.
147 148 //! By default this methode forward the write request to the parent plugin.
148 149 //! \param Value Pointer the data buffer.
149 150 //! \param count Number of 32 bits words you should to write.
150 151 //! \param address Address from where you should to start to write.
151 152 //! \return Quantity of 32 bits words writtens.
152 153 virtual unsigned int Write(unsigned int* Value, unsigned int count,unsigned int address);
153 154 //! Read slot this is the way your children plugins ask you for reading data.
154 155 //! If your plugin is supposed to have childern drivers you should implement this methode.
155 156 //! By default this methode forward the write request to the parent plugin.
156 157 //! \param Value Pointer the data buffer.
157 158 //! \param count Number of 32 bits words you should to read.
158 159 //! \param address Address from where you should to start to read.
159 160 //! \return Quantity of 32 bits words read.
160 161 virtual unsigned int Read(unsigned int* Value, unsigned int count,unsigned int address);
161 162 virtual void closeMe();
162 163 virtual void activate(bool flag);
163 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 171 protected:
165 172 void makeGenericPyWrapper();
166 173 int BaseAddress;
167 174 bool Connected;
168 175 genericPySysdriver* pyObject;
169 176 QString* _Name;
170 177 QString* _Author;
171 178 QString* _Version;
172 179 QString* _Description;
173 180 QString _instanceName;
174 181 int _canBeChild;
175 182 int _canBeRoot;
176 183 int _VID;
177 184 int _PID;
178 185 };
179 186
180 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 1 #include "PySocExplorer0.h"
2 2 #include <PythonQtConversion.h>
3 3 #include <PythonQtMethodInfo.h>
4 4 #include <PythonQtSignalReceiver.h>
5 #include <QIconEngine>
6 5 #include <QVariant>
7 6 #include <abstractbinfile.h>
8 7 #include <elfparser.h>
9 8 #include <qaction.h>
9 #include <qbackingstore.h>
10 10 #include <qbitmap.h>
11 11 #include <qbytearray.h>
12 12 #include <qcolor.h>
13 13 #include <qcoreevent.h>
14 14 #include <qcursor.h>
15 15 #include <qevent.h>
16 16 #include <qfile.h>
17 17 #include <qfont.h>
18 18 #include <qgraphicseffect.h>
19 19 #include <qgraphicsproxywidget.h>
20 #include <qicon.h>
20 21 #include <qkeysequence.h>
21 22 #include <qlayout.h>
22 23 #include <qlineedit.h>
23 24 #include <qlist.h>
24 25 #include <qlocale.h>
25 26 #include <qmargins.h>
27 #include <qmetaobject.h>
26 28 #include <qobject.h>
27 29 #include <qpaintdevice.h>
28 30 #include <qpaintengine.h>
29 31 #include <qpainter.h>
30 32 #include <qpalette.h>
31 33 #include <qpen.h>
32 34 #include <qpixmap.h>
33 35 #include <qpoint.h>
34 36 #include <qrect.h>
35 37 #include <qregion.h>
36 38 #include <qscrollarea.h>
37 39 #include <qscrollbar.h>
38 40 #include <qsize.h>
39 41 #include <qsizepolicy.h>
40 42 #include <qspinbox.h>
41 43 #include <qstringlist.h>
42 44 #include <qstyle.h>
43 45 #include <qstyleoption.h>
44 46 #include <qwidget.h>
47 #include <qwindow.h>
45 48
46 49 PythonQtShell_ElfFile::~PythonQtShell_ElfFile() {
47 50 PythonQtPrivate* priv = PythonQt::priv();
48 51 if (priv) { priv->shellClassDeleted(this); }
49 52 }
50 53 int PythonQtShell_ElfFile::closeFile()
51 54 {
52 if (_wrapper) {
53 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
54 PyErr_Clear();
55 if (obj && !PythonQtSlotFunction_Check(obj)) {
55 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
56 static PyObject* name = PyString_FromString("closeFile");
57 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
58 if (obj) {
56 59 static const char* argumentList[] ={"int"};
57 60 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
58 61 int returnValue;
59 62 void* args[1] = {NULL};
60 63 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
61 64 if (result) {
62 65 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
63 66 if (args[0]!=&returnValue) {
64 67 if (args[0]==NULL) {
65 68 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
66 69 } else {
67 70 returnValue = *((int*)args[0]);
68 71 }
69 72 }
70 73 }
71 74 if (result) { Py_DECREF(result); }
72 75 Py_DECREF(obj);
73 76 return returnValue;
77 } else {
78 PyErr_Clear();
74 79 }
75 80 }
76 81 return ElfFile::closeFile();
77 82 }
78 83 QList<codeFragment* > PythonQtShell_ElfFile::getFragments()
79 84 {
80 if (_wrapper) {
81 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
82 PyErr_Clear();
83 if (obj && !PythonQtSlotFunction_Check(obj)) {
85 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
86 static PyObject* name = PyString_FromString("getFragments");
87 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
88 if (obj) {
84 89 static const char* argumentList[] ={"QList<codeFragment* >"};
85 90 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
86 91 QList<codeFragment* > returnValue;
87 92 void* args[1] = {NULL};
88 93 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
89 94 if (result) {
90 95 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
91 96 if (args[0]!=&returnValue) {
92 97 if (args[0]==NULL) {
93 98 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
94 99 } else {
95 100 returnValue = *((QList<codeFragment* >*)args[0]);
96 101 }
97 102 }
98 103 }
99 104 if (result) { Py_DECREF(result); }
100 105 Py_DECREF(obj);
101 106 return returnValue;
107 } else {
108 PyErr_Clear();
102 109 }
103 110 }
104 111 return ElfFile::getFragments();
105 112 }
106 113 bool PythonQtShell_ElfFile::isopened()
107 114 {
108 if (_wrapper) {
109 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
110 PyErr_Clear();
111 if (obj && !PythonQtSlotFunction_Check(obj)) {
115 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
116 static PyObject* name = PyString_FromString("isopened");
117 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
118 if (obj) {
112 119 static const char* argumentList[] ={"bool"};
113 120 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
114 121 bool returnValue;
115 122 void* args[1] = {NULL};
116 123 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
117 124 if (result) {
118 125 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
119 126 if (args[0]!=&returnValue) {
120 127 if (args[0]==NULL) {
121 128 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
122 129 } else {
123 130 returnValue = *((bool*)args[0]);
124 131 }
125 132 }
126 133 }
127 134 if (result) { Py_DECREF(result); }
128 135 Py_DECREF(obj);
129 136 return returnValue;
137 } else {
138 PyErr_Clear();
130 139 }
131 140 }
132 141 return ElfFile::isopened();
133 142 }
134 bool PythonQtShell_ElfFile::openFile(const QString& File)
135 {
136 if (_wrapper) {
137 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
138 PyErr_Clear();
139 if (obj && !PythonQtSlotFunction_Check(obj)) {
143 bool PythonQtShell_ElfFile::openFile(const QString& File0)
144 {
145 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
146 static PyObject* name = PyString_FromString("openFile");
147 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
148 if (obj) {
140 149 static const char* argumentList[] ={"bool" , "const QString&"};
141 150 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
142 151 bool returnValue;
143 void* args[2] = {NULL, (void*)&File};
152 void* args[2] = {NULL, (void*)&File0};
144 153 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
145 154 if (result) {
146 155 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
147 156 if (args[0]!=&returnValue) {
148 157 if (args[0]==NULL) {
149 158 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
150 159 } else {
151 160 returnValue = *((bool*)args[0]);
152 161 }
153 162 }
154 163 }
155 164 if (result) { Py_DECREF(result); }
156 165 Py_DECREF(obj);
157 166 return returnValue;
158 }
159 }
160 return ElfFile::openFile(File);
161 }
162 bool PythonQtShell_ElfFile::toBinary(const QString& File)
163 {
164 if (_wrapper) {
165 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
166 PyErr_Clear();
167 if (obj && !PythonQtSlotFunction_Check(obj)) {
167 } else {
168 PyErr_Clear();
169 }
170 }
171 return ElfFile::openFile(File0);
172 }
173 bool PythonQtShell_ElfFile::toBinary(const QString& File0)
174 {
175 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
176 static PyObject* name = PyString_FromString("toBinary");
177 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
178 if (obj) {
168 179 static const char* argumentList[] ={"bool" , "const QString&"};
169 180 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
170 181 bool returnValue;
171 void* args[2] = {NULL, (void*)&File};
182 void* args[2] = {NULL, (void*)&File0};
172 183 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
173 184 if (result) {
174 185 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
175 186 if (args[0]!=&returnValue) {
176 187 if (args[0]==NULL) {
177 188 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
178 189 } else {
179 190 returnValue = *((bool*)args[0]);
180 191 }
181 192 }
182 193 }
183 194 if (result) { Py_DECREF(result); }
184 195 Py_DECREF(obj);
185 196 return returnValue;
186 }
187 }
188 return ElfFile::toBinary(File);
189 }
190 bool PythonQtShell_ElfFile::toSrec(const QString& File)
191 {
192 if (_wrapper) {
193 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
194 PyErr_Clear();
195 if (obj && !PythonQtSlotFunction_Check(obj)) {
197 } else {
198 PyErr_Clear();
199 }
200 }
201 return ElfFile::toBinary(File0);
202 }
203 bool PythonQtShell_ElfFile::toSrec(const QString& File0)
204 {
205 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
206 static PyObject* name = PyString_FromString("toSrec");
207 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
208 if (obj) {
196 209 static const char* argumentList[] ={"bool" , "const QString&"};
197 210 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
198 211 bool returnValue;
199 void* args[2] = {NULL, (void*)&File};
212 void* args[2] = {NULL, (void*)&File0};
200 213 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
201 214 if (result) {
202 215 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
203 216 if (args[0]!=&returnValue) {
204 217 if (args[0]==NULL) {
205 218 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
206 219 } else {
207 220 returnValue = *((bool*)args[0]);
208 221 }
209 222 }
210 223 }
211 224 if (result) { Py_DECREF(result); }
212 225 Py_DECREF(obj);
213 226 return returnValue;
214 }
215 }
216 return ElfFile::toSrec(File);
227 } else {
228 PyErr_Clear();
229 }
230 }
231 return ElfFile::toSrec(File0);
217 232 }
218 233 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile()
219 234 {
220 235 return new PythonQtShell_ElfFile(); }
221 236
222 237 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile(const QString& File)
223 238 {
224 239 return new PythonQtShell_ElfFile(File); }
225 240
226 241 int PythonQtWrapper_ElfFile::closeFile(ElfFile* theWrappedObject)
227 242 {
228 243 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_closeFile());
229 244 }
230 245
231 246 QString PythonQtWrapper_ElfFile::getABI(ElfFile* theWrappedObject)
232 247 {
233 248 return ( theWrappedObject->getABI());
234 249 }
235 250
236 251 QString PythonQtWrapper_ElfFile::getArchitecture(ElfFile* theWrappedObject)
237 252 {
238 253 return ( theWrappedObject->getArchitecture());
239 254 }
240 255
241 256 QString PythonQtWrapper_ElfFile::getClass(ElfFile* theWrappedObject)
242 257 {
243 258 return ( theWrappedObject->getClass());
244 259 }
245 260
246 261 QString PythonQtWrapper_ElfFile::getEndianness(ElfFile* theWrappedObject)
247 262 {
248 263 return ( theWrappedObject->getEndianness());
249 264 }
250 265
251 266 qint64 PythonQtWrapper_ElfFile::getEntryPointAddress(ElfFile* theWrappedObject)
252 267 {
253 268 return ( theWrappedObject->getEntryPointAddress());
254 269 }
255 270
256 271 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject)
257 272 {
258 273 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_getFragments());
259 274 }
260 275
261 276 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject, QStringList fragmentList)
262 277 {
263 278 return ( theWrappedObject->getFragments(fragmentList));
264 279 }
265 280
266 281 int PythonQtWrapper_ElfFile::getSectionCount(ElfFile* theWrappedObject)
267 282 {
268 283 return ( theWrappedObject->getSectionCount());
269 284 }
270 285
271 286 bool PythonQtWrapper_ElfFile::getSectionData(ElfFile* theWrappedObject, int index, char** buffer)
272 287 {
273 288 return ( theWrappedObject->getSectionData(index, buffer));
274 289 }
275 290
276 291 qint64 PythonQtWrapper_ElfFile::getSectionDatasz(ElfFile* theWrappedObject, int index)
277 292 {
278 293 return ( theWrappedObject->getSectionDatasz(index));
279 294 }
280 295
281 296 int PythonQtWrapper_ElfFile::getSectionIndex(ElfFile* theWrappedObject, QString name)
282 297 {
283 298 return ( theWrappedObject->getSectionIndex(name));
284 299 }
285 300
286 301 qint64 PythonQtWrapper_ElfFile::getSectionMemsz(ElfFile* theWrappedObject, int index)
287 302 {
288 303 return ( theWrappedObject->getSectionMemsz(index));
289 304 }
290 305
291 306 QString PythonQtWrapper_ElfFile::getSectionName(ElfFile* theWrappedObject, int index)
292 307 {
293 308 return ( theWrappedObject->getSectionName(index));
294 309 }
295 310
296 311 qint64 PythonQtWrapper_ElfFile::getSectionPaddr(ElfFile* theWrappedObject, int index)
297 312 {
298 313 return ( theWrappedObject->getSectionPaddr(index));
299 314 }
300 315
301 316 QString PythonQtWrapper_ElfFile::getSectionType(ElfFile* theWrappedObject, int index)
302 317 {
303 318 return ( theWrappedObject->getSectionType(index));
304 319 }
305 320
306 321 int PythonQtWrapper_ElfFile::getSegmentCount(ElfFile* theWrappedObject)
307 322 {
308 323 return ( theWrappedObject->getSegmentCount());
309 324 }
310 325
311 326 qint64 PythonQtWrapper_ElfFile::getSegmentFilesz(ElfFile* theWrappedObject, int index)
312 327 {
313 328 return ( theWrappedObject->getSegmentFilesz(index));
314 329 }
315 330
316 331 QString PythonQtWrapper_ElfFile::getSegmentFlags(ElfFile* theWrappedObject, int index)
317 332 {
318 333 return ( theWrappedObject->getSegmentFlags(index));
319 334 }
320 335
321 336 qint64 PythonQtWrapper_ElfFile::getSegmentMemsz(ElfFile* theWrappedObject, int index)
322 337 {
323 338 return ( theWrappedObject->getSegmentMemsz(index));
324 339 }
325 340
326 341 qint64 PythonQtWrapper_ElfFile::getSegmentOffset(ElfFile* theWrappedObject, int index)
327 342 {
328 343 return ( theWrappedObject->getSegmentOffset(index));
329 344 }
330 345
331 346 qint64 PythonQtWrapper_ElfFile::getSegmentPaddr(ElfFile* theWrappedObject, int index)
332 347 {
333 348 return ( theWrappedObject->getSegmentPaddr(index));
334 349 }
335 350
336 351 QString PythonQtWrapper_ElfFile::getSegmentType(ElfFile* theWrappedObject, int index)
337 352 {
338 353 return ( theWrappedObject->getSegmentType(index));
339 354 }
340 355
341 356 qint64 PythonQtWrapper_ElfFile::getSegmentVaddr(ElfFile* theWrappedObject, int index)
342 357 {
343 358 return ( theWrappedObject->getSegmentVaddr(index));
344 359 }
345 360
346 361 quint64 PythonQtWrapper_ElfFile::getSymbolAddress(ElfFile* theWrappedObject, int index)
347 362 {
348 363 return ( theWrappedObject->getSymbolAddress(index));
349 364 }
350 365
351 366 int PythonQtWrapper_ElfFile::getSymbolCount(ElfFile* theWrappedObject)
352 367 {
353 368 return ( theWrappedObject->getSymbolCount());
354 369 }
355 370
356 371 QString PythonQtWrapper_ElfFile::getSymbolLinkType(ElfFile* theWrappedObject, int index)
357 372 {
358 373 return ( theWrappedObject->getSymbolLinkType(index));
359 374 }
360 375
361 376 QString PythonQtWrapper_ElfFile::getSymbolName(ElfFile* theWrappedObject, int index)
362 377 {
363 378 return ( theWrappedObject->getSymbolName(index));
364 379 }
365 380
366 381 int PythonQtWrapper_ElfFile::getSymbolSectionIndex(ElfFile* theWrappedObject, int index)
367 382 {
368 383 return ( theWrappedObject->getSymbolSectionIndex(index));
369 384 }
370 385
371 386 QString PythonQtWrapper_ElfFile::getSymbolSectionName(ElfFile* theWrappedObject, int index)
372 387 {
373 388 return ( theWrappedObject->getSymbolSectionName(index));
374 389 }
375 390
376 391 quint64 PythonQtWrapper_ElfFile::getSymbolSize(ElfFile* theWrappedObject, int index)
377 392 {
378 393 return ( theWrappedObject->getSymbolSize(index));
379 394 }
380 395
381 396 QString PythonQtWrapper_ElfFile::getSymbolType(ElfFile* theWrappedObject, int index)
382 397 {
383 398 return ( theWrappedObject->getSymbolType(index));
384 399 }
385 400
386 401 QString PythonQtWrapper_ElfFile::getType(ElfFile* theWrappedObject)
387 402 {
388 403 return ( theWrappedObject->getType());
389 404 }
390 405
391 406 qint64 PythonQtWrapper_ElfFile::getVersion(ElfFile* theWrappedObject)
392 407 {
393 408 return ( theWrappedObject->getVersion());
394 409 }
395 410
411 bool PythonQtWrapper_ElfFile::isBigEndian(ElfFile* theWrappedObject)
412 {
413 return ( theWrappedObject->isBigEndian());
414 }
415
396 416 bool PythonQtWrapper_ElfFile::static_ElfFile_isElf(const QString& File)
397 417 {
398 418 return (ElfFile::isElf(File));
399 419 }
400 420
421 bool PythonQtWrapper_ElfFile::isLitleEndian(ElfFile* theWrappedObject)
422 {
423 return ( theWrappedObject->isLitleEndian());
424 }
425
401 426 bool PythonQtWrapper_ElfFile::iself(ElfFile* theWrappedObject)
402 427 {
403 428 return ( theWrappedObject->iself());
404 429 }
405 430
406 431 bool PythonQtWrapper_ElfFile::isopened(ElfFile* theWrappedObject)
407 432 {
408 433 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_isopened());
409 434 }
410 435
411 436 bool PythonQtWrapper_ElfFile::openFile(ElfFile* theWrappedObject, const QString& File)
412 437 {
413 438 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_openFile(File));
414 439 }
415 440
416 441 bool PythonQtWrapper_ElfFile::sectionIsNobits(ElfFile* theWrappedObject, int index)
417 442 {
418 443 return ( theWrappedObject->sectionIsNobits(index));
419 444 }
420 445
421 446 bool PythonQtWrapper_ElfFile::toBinary(ElfFile* theWrappedObject, const QString& File)
422 447 {
423 448 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_toBinary(File));
424 449 }
425 450
426 451 bool PythonQtWrapper_ElfFile::toSrec(ElfFile* theWrappedObject, const QString& File)
427 452 {
428 453 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_toSrec(File));
429 454 }
430 455
431 456
432 457
433 458 PythonQtShell_MemSizeWdgt::~PythonQtShell_MemSizeWdgt() {
434 459 PythonQtPrivate* priv = PythonQt::priv();
435 460 if (priv) { priv->shellClassDeleted(this); }
436 461 }
437 462 void PythonQtShell_MemSizeWdgt::actionEvent(QActionEvent* arg__1)
438 463 {
439 if (_wrapper) {
440 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
441 PyErr_Clear();
442 if (obj && !PythonQtSlotFunction_Check(obj)) {
464 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
465 static PyObject* name = PyString_FromString("actionEvent");
466 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
467 if (obj) {
443 468 static const char* argumentList[] ={"" , "QActionEvent*"};
444 469 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
445 470 void* args[2] = {NULL, (void*)&arg__1};
446 471 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
447 472 if (result) { Py_DECREF(result); }
448 473 Py_DECREF(obj);
449 474 return;
475 } else {
476 PyErr_Clear();
450 477 }
451 478 }
452 479 MemSizeWdgt::actionEvent(arg__1);
453 480 }
454 481 void PythonQtShell_MemSizeWdgt::changeEvent(QEvent* arg__1)
455 482 {
456 if (_wrapper) {
457 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
458 PyErr_Clear();
459 if (obj && !PythonQtSlotFunction_Check(obj)) {
483 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
484 static PyObject* name = PyString_FromString("changeEvent");
485 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
486 if (obj) {
460 487 static const char* argumentList[] ={"" , "QEvent*"};
461 488 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
462 489 void* args[2] = {NULL, (void*)&arg__1};
463 490 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
464 491 if (result) { Py_DECREF(result); }
465 492 Py_DECREF(obj);
466 493 return;
494 } else {
495 PyErr_Clear();
467 496 }
468 497 }
469 498 MemSizeWdgt::changeEvent(arg__1);
470 499 }
471 500 void PythonQtShell_MemSizeWdgt::childEvent(QChildEvent* arg__1)
472 501 {
473 if (_wrapper) {
474 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
475 PyErr_Clear();
476 if (obj && !PythonQtSlotFunction_Check(obj)) {
502 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
503 static PyObject* name = PyString_FromString("childEvent");
504 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
505 if (obj) {
477 506 static const char* argumentList[] ={"" , "QChildEvent*"};
478 507 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
479 508 void* args[2] = {NULL, (void*)&arg__1};
480 509 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
481 510 if (result) { Py_DECREF(result); }
482 511 Py_DECREF(obj);
483 512 return;
513 } else {
514 PyErr_Clear();
484 515 }
485 516 }
486 517 MemSizeWdgt::childEvent(arg__1);
487 518 }
488 519 void PythonQtShell_MemSizeWdgt::closeEvent(QCloseEvent* arg__1)
489 520 {
490 if (_wrapper) {
491 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
492 PyErr_Clear();
493 if (obj && !PythonQtSlotFunction_Check(obj)) {
521 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
522 static PyObject* name = PyString_FromString("closeEvent");
523 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
524 if (obj) {
494 525 static const char* argumentList[] ={"" , "QCloseEvent*"};
495 526 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
496 527 void* args[2] = {NULL, (void*)&arg__1};
497 528 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
498 529 if (result) { Py_DECREF(result); }
499 530 Py_DECREF(obj);
500 531 return;
532 } else {
533 PyErr_Clear();
501 534 }
502 535 }
503 536 MemSizeWdgt::closeEvent(arg__1);
504 537 }
505 538 void PythonQtShell_MemSizeWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
506 539 {
507 if (_wrapper) {
508 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
509 PyErr_Clear();
510 if (obj && !PythonQtSlotFunction_Check(obj)) {
540 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
541 static PyObject* name = PyString_FromString("contextMenuEvent");
542 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
543 if (obj) {
511 544 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
512 545 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
513 546 void* args[2] = {NULL, (void*)&arg__1};
514 547 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
515 548 if (result) { Py_DECREF(result); }
516 549 Py_DECREF(obj);
517 550 return;
551 } else {
552 PyErr_Clear();
518 553 }
519 554 }
520 555 MemSizeWdgt::contextMenuEvent(arg__1);
521 556 }
522 557 void PythonQtShell_MemSizeWdgt::customEvent(QEvent* arg__1)
523 558 {
524 if (_wrapper) {
525 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
526 PyErr_Clear();
527 if (obj && !PythonQtSlotFunction_Check(obj)) {
559 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
560 static PyObject* name = PyString_FromString("customEvent");
561 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
562 if (obj) {
528 563 static const char* argumentList[] ={"" , "QEvent*"};
529 564 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
530 565 void* args[2] = {NULL, (void*)&arg__1};
531 566 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
532 567 if (result) { Py_DECREF(result); }
533 568 Py_DECREF(obj);
534 569 return;
570 } else {
571 PyErr_Clear();
535 572 }
536 573 }
537 574 MemSizeWdgt::customEvent(arg__1);
538 575 }
539 576 int PythonQtShell_MemSizeWdgt::devType() const
540 577 {
541 if (_wrapper) {
542 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
543 PyErr_Clear();
544 if (obj && !PythonQtSlotFunction_Check(obj)) {
578 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
579 static PyObject* name = PyString_FromString("devType");
580 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
581 if (obj) {
545 582 static const char* argumentList[] ={"int"};
546 583 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
547 584 int returnValue;
548 585 void* args[1] = {NULL};
549 586 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
550 587 if (result) {
551 588 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
552 589 if (args[0]!=&returnValue) {
553 590 if (args[0]==NULL) {
554 591 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
555 592 } else {
556 593 returnValue = *((int*)args[0]);
557 594 }
558 595 }
559 596 }
560 597 if (result) { Py_DECREF(result); }
561 598 Py_DECREF(obj);
562 599 return returnValue;
600 } else {
601 PyErr_Clear();
563 602 }
564 603 }
565 604 return MemSizeWdgt::devType();
566 605 }
567 606 void PythonQtShell_MemSizeWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
568 607 {
569 if (_wrapper) {
570 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
571 PyErr_Clear();
572 if (obj && !PythonQtSlotFunction_Check(obj)) {
608 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
609 static PyObject* name = PyString_FromString("dragEnterEvent");
610 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
611 if (obj) {
573 612 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
574 613 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
575 614 void* args[2] = {NULL, (void*)&arg__1};
576 615 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
577 616 if (result) { Py_DECREF(result); }
578 617 Py_DECREF(obj);
579 618 return;
619 } else {
620 PyErr_Clear();
580 621 }
581 622 }
582 623 MemSizeWdgt::dragEnterEvent(arg__1);
583 624 }
584 625 void PythonQtShell_MemSizeWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
585 626 {
586 if (_wrapper) {
587 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
588 PyErr_Clear();
589 if (obj && !PythonQtSlotFunction_Check(obj)) {
627 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
628 static PyObject* name = PyString_FromString("dragLeaveEvent");
629 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
630 if (obj) {
590 631 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
591 632 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
592 633 void* args[2] = {NULL, (void*)&arg__1};
593 634 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
594 635 if (result) { Py_DECREF(result); }
595 636 Py_DECREF(obj);
596 637 return;
638 } else {
639 PyErr_Clear();
597 640 }
598 641 }
599 642 MemSizeWdgt::dragLeaveEvent(arg__1);
600 643 }
601 644 void PythonQtShell_MemSizeWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
602 645 {
603 if (_wrapper) {
604 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
605 PyErr_Clear();
606 if (obj && !PythonQtSlotFunction_Check(obj)) {
646 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
647 static PyObject* name = PyString_FromString("dragMoveEvent");
648 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
649 if (obj) {
607 650 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
608 651 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
609 652 void* args[2] = {NULL, (void*)&arg__1};
610 653 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
611 654 if (result) { Py_DECREF(result); }
612 655 Py_DECREF(obj);
613 656 return;
657 } else {
658 PyErr_Clear();
614 659 }
615 660 }
616 661 MemSizeWdgt::dragMoveEvent(arg__1);
617 662 }
618 663 void PythonQtShell_MemSizeWdgt::dropEvent(QDropEvent* arg__1)
619 664 {
620 if (_wrapper) {
621 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
622 PyErr_Clear();
623 if (obj && !PythonQtSlotFunction_Check(obj)) {
665 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
666 static PyObject* name = PyString_FromString("dropEvent");
667 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
668 if (obj) {
624 669 static const char* argumentList[] ={"" , "QDropEvent*"};
625 670 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
626 671 void* args[2] = {NULL, (void*)&arg__1};
627 672 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
628 673 if (result) { Py_DECREF(result); }
629 674 Py_DECREF(obj);
630 675 return;
676 } else {
677 PyErr_Clear();
631 678 }
632 679 }
633 680 MemSizeWdgt::dropEvent(arg__1);
634 681 }
635 682 void PythonQtShell_MemSizeWdgt::enterEvent(QEvent* arg__1)
636 683 {
637 if (_wrapper) {
638 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
639 PyErr_Clear();
640 if (obj && !PythonQtSlotFunction_Check(obj)) {
684 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
685 static PyObject* name = PyString_FromString("enterEvent");
686 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
687 if (obj) {
641 688 static const char* argumentList[] ={"" , "QEvent*"};
642 689 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
643 690 void* args[2] = {NULL, (void*)&arg__1};
644 691 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
645 692 if (result) { Py_DECREF(result); }
646 693 Py_DECREF(obj);
647 694 return;
695 } else {
696 PyErr_Clear();
648 697 }
649 698 }
650 699 MemSizeWdgt::enterEvent(arg__1);
651 700 }
652 701 bool PythonQtShell_MemSizeWdgt::event(QEvent* arg__1)
653 702 {
654 if (_wrapper) {
655 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
656 PyErr_Clear();
657 if (obj && !PythonQtSlotFunction_Check(obj)) {
703 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
704 static PyObject* name = PyString_FromString("event");
705 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
706 if (obj) {
658 707 static const char* argumentList[] ={"bool" , "QEvent*"};
659 708 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
660 709 bool returnValue;
661 710 void* args[2] = {NULL, (void*)&arg__1};
662 711 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
663 712 if (result) {
664 713 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
665 714 if (args[0]!=&returnValue) {
666 715 if (args[0]==NULL) {
667 716 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
668 717 } else {
669 718 returnValue = *((bool*)args[0]);
670 719 }
671 720 }
672 721 }
673 722 if (result) { Py_DECREF(result); }
674 723 Py_DECREF(obj);
675 724 return returnValue;
725 } else {
726 PyErr_Clear();
676 727 }
677 728 }
678 729 return MemSizeWdgt::event(arg__1);
679 730 }
680 731 bool PythonQtShell_MemSizeWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
681 732 {
682 if (_wrapper) {
683 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
684 PyErr_Clear();
685 if (obj && !PythonQtSlotFunction_Check(obj)) {
733 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
734 static PyObject* name = PyString_FromString("eventFilter");
735 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
736 if (obj) {
686 737 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
687 738 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
688 739 bool returnValue;
689 740 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
690 741 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
691 742 if (result) {
692 743 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
693 744 if (args[0]!=&returnValue) {
694 745 if (args[0]==NULL) {
695 746 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
696 747 } else {
697 748 returnValue = *((bool*)args[0]);
698 749 }
699 750 }
700 751 }
701 752 if (result) { Py_DECREF(result); }
702 753 Py_DECREF(obj);
703 754 return returnValue;
755 } else {
756 PyErr_Clear();
704 757 }
705 758 }
706 759 return MemSizeWdgt::eventFilter(arg__1, arg__2);
707 760 }
708 761 void PythonQtShell_MemSizeWdgt::focusInEvent(QFocusEvent* arg__1)
709 762 {
710 if (_wrapper) {
711 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
712 PyErr_Clear();
713 if (obj && !PythonQtSlotFunction_Check(obj)) {
763 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
764 static PyObject* name = PyString_FromString("focusInEvent");
765 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
766 if (obj) {
714 767 static const char* argumentList[] ={"" , "QFocusEvent*"};
715 768 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
716 769 void* args[2] = {NULL, (void*)&arg__1};
717 770 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
718 771 if (result) { Py_DECREF(result); }
719 772 Py_DECREF(obj);
720 773 return;
774 } else {
775 PyErr_Clear();
721 776 }
722 777 }
723 778 MemSizeWdgt::focusInEvent(arg__1);
724 779 }
725 bool PythonQtShell_MemSizeWdgt::focusNextPrevChild(bool next)
726 {
727 if (_wrapper) {
728 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
729 PyErr_Clear();
730 if (obj && !PythonQtSlotFunction_Check(obj)) {
780 bool PythonQtShell_MemSizeWdgt::focusNextPrevChild(bool next0)
781 {
782 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
783 static PyObject* name = PyString_FromString("focusNextPrevChild");
784 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
785 if (obj) {
731 786 static const char* argumentList[] ={"bool" , "bool"};
732 787 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
733 788 bool returnValue;
734 void* args[2] = {NULL, (void*)&next};
789 void* args[2] = {NULL, (void*)&next0};
735 790 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
736 791 if (result) {
737 792 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
738 793 if (args[0]!=&returnValue) {
739 794 if (args[0]==NULL) {
740 795 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
741 796 } else {
742 797 returnValue = *((bool*)args[0]);
743 798 }
744 799 }
745 800 }
746 801 if (result) { Py_DECREF(result); }
747 802 Py_DECREF(obj);
748 803 return returnValue;
749 }
750 }
751 return MemSizeWdgt::focusNextPrevChild(next);
804 } else {
805 PyErr_Clear();
806 }
807 }
808 return MemSizeWdgt::focusNextPrevChild(next0);
752 809 }
753 810 void PythonQtShell_MemSizeWdgt::focusOutEvent(QFocusEvent* arg__1)
754 811 {
755 if (_wrapper) {
756 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
757 PyErr_Clear();
758 if (obj && !PythonQtSlotFunction_Check(obj)) {
812 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
813 static PyObject* name = PyString_FromString("focusOutEvent");
814 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
815 if (obj) {
759 816 static const char* argumentList[] ={"" , "QFocusEvent*"};
760 817 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
761 818 void* args[2] = {NULL, (void*)&arg__1};
762 819 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
763 820 if (result) { Py_DECREF(result); }
764 821 Py_DECREF(obj);
765 822 return;
823 } else {
824 PyErr_Clear();
766 825 }
767 826 }
768 827 MemSizeWdgt::focusOutEvent(arg__1);
769 828 }
770 829 bool PythonQtShell_MemSizeWdgt::hasHeightForWidth() const
771 830 {
772 if (_wrapper) {
773 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
774 PyErr_Clear();
775 if (obj && !PythonQtSlotFunction_Check(obj)) {
831 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
832 static PyObject* name = PyString_FromString("hasHeightForWidth");
833 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
834 if (obj) {
776 835 static const char* argumentList[] ={"bool"};
777 836 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
778 837 bool returnValue;
779 838 void* args[1] = {NULL};
780 839 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
781 840 if (result) {
782 841 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
783 842 if (args[0]!=&returnValue) {
784 843 if (args[0]==NULL) {
785 844 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
786 845 } else {
787 846 returnValue = *((bool*)args[0]);
788 847 }
789 848 }
790 849 }
791 850 if (result) { Py_DECREF(result); }
792 851 Py_DECREF(obj);
793 852 return returnValue;
853 } else {
854 PyErr_Clear();
794 855 }
795 856 }
796 857 return MemSizeWdgt::hasHeightForWidth();
797 858 }
798 859 int PythonQtShell_MemSizeWdgt::heightForWidth(int arg__1) const
799 860 {
800 if (_wrapper) {
801 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
802 PyErr_Clear();
803 if (obj && !PythonQtSlotFunction_Check(obj)) {
861 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
862 static PyObject* name = PyString_FromString("heightForWidth");
863 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
864 if (obj) {
804 865 static const char* argumentList[] ={"int" , "int"};
805 866 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
806 867 int returnValue;
807 868 void* args[2] = {NULL, (void*)&arg__1};
808 869 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
809 870 if (result) {
810 871 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
811 872 if (args[0]!=&returnValue) {
812 873 if (args[0]==NULL) {
813 874 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
814 875 } else {
815 876 returnValue = *((int*)args[0]);
816 877 }
817 878 }
818 879 }
819 880 if (result) { Py_DECREF(result); }
820 881 Py_DECREF(obj);
821 882 return returnValue;
883 } else {
884 PyErr_Clear();
822 885 }
823 886 }
824 887 return MemSizeWdgt::heightForWidth(arg__1);
825 888 }
826 889 void PythonQtShell_MemSizeWdgt::hideEvent(QHideEvent* arg__1)
827 890 {
828 if (_wrapper) {
829 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
830 PyErr_Clear();
831 if (obj && !PythonQtSlotFunction_Check(obj)) {
891 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
892 static PyObject* name = PyString_FromString("hideEvent");
893 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
894 if (obj) {
832 895 static const char* argumentList[] ={"" , "QHideEvent*"};
833 896 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
834 897 void* args[2] = {NULL, (void*)&arg__1};
835 898 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
836 899 if (result) { Py_DECREF(result); }
837 900 Py_DECREF(obj);
838 901 return;
902 } else {
903 PyErr_Clear();
839 904 }
840 905 }
841 906 MemSizeWdgt::hideEvent(arg__1);
842 907 }
843 void PythonQtShell_MemSizeWdgt::initPainter(QPainter* painter) const
844 {
845 if (_wrapper) {
846 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
847 PyErr_Clear();
848 if (obj && !PythonQtSlotFunction_Check(obj)) {
908 void PythonQtShell_MemSizeWdgt::initPainter(QPainter* painter0) const
909 {
910 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
911 static PyObject* name = PyString_FromString("initPainter");
912 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
913 if (obj) {
849 914 static const char* argumentList[] ={"" , "QPainter*"};
850 915 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
851 void* args[2] = {NULL, (void*)&painter};
852 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
853 if (result) { Py_DECREF(result); }
854 Py_DECREF(obj);
855 return;
856 }
857 }
858 MemSizeWdgt::initPainter(painter);
916 void* args[2] = {NULL, (void*)&painter0};
917 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
918 if (result) { Py_DECREF(result); }
919 Py_DECREF(obj);
920 return;
921 } else {
922 PyErr_Clear();
923 }
924 }
925 MemSizeWdgt::initPainter(painter0);
859 926 }
860 927 void PythonQtShell_MemSizeWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
861 928 {
862 if (_wrapper) {
863 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
864 PyErr_Clear();
865 if (obj && !PythonQtSlotFunction_Check(obj)) {
929 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
930 static PyObject* name = PyString_FromString("inputMethodEvent");
931 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
932 if (obj) {
866 933 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
867 934 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
868 935 void* args[2] = {NULL, (void*)&arg__1};
869 936 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
870 937 if (result) { Py_DECREF(result); }
871 938 Py_DECREF(obj);
872 939 return;
940 } else {
941 PyErr_Clear();
873 942 }
874 943 }
875 944 MemSizeWdgt::inputMethodEvent(arg__1);
876 945 }
877 946 QVariant PythonQtShell_MemSizeWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
878 947 {
879 if (_wrapper) {
880 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
881 PyErr_Clear();
882 if (obj && !PythonQtSlotFunction_Check(obj)) {
948 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
949 static PyObject* name = PyString_FromString("inputMethodQuery");
950 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
951 if (obj) {
883 952 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
884 953 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
885 954 QVariant returnValue;
886 955 void* args[2] = {NULL, (void*)&arg__1};
887 956 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
888 957 if (result) {
889 958 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
890 959 if (args[0]!=&returnValue) {
891 960 if (args[0]==NULL) {
892 961 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
893 962 } else {
894 963 returnValue = *((QVariant*)args[0]);
895 964 }
896 965 }
897 966 }
898 967 if (result) { Py_DECREF(result); }
899 968 Py_DECREF(obj);
900 969 return returnValue;
970 } else {
971 PyErr_Clear();
901 972 }
902 973 }
903 974 return MemSizeWdgt::inputMethodQuery(arg__1);
904 975 }
905 976 void PythonQtShell_MemSizeWdgt::keyPressEvent(QKeyEvent* arg__1)
906 977 {
907 if (_wrapper) {
908 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
909 PyErr_Clear();
910 if (obj && !PythonQtSlotFunction_Check(obj)) {
978 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
979 static PyObject* name = PyString_FromString("keyPressEvent");
980 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
981 if (obj) {
911 982 static const char* argumentList[] ={"" , "QKeyEvent*"};
912 983 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
913 984 void* args[2] = {NULL, (void*)&arg__1};
914 985 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
915 986 if (result) { Py_DECREF(result); }
916 987 Py_DECREF(obj);
917 988 return;
989 } else {
990 PyErr_Clear();
918 991 }
919 992 }
920 993 MemSizeWdgt::keyPressEvent(arg__1);
921 994 }
922 995 void PythonQtShell_MemSizeWdgt::keyReleaseEvent(QKeyEvent* arg__1)
923 996 {
924 if (_wrapper) {
925 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
926 PyErr_Clear();
927 if (obj && !PythonQtSlotFunction_Check(obj)) {
997 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
998 static PyObject* name = PyString_FromString("keyReleaseEvent");
999 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1000 if (obj) {
928 1001 static const char* argumentList[] ={"" , "QKeyEvent*"};
929 1002 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
930 1003 void* args[2] = {NULL, (void*)&arg__1};
931 1004 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
932 1005 if (result) { Py_DECREF(result); }
933 1006 Py_DECREF(obj);
934 1007 return;
1008 } else {
1009 PyErr_Clear();
935 1010 }
936 1011 }
937 1012 MemSizeWdgt::keyReleaseEvent(arg__1);
938 1013 }
939 1014 void PythonQtShell_MemSizeWdgt::leaveEvent(QEvent* arg__1)
940 1015 {
941 if (_wrapper) {
942 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
943 PyErr_Clear();
944 if (obj && !PythonQtSlotFunction_Check(obj)) {
1016 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1017 static PyObject* name = PyString_FromString("leaveEvent");
1018 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1019 if (obj) {
945 1020 static const char* argumentList[] ={"" , "QEvent*"};
946 1021 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
947 1022 void* args[2] = {NULL, (void*)&arg__1};
948 1023 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
949 1024 if (result) { Py_DECREF(result); }
950 1025 Py_DECREF(obj);
951 1026 return;
1027 } else {
1028 PyErr_Clear();
952 1029 }
953 1030 }
954 1031 MemSizeWdgt::leaveEvent(arg__1);
955 1032 }
956 1033 int PythonQtShell_MemSizeWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
957 1034 {
958 if (_wrapper) {
959 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
960 PyErr_Clear();
961 if (obj && !PythonQtSlotFunction_Check(obj)) {
1035 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1036 static PyObject* name = PyString_FromString("metric");
1037 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1038 if (obj) {
962 1039 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
963 1040 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
964 1041 int returnValue;
965 1042 void* args[2] = {NULL, (void*)&arg__1};
966 1043 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
967 1044 if (result) {
968 1045 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
969 1046 if (args[0]!=&returnValue) {
970 1047 if (args[0]==NULL) {
971 1048 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
972 1049 } else {
973 1050 returnValue = *((int*)args[0]);
974 1051 }
975 1052 }
976 1053 }
977 1054 if (result) { Py_DECREF(result); }
978 1055 Py_DECREF(obj);
979 1056 return returnValue;
1057 } else {
1058 PyErr_Clear();
980 1059 }
981 1060 }
982 1061 return MemSizeWdgt::metric(arg__1);
983 1062 }
984 1063 QSize PythonQtShell_MemSizeWdgt::minimumSizeHint() const
985 1064 {
986 if (_wrapper) {
987 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
988 PyErr_Clear();
989 if (obj && !PythonQtSlotFunction_Check(obj)) {
1065 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1066 static PyObject* name = PyString_FromString("getMinimumSizeHint");
1067 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1068 if (obj) {
990 1069 static const char* argumentList[] ={"QSize"};
991 1070 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
992 1071 QSize returnValue;
993 1072 void* args[1] = {NULL};
994 1073 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
995 1074 if (result) {
996 1075 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
997 1076 if (args[0]!=&returnValue) {
998 1077 if (args[0]==NULL) {
999 1078 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
1000 1079 } else {
1001 1080 returnValue = *((QSize*)args[0]);
1002 1081 }
1003 1082 }
1004 1083 }
1005 1084 if (result) { Py_DECREF(result); }
1006 1085 Py_DECREF(obj);
1007 1086 return returnValue;
1087 } else {
1088 PyErr_Clear();
1008 1089 }
1009 1090 }
1010 1091 return MemSizeWdgt::minimumSizeHint();
1011 1092 }
1012 1093 void PythonQtShell_MemSizeWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
1013 1094 {
1014 if (_wrapper) {
1015 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
1016 PyErr_Clear();
1017 if (obj && !PythonQtSlotFunction_Check(obj)) {
1095 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1096 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
1097 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1098 if (obj) {
1018 1099 static const char* argumentList[] ={"" , "QMouseEvent*"};
1019 1100 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1020 1101 void* args[2] = {NULL, (void*)&arg__1};
1021 1102 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1022 1103 if (result) { Py_DECREF(result); }
1023 1104 Py_DECREF(obj);
1024 1105 return;
1106 } else {
1107 PyErr_Clear();
1025 1108 }
1026 1109 }
1027 1110 MemSizeWdgt::mouseDoubleClickEvent(arg__1);
1028 1111 }
1029 1112 void PythonQtShell_MemSizeWdgt::mouseMoveEvent(QMouseEvent* arg__1)
1030 1113 {
1031 if (_wrapper) {
1032 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
1033 PyErr_Clear();
1034 if (obj && !PythonQtSlotFunction_Check(obj)) {
1114 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1115 static PyObject* name = PyString_FromString("mouseMoveEvent");
1116 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1117 if (obj) {
1035 1118 static const char* argumentList[] ={"" , "QMouseEvent*"};
1036 1119 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1037 1120 void* args[2] = {NULL, (void*)&arg__1};
1038 1121 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1039 1122 if (result) { Py_DECREF(result); }
1040 1123 Py_DECREF(obj);
1041 1124 return;
1125 } else {
1126 PyErr_Clear();
1042 1127 }
1043 1128 }
1044 1129 MemSizeWdgt::mouseMoveEvent(arg__1);
1045 1130 }
1046 1131 void PythonQtShell_MemSizeWdgt::mousePressEvent(QMouseEvent* arg__1)
1047 1132 {
1048 if (_wrapper) {
1049 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
1050 PyErr_Clear();
1051 if (obj && !PythonQtSlotFunction_Check(obj)) {
1133 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1134 static PyObject* name = PyString_FromString("mousePressEvent");
1135 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1136 if (obj) {
1052 1137 static const char* argumentList[] ={"" , "QMouseEvent*"};
1053 1138 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1054 1139 void* args[2] = {NULL, (void*)&arg__1};
1055 1140 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1056 1141 if (result) { Py_DECREF(result); }
1057 1142 Py_DECREF(obj);
1058 1143 return;
1144 } else {
1145 PyErr_Clear();
1059 1146 }
1060 1147 }
1061 1148 MemSizeWdgt::mousePressEvent(arg__1);
1062 1149 }
1063 1150 void PythonQtShell_MemSizeWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
1064 1151 {
1065 if (_wrapper) {
1066 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
1067 PyErr_Clear();
1068 if (obj && !PythonQtSlotFunction_Check(obj)) {
1152 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1153 static PyObject* name = PyString_FromString("mouseReleaseEvent");
1154 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1155 if (obj) {
1069 1156 static const char* argumentList[] ={"" , "QMouseEvent*"};
1070 1157 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1071 1158 void* args[2] = {NULL, (void*)&arg__1};
1072 1159 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1073 1160 if (result) { Py_DECREF(result); }
1074 1161 Py_DECREF(obj);
1075 1162 return;
1163 } else {
1164 PyErr_Clear();
1076 1165 }
1077 1166 }
1078 1167 MemSizeWdgt::mouseReleaseEvent(arg__1);
1079 1168 }
1080 1169 void PythonQtShell_MemSizeWdgt::moveEvent(QMoveEvent* arg__1)
1081 1170 {
1082 if (_wrapper) {
1083 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
1084 PyErr_Clear();
1085 if (obj && !PythonQtSlotFunction_Check(obj)) {
1171 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1172 static PyObject* name = PyString_FromString("moveEvent");
1173 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1174 if (obj) {
1086 1175 static const char* argumentList[] ={"" , "QMoveEvent*"};
1087 1176 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1088 1177 void* args[2] = {NULL, (void*)&arg__1};
1089 1178 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1090 1179 if (result) { Py_DECREF(result); }
1091 1180 Py_DECREF(obj);
1092 1181 return;
1182 } else {
1183 PyErr_Clear();
1093 1184 }
1094 1185 }
1095 1186 MemSizeWdgt::moveEvent(arg__1);
1096 1187 }
1097 bool PythonQtShell_MemSizeWdgt::nativeEvent(const QByteArray& eventType, void* message, long* result)
1098 {
1099 if (_wrapper) {
1100 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
1101 PyErr_Clear();
1102 if (obj && !PythonQtSlotFunction_Check(obj)) {
1188 bool PythonQtShell_MemSizeWdgt::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
1189 {
1190 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1191 static PyObject* name = PyString_FromString("nativeEvent");
1192 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1193 if (obj) {
1103 1194 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
1104 1195 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
1105 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 1198 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1108 1199 if (result) {
1109 1200 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1110 1201 if (args[0]!=&returnValue) {
1111 1202 if (args[0]==NULL) {
1112 1203 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
1113 1204 } else {
1114 1205 returnValue = *((bool*)args[0]);
1115 1206 }
1116 1207 }
1117 1208 }
1118 1209 if (result) { Py_DECREF(result); }
1119 1210 Py_DECREF(obj);
1120 1211 return returnValue;
1121 }
1122 }
1123 return MemSizeWdgt::nativeEvent(eventType, message, result);
1212 } else {
1213 PyErr_Clear();
1214 }
1215 }
1216 return MemSizeWdgt::nativeEvent(eventType0, message1, result2);
1124 1217 }
1125 1218 QPaintEngine* PythonQtShell_MemSizeWdgt::paintEngine() const
1126 1219 {
1127 if (_wrapper) {
1128 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
1129 PyErr_Clear();
1130 if (obj && !PythonQtSlotFunction_Check(obj)) {
1220 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1221 static PyObject* name = PyString_FromString("paintEngine");
1222 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1223 if (obj) {
1131 1224 static const char* argumentList[] ={"QPaintEngine*"};
1132 1225 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1133 1226 QPaintEngine* returnValue;
1134 1227 void* args[1] = {NULL};
1135 1228 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1136 1229 if (result) {
1137 1230 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1138 1231 if (args[0]!=&returnValue) {
1139 1232 if (args[0]==NULL) {
1140 1233 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
1141 1234 } else {
1142 1235 returnValue = *((QPaintEngine**)args[0]);
1143 1236 }
1144 1237 }
1145 1238 }
1146 1239 if (result) { Py_DECREF(result); }
1147 1240 Py_DECREF(obj);
1148 1241 return returnValue;
1242 } else {
1243 PyErr_Clear();
1149 1244 }
1150 1245 }
1151 1246 return MemSizeWdgt::paintEngine();
1152 1247 }
1153 1248 void PythonQtShell_MemSizeWdgt::paintEvent(QPaintEvent* arg__1)
1154 1249 {
1155 if (_wrapper) {
1156 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
1157 PyErr_Clear();
1158 if (obj && !PythonQtSlotFunction_Check(obj)) {
1250 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1251 static PyObject* name = PyString_FromString("paintEvent");
1252 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1253 if (obj) {
1159 1254 static const char* argumentList[] ={"" , "QPaintEvent*"};
1160 1255 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1161 1256 void* args[2] = {NULL, (void*)&arg__1};
1162 1257 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1163 1258 if (result) { Py_DECREF(result); }
1164 1259 Py_DECREF(obj);
1165 1260 return;
1261 } else {
1262 PyErr_Clear();
1166 1263 }
1167 1264 }
1168 1265 MemSizeWdgt::paintEvent(arg__1);
1169 1266 }
1170 QPaintDevice* PythonQtShell_MemSizeWdgt::redirected(QPoint* offset) const
1171 {
1172 if (_wrapper) {
1173 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
1174 PyErr_Clear();
1175 if (obj && !PythonQtSlotFunction_Check(obj)) {
1267 QPaintDevice* PythonQtShell_MemSizeWdgt::redirected(QPoint* offset0) const
1268 {
1269 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1270 static PyObject* name = PyString_FromString("redirected");
1271 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1272 if (obj) {
1176 1273 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
1177 1274 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1178 1275 QPaintDevice* returnValue;
1179 void* args[2] = {NULL, (void*)&offset};
1276 void* args[2] = {NULL, (void*)&offset0};
1180 1277 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1181 1278 if (result) {
1182 1279 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1183 1280 if (args[0]!=&returnValue) {
1184 1281 if (args[0]==NULL) {
1185 1282 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
1186 1283 } else {
1187 1284 returnValue = *((QPaintDevice**)args[0]);
1188 1285 }
1189 1286 }
1190 1287 }
1191 1288 if (result) { Py_DECREF(result); }
1192 1289 Py_DECREF(obj);
1193 1290 return returnValue;
1194 }
1195 }
1196 return MemSizeWdgt::redirected(offset);
1291 } else {
1292 PyErr_Clear();
1293 }
1294 }
1295 return MemSizeWdgt::redirected(offset0);
1197 1296 }
1198 1297 void PythonQtShell_MemSizeWdgt::resizeEvent(QResizeEvent* arg__1)
1199 1298 {
1200 if (_wrapper) {
1201 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
1202 PyErr_Clear();
1203 if (obj && !PythonQtSlotFunction_Check(obj)) {
1299 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1300 static PyObject* name = PyString_FromString("resizeEvent");
1301 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1302 if (obj) {
1204 1303 static const char* argumentList[] ={"" , "QResizeEvent*"};
1205 1304 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1206 1305 void* args[2] = {NULL, (void*)&arg__1};
1207 1306 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1208 1307 if (result) { Py_DECREF(result); }
1209 1308 Py_DECREF(obj);
1210 1309 return;
1310 } else {
1311 PyErr_Clear();
1211 1312 }
1212 1313 }
1213 1314 MemSizeWdgt::resizeEvent(arg__1);
1214 1315 }
1215 1316 QPainter* PythonQtShell_MemSizeWdgt::sharedPainter() const
1216 1317 {
1217 if (_wrapper) {
1218 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
1219 PyErr_Clear();
1220 if (obj && !PythonQtSlotFunction_Check(obj)) {
1318 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1319 static PyObject* name = PyString_FromString("sharedPainter");
1320 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1321 if (obj) {
1221 1322 static const char* argumentList[] ={"QPainter*"};
1222 1323 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1223 1324 QPainter* returnValue;
1224 1325 void* args[1] = {NULL};
1225 1326 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1226 1327 if (result) {
1227 1328 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1228 1329 if (args[0]!=&returnValue) {
1229 1330 if (args[0]==NULL) {
1230 1331 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
1231 1332 } else {
1232 1333 returnValue = *((QPainter**)args[0]);
1233 1334 }
1234 1335 }
1235 1336 }
1236 1337 if (result) { Py_DECREF(result); }
1237 1338 Py_DECREF(obj);
1238 1339 return returnValue;
1340 } else {
1341 PyErr_Clear();
1239 1342 }
1240 1343 }
1241 1344 return MemSizeWdgt::sharedPainter();
1242 1345 }
1243 1346 void PythonQtShell_MemSizeWdgt::showEvent(QShowEvent* arg__1)
1244 1347 {
1245 if (_wrapper) {
1246 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
1247 PyErr_Clear();
1248 if (obj && !PythonQtSlotFunction_Check(obj)) {
1348 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1349 static PyObject* name = PyString_FromString("showEvent");
1350 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1351 if (obj) {
1249 1352 static const char* argumentList[] ={"" , "QShowEvent*"};
1250 1353 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1251 1354 void* args[2] = {NULL, (void*)&arg__1};
1252 1355 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1253 1356 if (result) { Py_DECREF(result); }
1254 1357 Py_DECREF(obj);
1255 1358 return;
1359 } else {
1360 PyErr_Clear();
1256 1361 }
1257 1362 }
1258 1363 MemSizeWdgt::showEvent(arg__1);
1259 1364 }
1260 1365 QSize PythonQtShell_MemSizeWdgt::sizeHint() const
1261 1366 {
1262 if (_wrapper) {
1263 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
1264 PyErr_Clear();
1265 if (obj && !PythonQtSlotFunction_Check(obj)) {
1367 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1368 static PyObject* name = PyString_FromString("getSizeHint");
1369 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1370 if (obj) {
1266 1371 static const char* argumentList[] ={"QSize"};
1267 1372 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1268 1373 QSize returnValue;
1269 1374 void* args[1] = {NULL};
1270 1375 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1271 1376 if (result) {
1272 1377 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1273 1378 if (args[0]!=&returnValue) {
1274 1379 if (args[0]==NULL) {
1275 1380 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
1276 1381 } else {
1277 1382 returnValue = *((QSize*)args[0]);
1278 1383 }
1279 1384 }
1280 1385 }
1281 1386 if (result) { Py_DECREF(result); }
1282 1387 Py_DECREF(obj);
1283 1388 return returnValue;
1389 } else {
1390 PyErr_Clear();
1284 1391 }
1285 1392 }
1286 1393 return MemSizeWdgt::sizeHint();
1287 1394 }
1288 1395 void PythonQtShell_MemSizeWdgt::tabletEvent(QTabletEvent* arg__1)
1289 1396 {
1290 if (_wrapper) {
1291 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
1292 PyErr_Clear();
1293 if (obj && !PythonQtSlotFunction_Check(obj)) {
1397 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1398 static PyObject* name = PyString_FromString("tabletEvent");
1399 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1400 if (obj) {
1294 1401 static const char* argumentList[] ={"" , "QTabletEvent*"};
1295 1402 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1296 1403 void* args[2] = {NULL, (void*)&arg__1};
1297 1404 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1298 1405 if (result) { Py_DECREF(result); }
1299 1406 Py_DECREF(obj);
1300 1407 return;
1408 } else {
1409 PyErr_Clear();
1301 1410 }
1302 1411 }
1303 1412 MemSizeWdgt::tabletEvent(arg__1);
1304 1413 }
1305 1414 void PythonQtShell_MemSizeWdgt::timerEvent(QTimerEvent* arg__1)
1306 1415 {
1307 if (_wrapper) {
1308 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
1309 PyErr_Clear();
1310 if (obj && !PythonQtSlotFunction_Check(obj)) {
1416 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1417 static PyObject* name = PyString_FromString("timerEvent");
1418 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1419 if (obj) {
1311 1420 static const char* argumentList[] ={"" , "QTimerEvent*"};
1312 1421 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1313 1422 void* args[2] = {NULL, (void*)&arg__1};
1314 1423 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1315 1424 if (result) { Py_DECREF(result); }
1316 1425 Py_DECREF(obj);
1317 1426 return;
1427 } else {
1428 PyErr_Clear();
1318 1429 }
1319 1430 }
1320 1431 MemSizeWdgt::timerEvent(arg__1);
1321 1432 }
1322 1433 void PythonQtShell_MemSizeWdgt::wheelEvent(QWheelEvent* arg__1)
1323 1434 {
1324 if (_wrapper) {
1325 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
1326 PyErr_Clear();
1327 if (obj && !PythonQtSlotFunction_Check(obj)) {
1435 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1436 static PyObject* name = PyString_FromString("wheelEvent");
1437 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1438 if (obj) {
1328 1439 static const char* argumentList[] ={"" , "QWheelEvent*"};
1329 1440 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1330 1441 void* args[2] = {NULL, (void*)&arg__1};
1331 1442 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1332 1443 if (result) { Py_DECREF(result); }
1333 1444 Py_DECREF(obj);
1334 1445 return;
1446 } else {
1447 PyErr_Clear();
1335 1448 }
1336 1449 }
1337 1450 MemSizeWdgt::wheelEvent(arg__1);
1338 1451 }
1339 1452 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(QWidget* parent)
1340 1453 {
1341 1454 return new PythonQtShell_MemSizeWdgt(parent); }
1342 1455
1343 1456 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(int defaultSize, QWidget* parent)
1344 1457 {
1345 1458 return new PythonQtShell_MemSizeWdgt(defaultSize, parent); }
1346 1459
1347 1460 int PythonQtWrapper_MemSizeWdgt::getsize(MemSizeWdgt* theWrappedObject)
1348 1461 {
1349 1462 return ( theWrappedObject->getsize());
1350 1463 }
1351 1464
1352 1465 void PythonQtWrapper_MemSizeWdgt::setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max)
1353 1466 {
1354 1467 ( theWrappedObject->setMaximum(max));
1355 1468 }
1356 1469
1357 1470 void PythonQtWrapper_MemSizeWdgt::show(MemSizeWdgt* theWrappedObject)
1358 1471 {
1359 1472 ( theWrappedObject->show());
1360 1473 }
1361 1474
1362 1475 void PythonQtWrapper_MemSizeWdgt::updateSizeValue(MemSizeWdgt* theWrappedObject)
1363 1476 {
1364 1477 ( theWrappedObject->updateSizeValue());
1365 1478 }
1366 1479
1367 1480
1368 1481
1369 1482 PythonQtShell_QHexEdit::~PythonQtShell_QHexEdit() {
1370 1483 PythonQtPrivate* priv = PythonQt::priv();
1371 1484 if (priv) { priv->shellClassDeleted(this); }
1372 1485 }
1373 1486 void PythonQtShell_QHexEdit::actionEvent(QActionEvent* arg__1)
1374 1487 {
1375 if (_wrapper) {
1376 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
1377 PyErr_Clear();
1378 if (obj && !PythonQtSlotFunction_Check(obj)) {
1488 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1489 static PyObject* name = PyString_FromString("actionEvent");
1490 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1491 if (obj) {
1379 1492 static const char* argumentList[] ={"" , "QActionEvent*"};
1380 1493 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1381 1494 void* args[2] = {NULL, (void*)&arg__1};
1382 1495 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1383 1496 if (result) { Py_DECREF(result); }
1384 1497 Py_DECREF(obj);
1385 1498 return;
1499 } else {
1500 PyErr_Clear();
1386 1501 }
1387 1502 }
1388 1503 QHexEdit::actionEvent(arg__1);
1389 1504 }
1390 1505 void PythonQtShell_QHexEdit::changeEvent(QEvent* arg__1)
1391 1506 {
1392 if (_wrapper) {
1393 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
1394 PyErr_Clear();
1395 if (obj && !PythonQtSlotFunction_Check(obj)) {
1507 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1508 static PyObject* name = PyString_FromString("changeEvent");
1509 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1510 if (obj) {
1396 1511 static const char* argumentList[] ={"" , "QEvent*"};
1397 1512 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1398 1513 void* args[2] = {NULL, (void*)&arg__1};
1399 1514 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1400 1515 if (result) { Py_DECREF(result); }
1401 1516 Py_DECREF(obj);
1402 1517 return;
1518 } else {
1519 PyErr_Clear();
1403 1520 }
1404 1521 }
1405 1522 QHexEdit::changeEvent(arg__1);
1406 1523 }
1407 1524 void PythonQtShell_QHexEdit::childEvent(QChildEvent* arg__1)
1408 1525 {
1409 if (_wrapper) {
1410 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
1411 PyErr_Clear();
1412 if (obj && !PythonQtSlotFunction_Check(obj)) {
1526 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1527 static PyObject* name = PyString_FromString("childEvent");
1528 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1529 if (obj) {
1413 1530 static const char* argumentList[] ={"" , "QChildEvent*"};
1414 1531 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1415 1532 void* args[2] = {NULL, (void*)&arg__1};
1416 1533 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1417 1534 if (result) { Py_DECREF(result); }
1418 1535 Py_DECREF(obj);
1419 1536 return;
1537 } else {
1538 PyErr_Clear();
1420 1539 }
1421 1540 }
1422 1541 QHexEdit::childEvent(arg__1);
1423 1542 }
1424 1543 void PythonQtShell_QHexEdit::closeEvent(QCloseEvent* arg__1)
1425 1544 {
1426 if (_wrapper) {
1427 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
1428 PyErr_Clear();
1429 if (obj && !PythonQtSlotFunction_Check(obj)) {
1545 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1546 static PyObject* name = PyString_FromString("closeEvent");
1547 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1548 if (obj) {
1430 1549 static const char* argumentList[] ={"" , "QCloseEvent*"};
1431 1550 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1432 1551 void* args[2] = {NULL, (void*)&arg__1};
1433 1552 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1434 1553 if (result) { Py_DECREF(result); }
1435 1554 Py_DECREF(obj);
1436 1555 return;
1556 } else {
1557 PyErr_Clear();
1437 1558 }
1438 1559 }
1439 1560 QHexEdit::closeEvent(arg__1);
1440 1561 }
1441 1562 void PythonQtShell_QHexEdit::contextMenuEvent(QContextMenuEvent* arg__1)
1442 1563 {
1443 if (_wrapper) {
1444 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
1445 PyErr_Clear();
1446 if (obj && !PythonQtSlotFunction_Check(obj)) {
1564 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1565 static PyObject* name = PyString_FromString("contextMenuEvent");
1566 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1567 if (obj) {
1447 1568 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
1448 1569 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1449 1570 void* args[2] = {NULL, (void*)&arg__1};
1450 1571 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1451 1572 if (result) { Py_DECREF(result); }
1452 1573 Py_DECREF(obj);
1453 1574 return;
1575 } else {
1576 PyErr_Clear();
1454 1577 }
1455 1578 }
1456 1579 QHexEdit::contextMenuEvent(arg__1);
1457 1580 }
1458 1581 void PythonQtShell_QHexEdit::customEvent(QEvent* arg__1)
1459 1582 {
1460 if (_wrapper) {
1461 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
1462 PyErr_Clear();
1463 if (obj && !PythonQtSlotFunction_Check(obj)) {
1583 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1584 static PyObject* name = PyString_FromString("customEvent");
1585 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1586 if (obj) {
1464 1587 static const char* argumentList[] ={"" , "QEvent*"};
1465 1588 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1466 1589 void* args[2] = {NULL, (void*)&arg__1};
1467 1590 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1468 1591 if (result) { Py_DECREF(result); }
1469 1592 Py_DECREF(obj);
1470 1593 return;
1594 } else {
1595 PyErr_Clear();
1471 1596 }
1472 1597 }
1473 1598 QHexEdit::customEvent(arg__1);
1474 1599 }
1475 1600 int PythonQtShell_QHexEdit::devType() const
1476 1601 {
1477 if (_wrapper) {
1478 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
1479 PyErr_Clear();
1480 if (obj && !PythonQtSlotFunction_Check(obj)) {
1602 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1603 static PyObject* name = PyString_FromString("devType");
1604 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1605 if (obj) {
1481 1606 static const char* argumentList[] ={"int"};
1482 1607 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1483 1608 int returnValue;
1484 1609 void* args[1] = {NULL};
1485 1610 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1486 1611 if (result) {
1487 1612 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1488 1613 if (args[0]!=&returnValue) {
1489 1614 if (args[0]==NULL) {
1490 1615 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
1491 1616 } else {
1492 1617 returnValue = *((int*)args[0]);
1493 1618 }
1494 1619 }
1495 1620 }
1496 1621 if (result) { Py_DECREF(result); }
1497 1622 Py_DECREF(obj);
1498 1623 return returnValue;
1624 } else {
1625 PyErr_Clear();
1499 1626 }
1500 1627 }
1501 1628 return QHexEdit::devType();
1502 1629 }
1503 1630 void PythonQtShell_QHexEdit::dragEnterEvent(QDragEnterEvent* arg__1)
1504 1631 {
1505 if (_wrapper) {
1506 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
1507 PyErr_Clear();
1508 if (obj && !PythonQtSlotFunction_Check(obj)) {
1632 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1633 static PyObject* name = PyString_FromString("dragEnterEvent");
1634 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1635 if (obj) {
1509 1636 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
1510 1637 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1511 1638 void* args[2] = {NULL, (void*)&arg__1};
1512 1639 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1513 1640 if (result) { Py_DECREF(result); }
1514 1641 Py_DECREF(obj);
1515 1642 return;
1643 } else {
1644 PyErr_Clear();
1516 1645 }
1517 1646 }
1518 1647 QHexEdit::dragEnterEvent(arg__1);
1519 1648 }
1520 1649 void PythonQtShell_QHexEdit::dragLeaveEvent(QDragLeaveEvent* arg__1)
1521 1650 {
1522 if (_wrapper) {
1523 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
1524 PyErr_Clear();
1525 if (obj && !PythonQtSlotFunction_Check(obj)) {
1651 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1652 static PyObject* name = PyString_FromString("dragLeaveEvent");
1653 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1654 if (obj) {
1526 1655 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
1527 1656 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1528 1657 void* args[2] = {NULL, (void*)&arg__1};
1529 1658 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1530 1659 if (result) { Py_DECREF(result); }
1531 1660 Py_DECREF(obj);
1532 1661 return;
1662 } else {
1663 PyErr_Clear();
1533 1664 }
1534 1665 }
1535 1666 QHexEdit::dragLeaveEvent(arg__1);
1536 1667 }
1537 1668 void PythonQtShell_QHexEdit::dragMoveEvent(QDragMoveEvent* arg__1)
1538 1669 {
1539 if (_wrapper) {
1540 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
1541 PyErr_Clear();
1542 if (obj && !PythonQtSlotFunction_Check(obj)) {
1670 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1671 static PyObject* name = PyString_FromString("dragMoveEvent");
1672 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1673 if (obj) {
1543 1674 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
1544 1675 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1545 1676 void* args[2] = {NULL, (void*)&arg__1};
1546 1677 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1547 1678 if (result) { Py_DECREF(result); }
1548 1679 Py_DECREF(obj);
1549 1680 return;
1681 } else {
1682 PyErr_Clear();
1550 1683 }
1551 1684 }
1552 1685 QHexEdit::dragMoveEvent(arg__1);
1553 1686 }
1554 1687 void PythonQtShell_QHexEdit::dropEvent(QDropEvent* arg__1)
1555 1688 {
1556 if (_wrapper) {
1557 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
1558 PyErr_Clear();
1559 if (obj && !PythonQtSlotFunction_Check(obj)) {
1689 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1690 static PyObject* name = PyString_FromString("dropEvent");
1691 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1692 if (obj) {
1560 1693 static const char* argumentList[] ={"" , "QDropEvent*"};
1561 1694 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1562 1695 void* args[2] = {NULL, (void*)&arg__1};
1563 1696 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1564 1697 if (result) { Py_DECREF(result); }
1565 1698 Py_DECREF(obj);
1566 1699 return;
1700 } else {
1701 PyErr_Clear();
1567 1702 }
1568 1703 }
1569 1704 QHexEdit::dropEvent(arg__1);
1570 1705 }
1571 1706 void PythonQtShell_QHexEdit::enterEvent(QEvent* arg__1)
1572 1707 {
1573 if (_wrapper) {
1574 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
1575 PyErr_Clear();
1576 if (obj && !PythonQtSlotFunction_Check(obj)) {
1708 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1709 static PyObject* name = PyString_FromString("enterEvent");
1710 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1711 if (obj) {
1577 1712 static const char* argumentList[] ={"" , "QEvent*"};
1578 1713 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1579 1714 void* args[2] = {NULL, (void*)&arg__1};
1580 1715 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1581 1716 if (result) { Py_DECREF(result); }
1582 1717 Py_DECREF(obj);
1583 1718 return;
1719 } else {
1720 PyErr_Clear();
1584 1721 }
1585 1722 }
1586 1723 QHexEdit::enterEvent(arg__1);
1587 1724 }
1588 1725 bool PythonQtShell_QHexEdit::event(QEvent* arg__1)
1589 1726 {
1590 if (_wrapper) {
1591 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
1592 PyErr_Clear();
1593 if (obj && !PythonQtSlotFunction_Check(obj)) {
1727 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1728 static PyObject* name = PyString_FromString("event");
1729 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1730 if (obj) {
1594 1731 static const char* argumentList[] ={"bool" , "QEvent*"};
1595 1732 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1596 1733 bool returnValue;
1597 1734 void* args[2] = {NULL, (void*)&arg__1};
1598 1735 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1599 1736 if (result) {
1600 1737 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1601 1738 if (args[0]!=&returnValue) {
1602 1739 if (args[0]==NULL) {
1603 1740 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
1604 1741 } else {
1605 1742 returnValue = *((bool*)args[0]);
1606 1743 }
1607 1744 }
1608 1745 }
1609 1746 if (result) { Py_DECREF(result); }
1610 1747 Py_DECREF(obj);
1611 1748 return returnValue;
1749 } else {
1750 PyErr_Clear();
1612 1751 }
1613 1752 }
1614 1753 return QHexEdit::event(arg__1);
1615 1754 }
1616 1755 bool PythonQtShell_QHexEdit::eventFilter(QObject* arg__1, QEvent* arg__2)
1617 1756 {
1618 if (_wrapper) {
1619 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
1620 PyErr_Clear();
1621 if (obj && !PythonQtSlotFunction_Check(obj)) {
1757 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1758 static PyObject* name = PyString_FromString("eventFilter");
1759 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1760 if (obj) {
1622 1761 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
1623 1762 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
1624 1763 bool returnValue;
1625 1764 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
1626 1765 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1627 1766 if (result) {
1628 1767 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1629 1768 if (args[0]!=&returnValue) {
1630 1769 if (args[0]==NULL) {
1631 1770 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
1632 1771 } else {
1633 1772 returnValue = *((bool*)args[0]);
1634 1773 }
1635 1774 }
1636 1775 }
1637 1776 if (result) { Py_DECREF(result); }
1638 1777 Py_DECREF(obj);
1639 1778 return returnValue;
1779 } else {
1780 PyErr_Clear();
1640 1781 }
1641 1782 }
1642 1783 return QHexEdit::eventFilter(arg__1, arg__2);
1643 1784 }
1644 1785 void PythonQtShell_QHexEdit::focusInEvent(QFocusEvent* arg__1)
1645 1786 {
1646 if (_wrapper) {
1647 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
1648 PyErr_Clear();
1649 if (obj && !PythonQtSlotFunction_Check(obj)) {
1787 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1788 static PyObject* name = PyString_FromString("focusInEvent");
1789 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1790 if (obj) {
1650 1791 static const char* argumentList[] ={"" , "QFocusEvent*"};
1651 1792 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1652 1793 void* args[2] = {NULL, (void*)&arg__1};
1653 1794 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1654 1795 if (result) { Py_DECREF(result); }
1655 1796 Py_DECREF(obj);
1656 1797 return;
1798 } else {
1799 PyErr_Clear();
1657 1800 }
1658 1801 }
1659 1802 QHexEdit::focusInEvent(arg__1);
1660 1803 }
1661 bool PythonQtShell_QHexEdit::focusNextPrevChild(bool next)
1662 {
1663 if (_wrapper) {
1664 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
1665 PyErr_Clear();
1666 if (obj && !PythonQtSlotFunction_Check(obj)) {
1804 bool PythonQtShell_QHexEdit::focusNextPrevChild(bool next0)
1805 {
1806 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1807 static PyObject* name = PyString_FromString("focusNextPrevChild");
1808 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1809 if (obj) {
1667 1810 static const char* argumentList[] ={"bool" , "bool"};
1668 1811 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1669 1812 bool returnValue;
1670 void* args[2] = {NULL, (void*)&next};
1813 void* args[2] = {NULL, (void*)&next0};
1671 1814 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1672 1815 if (result) {
1673 1816 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1674 1817 if (args[0]!=&returnValue) {
1675 1818 if (args[0]==NULL) {
1676 1819 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
1677 1820 } else {
1678 1821 returnValue = *((bool*)args[0]);
1679 1822 }
1680 1823 }
1681 1824 }
1682 1825 if (result) { Py_DECREF(result); }
1683 1826 Py_DECREF(obj);
1684 1827 return returnValue;
1685 }
1686 }
1687 return QHexEdit::focusNextPrevChild(next);
1828 } else {
1829 PyErr_Clear();
1830 }
1831 }
1832 return QHexEdit::focusNextPrevChild(next0);
1688 1833 }
1689 1834 void PythonQtShell_QHexEdit::focusOutEvent(QFocusEvent* arg__1)
1690 1835 {
1691 if (_wrapper) {
1692 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
1693 PyErr_Clear();
1694 if (obj && !PythonQtSlotFunction_Check(obj)) {
1836 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1837 static PyObject* name = PyString_FromString("focusOutEvent");
1838 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1839 if (obj) {
1695 1840 static const char* argumentList[] ={"" , "QFocusEvent*"};
1696 1841 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1697 1842 void* args[2] = {NULL, (void*)&arg__1};
1698 1843 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1699 1844 if (result) { Py_DECREF(result); }
1700 1845 Py_DECREF(obj);
1701 1846 return;
1847 } else {
1848 PyErr_Clear();
1702 1849 }
1703 1850 }
1704 1851 QHexEdit::focusOutEvent(arg__1);
1705 1852 }
1706 1853 bool PythonQtShell_QHexEdit::hasHeightForWidth() const
1707 1854 {
1708 if (_wrapper) {
1709 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
1710 PyErr_Clear();
1711 if (obj && !PythonQtSlotFunction_Check(obj)) {
1855 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1856 static PyObject* name = PyString_FromString("hasHeightForWidth");
1857 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1858 if (obj) {
1712 1859 static const char* argumentList[] ={"bool"};
1713 1860 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1714 1861 bool returnValue;
1715 1862 void* args[1] = {NULL};
1716 1863 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1717 1864 if (result) {
1718 1865 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1719 1866 if (args[0]!=&returnValue) {
1720 1867 if (args[0]==NULL) {
1721 1868 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
1722 1869 } else {
1723 1870 returnValue = *((bool*)args[0]);
1724 1871 }
1725 1872 }
1726 1873 }
1727 1874 if (result) { Py_DECREF(result); }
1728 1875 Py_DECREF(obj);
1729 1876 return returnValue;
1877 } else {
1878 PyErr_Clear();
1730 1879 }
1731 1880 }
1732 1881 return QHexEdit::hasHeightForWidth();
1733 1882 }
1734 1883 int PythonQtShell_QHexEdit::heightForWidth(int arg__1) const
1735 1884 {
1736 if (_wrapper) {
1737 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
1738 PyErr_Clear();
1739 if (obj && !PythonQtSlotFunction_Check(obj)) {
1885 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1886 static PyObject* name = PyString_FromString("heightForWidth");
1887 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1888 if (obj) {
1740 1889 static const char* argumentList[] ={"int" , "int"};
1741 1890 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1742 1891 int returnValue;
1743 1892 void* args[2] = {NULL, (void*)&arg__1};
1744 1893 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1745 1894 if (result) {
1746 1895 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1747 1896 if (args[0]!=&returnValue) {
1748 1897 if (args[0]==NULL) {
1749 1898 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
1750 1899 } else {
1751 1900 returnValue = *((int*)args[0]);
1752 1901 }
1753 1902 }
1754 1903 }
1755 1904 if (result) { Py_DECREF(result); }
1756 1905 Py_DECREF(obj);
1757 1906 return returnValue;
1907 } else {
1908 PyErr_Clear();
1758 1909 }
1759 1910 }
1760 1911 return QHexEdit::heightForWidth(arg__1);
1761 1912 }
1762 1913 void PythonQtShell_QHexEdit::hideEvent(QHideEvent* arg__1)
1763 1914 {
1764 if (_wrapper) {
1765 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
1766 PyErr_Clear();
1767 if (obj && !PythonQtSlotFunction_Check(obj)) {
1915 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1916 static PyObject* name = PyString_FromString("hideEvent");
1917 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1918 if (obj) {
1768 1919 static const char* argumentList[] ={"" , "QHideEvent*"};
1769 1920 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1770 1921 void* args[2] = {NULL, (void*)&arg__1};
1771 1922 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1772 1923 if (result) { Py_DECREF(result); }
1773 1924 Py_DECREF(obj);
1774 1925 return;
1926 } else {
1927 PyErr_Clear();
1775 1928 }
1776 1929 }
1777 1930 QHexEdit::hideEvent(arg__1);
1778 1931 }
1779 void PythonQtShell_QHexEdit::initPainter(QPainter* painter) const
1780 {
1781 if (_wrapper) {
1782 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
1783 PyErr_Clear();
1784 if (obj && !PythonQtSlotFunction_Check(obj)) {
1932 void PythonQtShell_QHexEdit::initPainter(QPainter* painter0) const
1933 {
1934 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1935 static PyObject* name = PyString_FromString("initPainter");
1936 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1937 if (obj) {
1785 1938 static const char* argumentList[] ={"" , "QPainter*"};
1786 1939 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1787 void* args[2] = {NULL, (void*)&painter};
1788 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1789 if (result) { Py_DECREF(result); }
1790 Py_DECREF(obj);
1791 return;
1792 }
1793 }
1794 QHexEdit::initPainter(painter);
1940 void* args[2] = {NULL, (void*)&painter0};
1941 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1942 if (result) { Py_DECREF(result); }
1943 Py_DECREF(obj);
1944 return;
1945 } else {
1946 PyErr_Clear();
1947 }
1948 }
1949 QHexEdit::initPainter(painter0);
1795 1950 }
1796 1951 void PythonQtShell_QHexEdit::inputMethodEvent(QInputMethodEvent* arg__1)
1797 1952 {
1798 if (_wrapper) {
1799 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
1800 PyErr_Clear();
1801 if (obj && !PythonQtSlotFunction_Check(obj)) {
1953 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1954 static PyObject* name = PyString_FromString("inputMethodEvent");
1955 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1956 if (obj) {
1802 1957 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
1803 1958 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1804 1959 void* args[2] = {NULL, (void*)&arg__1};
1805 1960 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1806 1961 if (result) { Py_DECREF(result); }
1807 1962 Py_DECREF(obj);
1808 1963 return;
1964 } else {
1965 PyErr_Clear();
1809 1966 }
1810 1967 }
1811 1968 QHexEdit::inputMethodEvent(arg__1);
1812 1969 }
1813 1970 QVariant PythonQtShell_QHexEdit::inputMethodQuery(Qt::InputMethodQuery arg__1) const
1814 1971 {
1815 if (_wrapper) {
1816 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
1817 PyErr_Clear();
1818 if (obj && !PythonQtSlotFunction_Check(obj)) {
1972 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1973 static PyObject* name = PyString_FromString("inputMethodQuery");
1974 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1975 if (obj) {
1819 1976 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
1820 1977 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1821 1978 QVariant returnValue;
1822 1979 void* args[2] = {NULL, (void*)&arg__1};
1823 1980 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1824 1981 if (result) {
1825 1982 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1826 1983 if (args[0]!=&returnValue) {
1827 1984 if (args[0]==NULL) {
1828 1985 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
1829 1986 } else {
1830 1987 returnValue = *((QVariant*)args[0]);
1831 1988 }
1832 1989 }
1833 1990 }
1834 1991 if (result) { Py_DECREF(result); }
1835 1992 Py_DECREF(obj);
1836 1993 return returnValue;
1994 } else {
1995 PyErr_Clear();
1837 1996 }
1838 1997 }
1839 1998 return QHexEdit::inputMethodQuery(arg__1);
1840 1999 }
1841 2000 void PythonQtShell_QHexEdit::keyPressEvent(QKeyEvent* arg__1)
1842 2001 {
1843 if (_wrapper) {
1844 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
1845 PyErr_Clear();
1846 if (obj && !PythonQtSlotFunction_Check(obj)) {
2002 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2003 static PyObject* name = PyString_FromString("keyPressEvent");
2004 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2005 if (obj) {
1847 2006 static const char* argumentList[] ={"" , "QKeyEvent*"};
1848 2007 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1849 2008 void* args[2] = {NULL, (void*)&arg__1};
1850 2009 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1851 2010 if (result) { Py_DECREF(result); }
1852 2011 Py_DECREF(obj);
1853 2012 return;
2013 } else {
2014 PyErr_Clear();
1854 2015 }
1855 2016 }
1856 2017 QHexEdit::keyPressEvent(arg__1);
1857 2018 }
1858 2019 void PythonQtShell_QHexEdit::keyReleaseEvent(QKeyEvent* arg__1)
1859 2020 {
1860 if (_wrapper) {
1861 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
1862 PyErr_Clear();
1863 if (obj && !PythonQtSlotFunction_Check(obj)) {
2021 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2022 static PyObject* name = PyString_FromString("keyReleaseEvent");
2023 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2024 if (obj) {
1864 2025 static const char* argumentList[] ={"" , "QKeyEvent*"};
1865 2026 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1866 2027 void* args[2] = {NULL, (void*)&arg__1};
1867 2028 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1868 2029 if (result) { Py_DECREF(result); }
1869 2030 Py_DECREF(obj);
1870 2031 return;
2032 } else {
2033 PyErr_Clear();
1871 2034 }
1872 2035 }
1873 2036 QHexEdit::keyReleaseEvent(arg__1);
1874 2037 }
1875 2038 void PythonQtShell_QHexEdit::leaveEvent(QEvent* arg__1)
1876 2039 {
1877 if (_wrapper) {
1878 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
1879 PyErr_Clear();
1880 if (obj && !PythonQtSlotFunction_Check(obj)) {
2040 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2041 static PyObject* name = PyString_FromString("leaveEvent");
2042 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2043 if (obj) {
1881 2044 static const char* argumentList[] ={"" , "QEvent*"};
1882 2045 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1883 2046 void* args[2] = {NULL, (void*)&arg__1};
1884 2047 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1885 2048 if (result) { Py_DECREF(result); }
1886 2049 Py_DECREF(obj);
1887 2050 return;
2051 } else {
2052 PyErr_Clear();
1888 2053 }
1889 2054 }
1890 2055 QHexEdit::leaveEvent(arg__1);
1891 2056 }
1892 2057 int PythonQtShell_QHexEdit::metric(QPaintDevice::PaintDeviceMetric arg__1) const
1893 2058 {
1894 if (_wrapper) {
1895 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
1896 PyErr_Clear();
1897 if (obj && !PythonQtSlotFunction_Check(obj)) {
2059 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2060 static PyObject* name = PyString_FromString("metric");
2061 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2062 if (obj) {
1898 2063 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
1899 2064 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1900 2065 int returnValue;
1901 2066 void* args[2] = {NULL, (void*)&arg__1};
1902 2067 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1903 2068 if (result) {
1904 2069 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1905 2070 if (args[0]!=&returnValue) {
1906 2071 if (args[0]==NULL) {
1907 2072 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
1908 2073 } else {
1909 2074 returnValue = *((int*)args[0]);
1910 2075 }
1911 2076 }
1912 2077 }
1913 2078 if (result) { Py_DECREF(result); }
1914 2079 Py_DECREF(obj);
1915 2080 return returnValue;
2081 } else {
2082 PyErr_Clear();
1916 2083 }
1917 2084 }
1918 2085 return QHexEdit::metric(arg__1);
1919 2086 }
1920 2087 void PythonQtShell_QHexEdit::mouseDoubleClickEvent(QMouseEvent* arg__1)
1921 2088 {
1922 if (_wrapper) {
1923 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
1924 PyErr_Clear();
1925 if (obj && !PythonQtSlotFunction_Check(obj)) {
2089 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2090 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
2091 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2092 if (obj) {
1926 2093 static const char* argumentList[] ={"" , "QMouseEvent*"};
1927 2094 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1928 2095 void* args[2] = {NULL, (void*)&arg__1};
1929 2096 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1930 2097 if (result) { Py_DECREF(result); }
1931 2098 Py_DECREF(obj);
1932 2099 return;
2100 } else {
2101 PyErr_Clear();
1933 2102 }
1934 2103 }
1935 2104 QHexEdit::mouseDoubleClickEvent(arg__1);
1936 2105 }
1937 2106 void PythonQtShell_QHexEdit::mouseMoveEvent(QMouseEvent* arg__1)
1938 2107 {
1939 if (_wrapper) {
1940 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
1941 PyErr_Clear();
1942 if (obj && !PythonQtSlotFunction_Check(obj)) {
2108 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2109 static PyObject* name = PyString_FromString("mouseMoveEvent");
2110 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2111 if (obj) {
1943 2112 static const char* argumentList[] ={"" , "QMouseEvent*"};
1944 2113 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1945 2114 void* args[2] = {NULL, (void*)&arg__1};
1946 2115 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1947 2116 if (result) { Py_DECREF(result); }
1948 2117 Py_DECREF(obj);
1949 2118 return;
2119 } else {
2120 PyErr_Clear();
1950 2121 }
1951 2122 }
1952 2123 QHexEdit::mouseMoveEvent(arg__1);
1953 2124 }
1954 2125 void PythonQtShell_QHexEdit::mousePressEvent(QMouseEvent* arg__1)
1955 2126 {
1956 if (_wrapper) {
1957 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
1958 PyErr_Clear();
1959 if (obj && !PythonQtSlotFunction_Check(obj)) {
2127 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2128 static PyObject* name = PyString_FromString("mousePressEvent");
2129 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2130 if (obj) {
1960 2131 static const char* argumentList[] ={"" , "QMouseEvent*"};
1961 2132 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1962 2133 void* args[2] = {NULL, (void*)&arg__1};
1963 2134 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1964 2135 if (result) { Py_DECREF(result); }
1965 2136 Py_DECREF(obj);
1966 2137 return;
2138 } else {
2139 PyErr_Clear();
1967 2140 }
1968 2141 }
1969 2142 QHexEdit::mousePressEvent(arg__1);
1970 2143 }
1971 2144 void PythonQtShell_QHexEdit::mouseReleaseEvent(QMouseEvent* arg__1)
1972 2145 {
1973 if (_wrapper) {
1974 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
1975 PyErr_Clear();
1976 if (obj && !PythonQtSlotFunction_Check(obj)) {
2146 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2147 static PyObject* name = PyString_FromString("mouseReleaseEvent");
2148 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2149 if (obj) {
1977 2150 static const char* argumentList[] ={"" , "QMouseEvent*"};
1978 2151 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1979 2152 void* args[2] = {NULL, (void*)&arg__1};
1980 2153 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1981 2154 if (result) { Py_DECREF(result); }
1982 2155 Py_DECREF(obj);
1983 2156 return;
2157 } else {
2158 PyErr_Clear();
1984 2159 }
1985 2160 }
1986 2161 QHexEdit::mouseReleaseEvent(arg__1);
1987 2162 }
1988 2163 void PythonQtShell_QHexEdit::moveEvent(QMoveEvent* arg__1)
1989 2164 {
1990 if (_wrapper) {
1991 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
1992 PyErr_Clear();
1993 if (obj && !PythonQtSlotFunction_Check(obj)) {
2165 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2166 static PyObject* name = PyString_FromString("moveEvent");
2167 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2168 if (obj) {
1994 2169 static const char* argumentList[] ={"" , "QMoveEvent*"};
1995 2170 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1996 2171 void* args[2] = {NULL, (void*)&arg__1};
1997 2172 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1998 2173 if (result) { Py_DECREF(result); }
1999 2174 Py_DECREF(obj);
2000 2175 return;
2176 } else {
2177 PyErr_Clear();
2001 2178 }
2002 2179 }
2003 2180 QHexEdit::moveEvent(arg__1);
2004 2181 }
2005 bool PythonQtShell_QHexEdit::nativeEvent(const QByteArray& eventType, void* message, long* result)
2006 {
2007 if (_wrapper) {
2008 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
2009 PyErr_Clear();
2010 if (obj && !PythonQtSlotFunction_Check(obj)) {
2182 bool PythonQtShell_QHexEdit::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
2183 {
2184 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2185 static PyObject* name = PyString_FromString("nativeEvent");
2186 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2187 if (obj) {
2011 2188 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
2012 2189 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
2013 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 2192 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2016 2193 if (result) {
2017 2194 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2018 2195 if (args[0]!=&returnValue) {
2019 2196 if (args[0]==NULL) {
2020 2197 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
2021 2198 } else {
2022 2199 returnValue = *((bool*)args[0]);
2023 2200 }
2024 2201 }
2025 2202 }
2026 2203 if (result) { Py_DECREF(result); }
2027 2204 Py_DECREF(obj);
2028 2205 return returnValue;
2029 }
2030 }
2031 return QHexEdit::nativeEvent(eventType, message, result);
2206 } else {
2207 PyErr_Clear();
2208 }
2209 }
2210 return QHexEdit::nativeEvent(eventType0, message1, result2);
2032 2211 }
2033 2212 QPaintEngine* PythonQtShell_QHexEdit::paintEngine() const
2034 2213 {
2035 if (_wrapper) {
2036 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
2037 PyErr_Clear();
2038 if (obj && !PythonQtSlotFunction_Check(obj)) {
2214 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2215 static PyObject* name = PyString_FromString("paintEngine");
2216 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2217 if (obj) {
2039 2218 static const char* argumentList[] ={"QPaintEngine*"};
2040 2219 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2041 2220 QPaintEngine* returnValue;
2042 2221 void* args[1] = {NULL};
2043 2222 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2044 2223 if (result) {
2045 2224 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2046 2225 if (args[0]!=&returnValue) {
2047 2226 if (args[0]==NULL) {
2048 2227 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
2049 2228 } else {
2050 2229 returnValue = *((QPaintEngine**)args[0]);
2051 2230 }
2052 2231 }
2053 2232 }
2054 2233 if (result) { Py_DECREF(result); }
2055 2234 Py_DECREF(obj);
2056 2235 return returnValue;
2236 } else {
2237 PyErr_Clear();
2057 2238 }
2058 2239 }
2059 2240 return QHexEdit::paintEngine();
2060 2241 }
2061 2242 void PythonQtShell_QHexEdit::paintEvent(QPaintEvent* arg__1)
2062 2243 {
2063 if (_wrapper) {
2064 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
2065 PyErr_Clear();
2066 if (obj && !PythonQtSlotFunction_Check(obj)) {
2244 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2245 static PyObject* name = PyString_FromString("paintEvent");
2246 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2247 if (obj) {
2067 2248 static const char* argumentList[] ={"" , "QPaintEvent*"};
2068 2249 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2069 2250 void* args[2] = {NULL, (void*)&arg__1};
2070 2251 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2071 2252 if (result) { Py_DECREF(result); }
2072 2253 Py_DECREF(obj);
2073 2254 return;
2255 } else {
2256 PyErr_Clear();
2074 2257 }
2075 2258 }
2076 2259 QHexEdit::paintEvent(arg__1);
2077 2260 }
2078 QPaintDevice* PythonQtShell_QHexEdit::redirected(QPoint* offset) const
2079 {
2080 if (_wrapper) {
2081 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
2082 PyErr_Clear();
2083 if (obj && !PythonQtSlotFunction_Check(obj)) {
2261 QPaintDevice* PythonQtShell_QHexEdit::redirected(QPoint* offset0) const
2262 {
2263 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2264 static PyObject* name = PyString_FromString("redirected");
2265 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2266 if (obj) {
2084 2267 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
2085 2268 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2086 2269 QPaintDevice* returnValue;
2087 void* args[2] = {NULL, (void*)&offset};
2270 void* args[2] = {NULL, (void*)&offset0};
2088 2271 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2089 2272 if (result) {
2090 2273 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2091 2274 if (args[0]!=&returnValue) {
2092 2275 if (args[0]==NULL) {
2093 2276 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
2094 2277 } else {
2095 2278 returnValue = *((QPaintDevice**)args[0]);
2096 2279 }
2097 2280 }
2098 2281 }
2099 2282 if (result) { Py_DECREF(result); }
2100 2283 Py_DECREF(obj);
2101 2284 return returnValue;
2102 }
2103 }
2104 return QHexEdit::redirected(offset);
2285 } else {
2286 PyErr_Clear();
2287 }
2288 }
2289 return QHexEdit::redirected(offset0);
2105 2290 }
2106 2291 void PythonQtShell_QHexEdit::resizeEvent(QResizeEvent* arg__1)
2107 2292 {
2108 if (_wrapper) {
2109 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
2110 PyErr_Clear();
2111 if (obj && !PythonQtSlotFunction_Check(obj)) {
2293 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2294 static PyObject* name = PyString_FromString("resizeEvent");
2295 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2296 if (obj) {
2112 2297 static const char* argumentList[] ={"" , "QResizeEvent*"};
2113 2298 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2114 2299 void* args[2] = {NULL, (void*)&arg__1};
2115 2300 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2116 2301 if (result) { Py_DECREF(result); }
2117 2302 Py_DECREF(obj);
2118 2303 return;
2304 } else {
2305 PyErr_Clear();
2119 2306 }
2120 2307 }
2121 2308 QHexEdit::resizeEvent(arg__1);
2122 2309 }
2123 void PythonQtShell_QHexEdit::scrollContentsBy(int dx, int dy)
2124 {
2125 if (_wrapper) {
2126 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "scrollContentsBy");
2127 PyErr_Clear();
2128 if (obj && !PythonQtSlotFunction_Check(obj)) {
2310 void PythonQtShell_QHexEdit::scrollContentsBy(int dx0, int dy1)
2311 {
2312 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2313 static PyObject* name = PyString_FromString("scrollContentsBy");
2314 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2315 if (obj) {
2129 2316 static const char* argumentList[] ={"" , "int" , "int"};
2130 2317 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2131 void* args[3] = {NULL, (void*)&dx, (void*)&dy};
2132 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2133 if (result) { Py_DECREF(result); }
2134 Py_DECREF(obj);
2135 return;
2136 }
2137 }
2138 QHexEdit::scrollContentsBy(dx, dy);
2139 }
2140 void PythonQtShell_QHexEdit::setupViewport(QWidget* viewport)
2141 {
2142 if (_wrapper) {
2143 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setupViewport");
2144 PyErr_Clear();
2145 if (obj && !PythonQtSlotFunction_Check(obj)) {
2318 void* args[3] = {NULL, (void*)&dx0, (void*)&dy1};
2319 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2320 if (result) { Py_DECREF(result); }
2321 Py_DECREF(obj);
2322 return;
2323 } else {
2324 PyErr_Clear();
2325 }
2326 }
2327 QHexEdit::scrollContentsBy(dx0, dy1);
2328 }
2329 void PythonQtShell_QHexEdit::setupViewport(QWidget* viewport0)
2330 {
2331 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2332 static PyObject* name = PyString_FromString("setupViewport");
2333 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2334 if (obj) {
2146 2335 static const char* argumentList[] ={"" , "QWidget*"};
2147 2336 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2148 void* args[2] = {NULL, (void*)&viewport};
2149 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2150 if (result) { Py_DECREF(result); }
2151 Py_DECREF(obj);
2152 return;
2153 }
2154 }
2155 QHexEdit::setupViewport(viewport);
2337 void* args[2] = {NULL, (void*)&viewport0};
2338 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2339 if (result) { Py_DECREF(result); }
2340 Py_DECREF(obj);
2341 return;
2342 } else {
2343 PyErr_Clear();
2344 }
2345 }
2346 QHexEdit::setupViewport(viewport0);
2156 2347 }
2157 2348 QPainter* PythonQtShell_QHexEdit::sharedPainter() const
2158 2349 {
2159 if (_wrapper) {
2160 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
2161 PyErr_Clear();
2162 if (obj && !PythonQtSlotFunction_Check(obj)) {
2350 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2351 static PyObject* name = PyString_FromString("sharedPainter");
2352 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2353 if (obj) {
2163 2354 static const char* argumentList[] ={"QPainter*"};
2164 2355 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2165 2356 QPainter* returnValue;
2166 2357 void* args[1] = {NULL};
2167 2358 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2168 2359 if (result) {
2169 2360 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2170 2361 if (args[0]!=&returnValue) {
2171 2362 if (args[0]==NULL) {
2172 2363 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
2173 2364 } else {
2174 2365 returnValue = *((QPainter**)args[0]);
2175 2366 }
2176 2367 }
2177 2368 }
2178 2369 if (result) { Py_DECREF(result); }
2179 2370 Py_DECREF(obj);
2180 2371 return returnValue;
2372 } else {
2373 PyErr_Clear();
2181 2374 }
2182 2375 }
2183 2376 return QHexEdit::sharedPainter();
2184 2377 }
2185 2378 void PythonQtShell_QHexEdit::showEvent(QShowEvent* arg__1)
2186 2379 {
2187 if (_wrapper) {
2188 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
2189 PyErr_Clear();
2190 if (obj && !PythonQtSlotFunction_Check(obj)) {
2380 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2381 static PyObject* name = PyString_FromString("showEvent");
2382 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2383 if (obj) {
2191 2384 static const char* argumentList[] ={"" , "QShowEvent*"};
2192 2385 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2193 2386 void* args[2] = {NULL, (void*)&arg__1};
2194 2387 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2195 2388 if (result) { Py_DECREF(result); }
2196 2389 Py_DECREF(obj);
2197 2390 return;
2391 } else {
2392 PyErr_Clear();
2198 2393 }
2199 2394 }
2200 2395 QHexEdit::showEvent(arg__1);
2201 2396 }
2202 2397 void PythonQtShell_QHexEdit::tabletEvent(QTabletEvent* arg__1)
2203 2398 {
2204 if (_wrapper) {
2205 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
2206 PyErr_Clear();
2207 if (obj && !PythonQtSlotFunction_Check(obj)) {
2399 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2400 static PyObject* name = PyString_FromString("tabletEvent");
2401 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2402 if (obj) {
2208 2403 static const char* argumentList[] ={"" , "QTabletEvent*"};
2209 2404 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2210 2405 void* args[2] = {NULL, (void*)&arg__1};
2211 2406 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2212 2407 if (result) { Py_DECREF(result); }
2213 2408 Py_DECREF(obj);
2214 2409 return;
2410 } else {
2411 PyErr_Clear();
2215 2412 }
2216 2413 }
2217 2414 QHexEdit::tabletEvent(arg__1);
2218 2415 }
2219 2416 void PythonQtShell_QHexEdit::timerEvent(QTimerEvent* arg__1)
2220 2417 {
2221 if (_wrapper) {
2222 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
2223 PyErr_Clear();
2224 if (obj && !PythonQtSlotFunction_Check(obj)) {
2418 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2419 static PyObject* name = PyString_FromString("timerEvent");
2420 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2421 if (obj) {
2225 2422 static const char* argumentList[] ={"" , "QTimerEvent*"};
2226 2423 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2227 2424 void* args[2] = {NULL, (void*)&arg__1};
2228 2425 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2229 2426 if (result) { Py_DECREF(result); }
2230 2427 Py_DECREF(obj);
2231 2428 return;
2429 } else {
2430 PyErr_Clear();
2232 2431 }
2233 2432 }
2234 2433 QHexEdit::timerEvent(arg__1);
2235 2434 }
2236 2435 bool PythonQtShell_QHexEdit::viewportEvent(QEvent* arg__1)
2237 2436 {
2238 if (_wrapper) {
2239 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportEvent");
2240 PyErr_Clear();
2241 if (obj && !PythonQtSlotFunction_Check(obj)) {
2437 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2438 static PyObject* name = PyString_FromString("viewportEvent");
2439 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2440 if (obj) {
2242 2441 static const char* argumentList[] ={"bool" , "QEvent*"};
2243 2442 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2244 2443 bool returnValue;
2245 2444 void* args[2] = {NULL, (void*)&arg__1};
2246 2445 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2247 2446 if (result) {
2248 2447 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2249 2448 if (args[0]!=&returnValue) {
2250 2449 if (args[0]==NULL) {
2251 2450 PythonQt::priv()->handleVirtualOverloadReturnError("viewportEvent", methodInfo, result);
2252 2451 } else {
2253 2452 returnValue = *((bool*)args[0]);
2254 2453 }
2255 2454 }
2256 2455 }
2257 2456 if (result) { Py_DECREF(result); }
2258 2457 Py_DECREF(obj);
2259 2458 return returnValue;
2459 } else {
2460 PyErr_Clear();
2260 2461 }
2261 2462 }
2262 2463 return QHexEdit::viewportEvent(arg__1);
2263 2464 }
2264 2465 QSize PythonQtShell_QHexEdit::viewportSizeHint() const
2265 2466 {
2266 if (_wrapper) {
2267 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportSizeHint");
2268 PyErr_Clear();
2269 if (obj && !PythonQtSlotFunction_Check(obj)) {
2467 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2468 static PyObject* name = PyString_FromString("viewportSizeHint");
2469 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2470 if (obj) {
2270 2471 static const char* argumentList[] ={"QSize"};
2271 2472 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2272 2473 QSize returnValue;
2273 2474 void* args[1] = {NULL};
2274 2475 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2275 2476 if (result) {
2276 2477 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2277 2478 if (args[0]!=&returnValue) {
2278 2479 if (args[0]==NULL) {
2279 2480 PythonQt::priv()->handleVirtualOverloadReturnError("viewportSizeHint", methodInfo, result);
2280 2481 } else {
2281 2482 returnValue = *((QSize*)args[0]);
2282 2483 }
2283 2484 }
2284 2485 }
2285 2486 if (result) { Py_DECREF(result); }
2286 2487 Py_DECREF(obj);
2287 2488 return returnValue;
2489 } else {
2490 PyErr_Clear();
2288 2491 }
2289 2492 }
2290 2493 return QHexEdit::viewportSizeHint();
2291 2494 }
2292 2495 void PythonQtShell_QHexEdit::wheelEvent(QWheelEvent* arg__1)
2293 2496 {
2294 if (_wrapper) {
2295 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
2296 PyErr_Clear();
2297 if (obj && !PythonQtSlotFunction_Check(obj)) {
2497 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2498 static PyObject* name = PyString_FromString("wheelEvent");
2499 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2500 if (obj) {
2298 2501 static const char* argumentList[] ={"" , "QWheelEvent*"};
2299 2502 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2300 2503 void* args[2] = {NULL, (void*)&arg__1};
2301 2504 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2302 2505 if (result) { Py_DECREF(result); }
2303 2506 Py_DECREF(obj);
2304 2507 return;
2508 } else {
2509 PyErr_Clear();
2305 2510 }
2306 2511 }
2307 2512 QHexEdit::wheelEvent(arg__1);
2308 2513 }
2309 2514 QHexEdit* PythonQtWrapper_QHexEdit::new_QHexEdit(QWidget* parent)
2310 2515 {
2311 2516 return new PythonQtShell_QHexEdit(parent); }
2312 2517
2313 2518 QColor PythonQtWrapper_QHexEdit::addressAreaColor(QHexEdit* theWrappedObject)
2314 2519 {
2315 2520 return ( theWrappedObject->addressAreaColor());
2316 2521 }
2317 2522
2318 2523 int PythonQtWrapper_QHexEdit::addressOffset(QHexEdit* theWrappedObject)
2319 2524 {
2320 2525 return ( theWrappedObject->addressOffset());
2321 2526 }
2322 2527
2323 2528 int PythonQtWrapper_QHexEdit::cursorPosition(QHexEdit* theWrappedObject)
2324 2529 {
2325 2530 return ( theWrappedObject->cursorPosition());
2326 2531 }
2327 2532
2328 2533 QByteArray PythonQtWrapper_QHexEdit::data(QHexEdit* theWrappedObject)
2329 2534 {
2330 2535 return ( theWrappedObject->data());
2331 2536 }
2332 2537
2333 2538 const QFont* PythonQtWrapper_QHexEdit::font(QHexEdit* theWrappedObject) const
2334 2539 {
2335 2540 return &( theWrappedObject->font());
2336 2541 }
2337 2542
2338 2543 int PythonQtWrapper_QHexEdit::getSelectionBegin(QHexEdit* theWrappedObject)
2339 2544 {
2340 2545 return ( theWrappedObject->getSelectionBegin());
2341 2546 }
2342 2547
2343 2548 int PythonQtWrapper_QHexEdit::getSelectionEnd(QHexEdit* theWrappedObject)
2344 2549 {
2345 2550 return ( theWrappedObject->getSelectionEnd());
2346 2551 }
2347 2552
2348 2553 QColor PythonQtWrapper_QHexEdit::highlightingColor(QHexEdit* theWrappedObject)
2349 2554 {
2350 2555 return ( theWrappedObject->highlightingColor());
2351 2556 }
2352 2557
2353 2558 int PythonQtWrapper_QHexEdit::indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2354 2559 {
2355 2560 return ( theWrappedObject->indexOf(ba, from));
2356 2561 }
2357 2562
2358 2563 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, char ch)
2359 2564 {
2360 2565 ( theWrappedObject->insert(i, ch));
2361 2566 }
2362 2567
2363 2568 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba)
2364 2569 {
2365 2570 ( theWrappedObject->insert(i, ba));
2366 2571 }
2367 2572
2368 2573 bool PythonQtWrapper_QHexEdit::isReadOnly(QHexEdit* theWrappedObject)
2369 2574 {
2370 2575 return ( theWrappedObject->isReadOnly());
2371 2576 }
2372 2577
2373 2578 int PythonQtWrapper_QHexEdit::lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2374 2579 {
2375 2580 return ( theWrappedObject->lastIndexOf(ba, from));
2376 2581 }
2377 2582
2378 2583 bool PythonQtWrapper_QHexEdit::overwriteMode(QHexEdit* theWrappedObject)
2379 2584 {
2380 2585 return ( theWrappedObject->overwriteMode());
2381 2586 }
2382 2587
2383 2588 void PythonQtWrapper_QHexEdit::remove(QHexEdit* theWrappedObject, int pos, int len)
2384 2589 {
2385 2590 ( theWrappedObject->remove(pos, len));
2386 2591 }
2387 2592
2388 2593 void PythonQtWrapper_QHexEdit::replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after)
2389 2594 {
2390 2595 ( theWrappedObject->replace(pos, len, after));
2391 2596 }
2392 2597
2393 2598 void PythonQtWrapper_QHexEdit::resetSelection(QHexEdit* theWrappedObject)
2394 2599 {
2395 2600 ( theWrappedObject->resetSelection());
2396 2601 }
2397 2602
2398 2603 void PythonQtWrapper_QHexEdit::resetSelection(QHexEdit* theWrappedObject, int pos)
2399 2604 {
2400 2605 ( theWrappedObject->resetSelection(pos));
2401 2606 }
2402 2607
2403 2608 QColor PythonQtWrapper_QHexEdit::selectionColor(QHexEdit* theWrappedObject)
2404 2609 {
2405 2610 return ( theWrappedObject->selectionColor());
2406 2611 }
2407 2612
2408 2613 QString PythonQtWrapper_QHexEdit::selectionToReadableString(QHexEdit* theWrappedObject)
2409 2614 {
2410 2615 return ( theWrappedObject->selectionToReadableString());
2411 2616 }
2412 2617
2413 2618 void PythonQtWrapper_QHexEdit::setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color)
2414 2619 {
2415 2620 ( theWrappedObject->setAddressAreaColor(color));
2416 2621 }
2417 2622
2418 2623 void PythonQtWrapper_QHexEdit::setAddressOffset(QHexEdit* theWrappedObject, int offset)
2419 2624 {
2420 2625 ( theWrappedObject->setAddressOffset(offset));
2421 2626 }
2422 2627
2423 2628 void PythonQtWrapper_QHexEdit::setCursorPosition(QHexEdit* theWrappedObject, int cusorPos)
2424 2629 {
2425 2630 ( theWrappedObject->setCursorPosition(cusorPos));
2426 2631 }
2427 2632
2428 2633 void PythonQtWrapper_QHexEdit::setData(QHexEdit* theWrappedObject, const QByteArray& data)
2429 2634 {
2430 2635 ( theWrappedObject->setData(data));
2431 2636 }
2432 2637
2433 2638 void PythonQtWrapper_QHexEdit::setFont(QHexEdit* theWrappedObject, const QFont& arg__1)
2434 2639 {
2435 2640 ( theWrappedObject->setFont(arg__1));
2436 2641 }
2437 2642
2438 2643 void PythonQtWrapper_QHexEdit::setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color)
2439 2644 {
2440 2645 ( theWrappedObject->setHighlightingColor(color));
2441 2646 }
2442 2647
2443 2648 void PythonQtWrapper_QHexEdit::setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1)
2444 2649 {
2445 2650 ( theWrappedObject->setOverwriteMode(arg__1));
2446 2651 }
2447 2652
2448 2653 void PythonQtWrapper_QHexEdit::setReadOnly(QHexEdit* theWrappedObject, bool arg__1)
2449 2654 {
2450 2655 ( theWrappedObject->setReadOnly(arg__1));
2451 2656 }
2452 2657
2453 2658 void PythonQtWrapper_QHexEdit::setSelection(QHexEdit* theWrappedObject, int pos)
2454 2659 {
2455 2660 ( theWrappedObject->setSelection(pos));
2456 2661 }
2457 2662
2458 2663 void PythonQtWrapper_QHexEdit::setSelectionColor(QHexEdit* theWrappedObject, const QColor& color)
2459 2664 {
2460 2665 ( theWrappedObject->setSelectionColor(color));
2461 2666 }
2462 2667
2463 2668 QString PythonQtWrapper_QHexEdit::toReadableString(QHexEdit* theWrappedObject)
2464 2669 {
2465 2670 return ( theWrappedObject->toReadableString());
2466 2671 }
2467 2672
2468 2673
2469 2674
2470 2675 PythonQtShell_QHexSpinBox::~PythonQtShell_QHexSpinBox() {
2471 2676 PythonQtPrivate* priv = PythonQt::priv();
2472 2677 if (priv) { priv->shellClassDeleted(this); }
2473 2678 }
2474 2679 void PythonQtShell_QHexSpinBox::actionEvent(QActionEvent* arg__1)
2475 2680 {
2476 if (_wrapper) {
2477 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
2478 PyErr_Clear();
2479 if (obj && !PythonQtSlotFunction_Check(obj)) {
2681 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2682 static PyObject* name = PyString_FromString("actionEvent");
2683 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2684 if (obj) {
2480 2685 static const char* argumentList[] ={"" , "QActionEvent*"};
2481 2686 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2482 2687 void* args[2] = {NULL, (void*)&arg__1};
2483 2688 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2484 2689 if (result) { Py_DECREF(result); }
2485 2690 Py_DECREF(obj);
2486 2691 return;
2692 } else {
2693 PyErr_Clear();
2487 2694 }
2488 2695 }
2489 2696 QHexSpinBox::actionEvent(arg__1);
2490 2697 }
2491 void PythonQtShell_QHexSpinBox::changeEvent(QEvent* event)
2492 {
2493 if (_wrapper) {
2494 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
2495 PyErr_Clear();
2496 if (obj && !PythonQtSlotFunction_Check(obj)) {
2698 void PythonQtShell_QHexSpinBox::changeEvent(QEvent* event0)
2699 {
2700 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2701 static PyObject* name = PyString_FromString("changeEvent");
2702 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2703 if (obj) {
2497 2704 static const char* argumentList[] ={"" , "QEvent*"};
2498 2705 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2499 void* args[2] = {NULL, (void*)&event};
2500 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2501 if (result) { Py_DECREF(result); }
2502 Py_DECREF(obj);
2503 return;
2504 }
2505 }
2506 QHexSpinBox::changeEvent(event);
2706 void* args[2] = {NULL, (void*)&event0};
2707 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2708 if (result) { Py_DECREF(result); }
2709 Py_DECREF(obj);
2710 return;
2711 } else {
2712 PyErr_Clear();
2713 }
2714 }
2715 QHexSpinBox::changeEvent(event0);
2507 2716 }
2508 2717 void PythonQtShell_QHexSpinBox::childEvent(QChildEvent* arg__1)
2509 2718 {
2510 if (_wrapper) {
2511 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
2512 PyErr_Clear();
2513 if (obj && !PythonQtSlotFunction_Check(obj)) {
2719 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2720 static PyObject* name = PyString_FromString("childEvent");
2721 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2722 if (obj) {
2514 2723 static const char* argumentList[] ={"" , "QChildEvent*"};
2515 2724 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2516 2725 void* args[2] = {NULL, (void*)&arg__1};
2517 2726 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2518 2727 if (result) { Py_DECREF(result); }
2519 2728 Py_DECREF(obj);
2520 2729 return;
2730 } else {
2731 PyErr_Clear();
2521 2732 }
2522 2733 }
2523 2734 QHexSpinBox::childEvent(arg__1);
2524 2735 }
2525 2736 void PythonQtShell_QHexSpinBox::clear()
2526 2737 {
2527 if (_wrapper) {
2528 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "clear");
2529 PyErr_Clear();
2530 if (obj && !PythonQtSlotFunction_Check(obj)) {
2738 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2739 static PyObject* name = PyString_FromString("clear");
2740 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2741 if (obj) {
2531 2742 static const char* argumentList[] ={""};
2532 2743 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2533 2744 void* args[1] = {NULL};
2534 2745 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2535 2746 if (result) { Py_DECREF(result); }
2536 2747 Py_DECREF(obj);
2537 2748 return;
2749 } else {
2750 PyErr_Clear();
2538 2751 }
2539 2752 }
2540 2753 QHexSpinBox::clear();
2541 2754 }
2542 void PythonQtShell_QHexSpinBox::closeEvent(QCloseEvent* event)
2543 {
2544 if (_wrapper) {
2545 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
2546 PyErr_Clear();
2547 if (obj && !PythonQtSlotFunction_Check(obj)) {
2755 void PythonQtShell_QHexSpinBox::closeEvent(QCloseEvent* event0)
2756 {
2757 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2758 static PyObject* name = PyString_FromString("closeEvent");
2759 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2760 if (obj) {
2548 2761 static const char* argumentList[] ={"" , "QCloseEvent*"};
2549 2762 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2550 void* args[2] = {NULL, (void*)&event};
2551 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2552 if (result) { Py_DECREF(result); }
2553 Py_DECREF(obj);
2554 return;
2555 }
2556 }
2557 QHexSpinBox::closeEvent(event);
2558 }
2559 void PythonQtShell_QHexSpinBox::contextMenuEvent(QContextMenuEvent* event)
2560 {
2561 if (_wrapper) {
2562 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
2563 PyErr_Clear();
2564 if (obj && !PythonQtSlotFunction_Check(obj)) {
2763 void* args[2] = {NULL, (void*)&event0};
2764 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2765 if (result) { Py_DECREF(result); }
2766 Py_DECREF(obj);
2767 return;
2768 } else {
2769 PyErr_Clear();
2770 }
2771 }
2772 QHexSpinBox::closeEvent(event0);
2773 }
2774 void PythonQtShell_QHexSpinBox::contextMenuEvent(QContextMenuEvent* event0)
2775 {
2776 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2777 static PyObject* name = PyString_FromString("contextMenuEvent");
2778 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2779 if (obj) {
2565 2780 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
2566 2781 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2567 void* args[2] = {NULL, (void*)&event};
2568 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2569 if (result) { Py_DECREF(result); }
2570 Py_DECREF(obj);
2571 return;
2572 }
2573 }
2574 QHexSpinBox::contextMenuEvent(event);
2782 void* args[2] = {NULL, (void*)&event0};
2783 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2784 if (result) { Py_DECREF(result); }
2785 Py_DECREF(obj);
2786 return;
2787 } else {
2788 PyErr_Clear();
2789 }
2790 }
2791 QHexSpinBox::contextMenuEvent(event0);
2575 2792 }
2576 2793 void PythonQtShell_QHexSpinBox::customEvent(QEvent* arg__1)
2577 2794 {
2578 if (_wrapper) {
2579 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
2580 PyErr_Clear();
2581 if (obj && !PythonQtSlotFunction_Check(obj)) {
2795 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2796 static PyObject* name = PyString_FromString("customEvent");
2797 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2798 if (obj) {
2582 2799 static const char* argumentList[] ={"" , "QEvent*"};
2583 2800 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2584 2801 void* args[2] = {NULL, (void*)&arg__1};
2585 2802 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2586 2803 if (result) { Py_DECREF(result); }
2587 2804 Py_DECREF(obj);
2588 2805 return;
2806 } else {
2807 PyErr_Clear();
2589 2808 }
2590 2809 }
2591 2810 QHexSpinBox::customEvent(arg__1);
2592 2811 }
2593 2812 int PythonQtShell_QHexSpinBox::devType() const
2594 2813 {
2595 if (_wrapper) {
2596 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
2597 PyErr_Clear();
2598 if (obj && !PythonQtSlotFunction_Check(obj)) {
2814 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2815 static PyObject* name = PyString_FromString("devType");
2816 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2817 if (obj) {
2599 2818 static const char* argumentList[] ={"int"};
2600 2819 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2601 2820 int returnValue;
2602 2821 void* args[1] = {NULL};
2603 2822 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2604 2823 if (result) {
2605 2824 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2606 2825 if (args[0]!=&returnValue) {
2607 2826 if (args[0]==NULL) {
2608 2827 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
2609 2828 } else {
2610 2829 returnValue = *((int*)args[0]);
2611 2830 }
2612 2831 }
2613 2832 }
2614 2833 if (result) { Py_DECREF(result); }
2615 2834 Py_DECREF(obj);
2616 2835 return returnValue;
2836 } else {
2837 PyErr_Clear();
2617 2838 }
2618 2839 }
2619 2840 return QHexSpinBox::devType();
2620 2841 }
2621 2842 void PythonQtShell_QHexSpinBox::dragEnterEvent(QDragEnterEvent* arg__1)
2622 2843 {
2623 if (_wrapper) {
2624 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
2625 PyErr_Clear();
2626 if (obj && !PythonQtSlotFunction_Check(obj)) {
2844 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2845 static PyObject* name = PyString_FromString("dragEnterEvent");
2846 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2847 if (obj) {
2627 2848 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
2628 2849 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2629 2850 void* args[2] = {NULL, (void*)&arg__1};
2630 2851 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2631 2852 if (result) { Py_DECREF(result); }
2632 2853 Py_DECREF(obj);
2633 2854 return;
2855 } else {
2856 PyErr_Clear();
2634 2857 }
2635 2858 }
2636 2859 QHexSpinBox::dragEnterEvent(arg__1);
2637 2860 }
2638 2861 void PythonQtShell_QHexSpinBox::dragLeaveEvent(QDragLeaveEvent* arg__1)
2639 2862 {
2640 if (_wrapper) {
2641 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
2642 PyErr_Clear();
2643 if (obj && !PythonQtSlotFunction_Check(obj)) {
2863 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2864 static PyObject* name = PyString_FromString("dragLeaveEvent");
2865 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2866 if (obj) {
2644 2867 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
2645 2868 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2646 2869 void* args[2] = {NULL, (void*)&arg__1};
2647 2870 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2648 2871 if (result) { Py_DECREF(result); }
2649 2872 Py_DECREF(obj);
2650 2873 return;
2874 } else {
2875 PyErr_Clear();
2651 2876 }
2652 2877 }
2653 2878 QHexSpinBox::dragLeaveEvent(arg__1);
2654 2879 }
2655 2880 void PythonQtShell_QHexSpinBox::dragMoveEvent(QDragMoveEvent* arg__1)
2656 2881 {
2657 if (_wrapper) {
2658 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
2659 PyErr_Clear();
2660 if (obj && !PythonQtSlotFunction_Check(obj)) {
2882 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2883 static PyObject* name = PyString_FromString("dragMoveEvent");
2884 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2885 if (obj) {
2661 2886 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
2662 2887 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2663 2888 void* args[2] = {NULL, (void*)&arg__1};
2664 2889 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2665 2890 if (result) { Py_DECREF(result); }
2666 2891 Py_DECREF(obj);
2667 2892 return;
2893 } else {
2894 PyErr_Clear();
2668 2895 }
2669 2896 }
2670 2897 QHexSpinBox::dragMoveEvent(arg__1);
2671 2898 }
2672 2899 void PythonQtShell_QHexSpinBox::dropEvent(QDropEvent* arg__1)
2673 2900 {
2674 if (_wrapper) {
2675 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
2676 PyErr_Clear();
2677 if (obj && !PythonQtSlotFunction_Check(obj)) {
2901 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2902 static PyObject* name = PyString_FromString("dropEvent");
2903 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2904 if (obj) {
2678 2905 static const char* argumentList[] ={"" , "QDropEvent*"};
2679 2906 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2680 2907 void* args[2] = {NULL, (void*)&arg__1};
2681 2908 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2682 2909 if (result) { Py_DECREF(result); }
2683 2910 Py_DECREF(obj);
2684 2911 return;
2912 } else {
2913 PyErr_Clear();
2685 2914 }
2686 2915 }
2687 2916 QHexSpinBox::dropEvent(arg__1);
2688 2917 }
2689 2918 void PythonQtShell_QHexSpinBox::enterEvent(QEvent* arg__1)
2690 2919 {
2691 if (_wrapper) {
2692 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
2693 PyErr_Clear();
2694 if (obj && !PythonQtSlotFunction_Check(obj)) {
2920 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2921 static PyObject* name = PyString_FromString("enterEvent");
2922 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2923 if (obj) {
2695 2924 static const char* argumentList[] ={"" , "QEvent*"};
2696 2925 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2697 2926 void* args[2] = {NULL, (void*)&arg__1};
2698 2927 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2699 2928 if (result) { Py_DECREF(result); }
2700 2929 Py_DECREF(obj);
2701 2930 return;
2931 } else {
2932 PyErr_Clear();
2702 2933 }
2703 2934 }
2704 2935 QHexSpinBox::enterEvent(arg__1);
2705 2936 }
2706 bool PythonQtShell_QHexSpinBox::event(QEvent* event)
2707 {
2708 if (_wrapper) {
2709 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
2710 PyErr_Clear();
2711 if (obj && !PythonQtSlotFunction_Check(obj)) {
2937 bool PythonQtShell_QHexSpinBox::event(QEvent* event0)
2938 {
2939 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2940 static PyObject* name = PyString_FromString("event");
2941 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2942 if (obj) {
2712 2943 static const char* argumentList[] ={"bool" , "QEvent*"};
2713 2944 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2714 2945 bool returnValue;
2715 void* args[2] = {NULL, (void*)&event};
2946 void* args[2] = {NULL, (void*)&event0};
2716 2947 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2717 2948 if (result) {
2718 2949 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2719 2950 if (args[0]!=&returnValue) {
2720 2951 if (args[0]==NULL) {
2721 2952 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
2722 2953 } else {
2723 2954 returnValue = *((bool*)args[0]);
2724 2955 }
2725 2956 }
2726 2957 }
2727 2958 if (result) { Py_DECREF(result); }
2728 2959 Py_DECREF(obj);
2729 2960 return returnValue;
2730 }
2731 }
2732 return QHexSpinBox::event(event);
2961 } else {
2962 PyErr_Clear();
2963 }
2964 }
2965 return QHexSpinBox::event(event0);
2733 2966 }
2734 2967 bool PythonQtShell_QHexSpinBox::eventFilter(QObject* arg__1, QEvent* arg__2)
2735 2968 {
2736 if (_wrapper) {
2737 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
2738 PyErr_Clear();
2739 if (obj && !PythonQtSlotFunction_Check(obj)) {
2969 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2970 static PyObject* name = PyString_FromString("eventFilter");
2971 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2972 if (obj) {
2740 2973 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
2741 2974 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2742 2975 bool returnValue;
2743 2976 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
2744 2977 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2745 2978 if (result) {
2746 2979 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2747 2980 if (args[0]!=&returnValue) {
2748 2981 if (args[0]==NULL) {
2749 2982 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
2750 2983 } else {
2751 2984 returnValue = *((bool*)args[0]);
2752 2985 }
2753 2986 }
2754 2987 }
2755 2988 if (result) { Py_DECREF(result); }
2756 2989 Py_DECREF(obj);
2757 2990 return returnValue;
2991 } else {
2992 PyErr_Clear();
2758 2993 }
2759 2994 }
2760 2995 return QHexSpinBox::eventFilter(arg__1, arg__2);
2761 2996 }
2762 void PythonQtShell_QHexSpinBox::fixup(QString& str) const
2763 {
2764 if (_wrapper) {
2765 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "fixup");
2766 PyErr_Clear();
2767 if (obj && !PythonQtSlotFunction_Check(obj)) {
2997 void PythonQtShell_QHexSpinBox::fixup(QString& str0) const
2998 {
2999 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3000 static PyObject* name = PyString_FromString("fixup");
3001 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3002 if (obj) {
2768 3003 static const char* argumentList[] ={"" , "QString&"};
2769 3004 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2770 void* args[2] = {NULL, (void*)&str};
2771 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2772 if (result) { Py_DECREF(result); }
2773 Py_DECREF(obj);
2774 return;
2775 }
2776 }
2777 QHexSpinBox::fixup(str);
2778 }
2779 void PythonQtShell_QHexSpinBox::focusInEvent(QFocusEvent* event)
2780 {
2781 if (_wrapper) {
2782 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
2783 PyErr_Clear();
2784 if (obj && !PythonQtSlotFunction_Check(obj)) {
3005 void* args[2] = {NULL, (void*)&str0};
3006 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3007 if (result) { Py_DECREF(result); }
3008 Py_DECREF(obj);
3009 return;
3010 } else {
3011 PyErr_Clear();
3012 }
3013 }
3014 QHexSpinBox::fixup(str0);
3015 }
3016 void PythonQtShell_QHexSpinBox::focusInEvent(QFocusEvent* event0)
3017 {
3018 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3019 static PyObject* name = PyString_FromString("focusInEvent");
3020 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3021 if (obj) {
2785 3022 static const char* argumentList[] ={"" , "QFocusEvent*"};
2786 3023 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2787 void* args[2] = {NULL, (void*)&event};
2788 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2789 if (result) { Py_DECREF(result); }
2790 Py_DECREF(obj);
2791 return;
2792 }
2793 }
2794 QHexSpinBox::focusInEvent(event);
2795 }
2796 bool PythonQtShell_QHexSpinBox::focusNextPrevChild(bool next)
2797 {
2798 if (_wrapper) {
2799 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
2800 PyErr_Clear();
2801 if (obj && !PythonQtSlotFunction_Check(obj)) {
3024 void* args[2] = {NULL, (void*)&event0};
3025 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3026 if (result) { Py_DECREF(result); }
3027 Py_DECREF(obj);
3028 return;
3029 } else {
3030 PyErr_Clear();
3031 }
3032 }
3033 QHexSpinBox::focusInEvent(event0);
3034 }
3035 bool PythonQtShell_QHexSpinBox::focusNextPrevChild(bool next0)
3036 {
3037 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3038 static PyObject* name = PyString_FromString("focusNextPrevChild");
3039 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3040 if (obj) {
2802 3041 static const char* argumentList[] ={"bool" , "bool"};
2803 3042 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2804 3043 bool returnValue;
2805 void* args[2] = {NULL, (void*)&next};
3044 void* args[2] = {NULL, (void*)&next0};
2806 3045 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2807 3046 if (result) {
2808 3047 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2809 3048 if (args[0]!=&returnValue) {
2810 3049 if (args[0]==NULL) {
2811 3050 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
2812 3051 } else {
2813 3052 returnValue = *((bool*)args[0]);
2814 3053 }
2815 3054 }
2816 3055 }
2817 3056 if (result) { Py_DECREF(result); }
2818 3057 Py_DECREF(obj);
2819 3058 return returnValue;
2820 }
2821 }
2822 return QHexSpinBox::focusNextPrevChild(next);
2823 }
2824 void PythonQtShell_QHexSpinBox::focusOutEvent(QFocusEvent* event)
2825 {
2826 if (_wrapper) {
2827 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
2828 PyErr_Clear();
2829 if (obj && !PythonQtSlotFunction_Check(obj)) {
3059 } else {
3060 PyErr_Clear();
3061 }
3062 }
3063 return QHexSpinBox::focusNextPrevChild(next0);
3064 }
3065 void PythonQtShell_QHexSpinBox::focusOutEvent(QFocusEvent* event0)
3066 {
3067 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3068 static PyObject* name = PyString_FromString("focusOutEvent");
3069 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3070 if (obj) {
2830 3071 static const char* argumentList[] ={"" , "QFocusEvent*"};
2831 3072 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2832 void* args[2] = {NULL, (void*)&event};
2833 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2834 if (result) { Py_DECREF(result); }
2835 Py_DECREF(obj);
2836 return;
2837 }
2838 }
2839 QHexSpinBox::focusOutEvent(event);
3073 void* args[2] = {NULL, (void*)&event0};
3074 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3075 if (result) { Py_DECREF(result); }
3076 Py_DECREF(obj);
3077 return;
3078 } else {
3079 PyErr_Clear();
3080 }
3081 }
3082 QHexSpinBox::focusOutEvent(event0);
2840 3083 }
2841 3084 bool PythonQtShell_QHexSpinBox::hasHeightForWidth() const
2842 3085 {
2843 if (_wrapper) {
2844 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
2845 PyErr_Clear();
2846 if (obj && !PythonQtSlotFunction_Check(obj)) {
3086 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3087 static PyObject* name = PyString_FromString("hasHeightForWidth");
3088 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3089 if (obj) {
2847 3090 static const char* argumentList[] ={"bool"};
2848 3091 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2849 3092 bool returnValue;
2850 3093 void* args[1] = {NULL};
2851 3094 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2852 3095 if (result) {
2853 3096 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2854 3097 if (args[0]!=&returnValue) {
2855 3098 if (args[0]==NULL) {
2856 3099 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
2857 3100 } else {
2858 3101 returnValue = *((bool*)args[0]);
2859 3102 }
2860 3103 }
2861 3104 }
2862 3105 if (result) { Py_DECREF(result); }
2863 3106 Py_DECREF(obj);
2864 3107 return returnValue;
3108 } else {
3109 PyErr_Clear();
2865 3110 }
2866 3111 }
2867 3112 return QHexSpinBox::hasHeightForWidth();
2868 3113 }
2869 3114 int PythonQtShell_QHexSpinBox::heightForWidth(int arg__1) const
2870 3115 {
2871 if (_wrapper) {
2872 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
2873 PyErr_Clear();
2874 if (obj && !PythonQtSlotFunction_Check(obj)) {
3116 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3117 static PyObject* name = PyString_FromString("heightForWidth");
3118 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3119 if (obj) {
2875 3120 static const char* argumentList[] ={"int" , "int"};
2876 3121 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2877 3122 int returnValue;
2878 3123 void* args[2] = {NULL, (void*)&arg__1};
2879 3124 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2880 3125 if (result) {
2881 3126 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2882 3127 if (args[0]!=&returnValue) {
2883 3128 if (args[0]==NULL) {
2884 3129 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
2885 3130 } else {
2886 3131 returnValue = *((int*)args[0]);
2887 3132 }
2888 3133 }
2889 3134 }
2890 3135 if (result) { Py_DECREF(result); }
2891 3136 Py_DECREF(obj);
2892 3137 return returnValue;
3138 } else {
3139 PyErr_Clear();
2893 3140 }
2894 3141 }
2895 3142 return QHexSpinBox::heightForWidth(arg__1);
2896 3143 }
2897 void PythonQtShell_QHexSpinBox::hideEvent(QHideEvent* event)
2898 {
2899 if (_wrapper) {
2900 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
2901 PyErr_Clear();
2902 if (obj && !PythonQtSlotFunction_Check(obj)) {
3144 void PythonQtShell_QHexSpinBox::hideEvent(QHideEvent* event0)
3145 {
3146 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3147 static PyObject* name = PyString_FromString("hideEvent");
3148 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3149 if (obj) {
2903 3150 static const char* argumentList[] ={"" , "QHideEvent*"};
2904 3151 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2905 void* args[2] = {NULL, (void*)&event};
2906 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2907 if (result) { Py_DECREF(result); }
2908 Py_DECREF(obj);
2909 return;
2910 }
2911 }
2912 QHexSpinBox::hideEvent(event);
2913 }
2914 void PythonQtShell_QHexSpinBox::initPainter(QPainter* painter) const
2915 {
2916 if (_wrapper) {
2917 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
2918 PyErr_Clear();
2919 if (obj && !PythonQtSlotFunction_Check(obj)) {
3152 void* args[2] = {NULL, (void*)&event0};
3153 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3154 if (result) { Py_DECREF(result); }
3155 Py_DECREF(obj);
3156 return;
3157 } else {
3158 PyErr_Clear();
3159 }
3160 }
3161 QHexSpinBox::hideEvent(event0);
3162 }
3163 void PythonQtShell_QHexSpinBox::initPainter(QPainter* painter0) const
3164 {
3165 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3166 static PyObject* name = PyString_FromString("initPainter");
3167 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3168 if (obj) {
2920 3169 static const char* argumentList[] ={"" , "QPainter*"};
2921 3170 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2922 void* args[2] = {NULL, (void*)&painter};
2923 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2924 if (result) { Py_DECREF(result); }
2925 Py_DECREF(obj);
2926 return;
2927 }
2928 }
2929 QHexSpinBox::initPainter(painter);
3171 void* args[2] = {NULL, (void*)&painter0};
3172 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3173 if (result) { Py_DECREF(result); }
3174 Py_DECREF(obj);
3175 return;
3176 } else {
3177 PyErr_Clear();
3178 }
3179 }
3180 QHexSpinBox::initPainter(painter0);
2930 3181 }
2931 3182 void PythonQtShell_QHexSpinBox::inputMethodEvent(QInputMethodEvent* arg__1)
2932 3183 {
2933 if (_wrapper) {
2934 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
2935 PyErr_Clear();
2936 if (obj && !PythonQtSlotFunction_Check(obj)) {
3184 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3185 static PyObject* name = PyString_FromString("inputMethodEvent");
3186 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3187 if (obj) {
2937 3188 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
2938 3189 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2939 3190 void* args[2] = {NULL, (void*)&arg__1};
2940 3191 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2941 3192 if (result) { Py_DECREF(result); }
2942 3193 Py_DECREF(obj);
2943 3194 return;
3195 } else {
3196 PyErr_Clear();
2944 3197 }
2945 3198 }
2946 3199 QHexSpinBox::inputMethodEvent(arg__1);
2947 3200 }
2948 3201 QVariant PythonQtShell_QHexSpinBox::inputMethodQuery(Qt::InputMethodQuery arg__1) const
2949 3202 {
2950 if (_wrapper) {
2951 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
2952 PyErr_Clear();
2953 if (obj && !PythonQtSlotFunction_Check(obj)) {
3203 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3204 static PyObject* name = PyString_FromString("inputMethodQuery");
3205 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3206 if (obj) {
2954 3207 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
2955 3208 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2956 3209 QVariant returnValue;
2957 3210 void* args[2] = {NULL, (void*)&arg__1};
2958 3211 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2959 3212 if (result) {
2960 3213 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2961 3214 if (args[0]!=&returnValue) {
2962 3215 if (args[0]==NULL) {
2963 3216 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
2964 3217 } else {
2965 3218 returnValue = *((QVariant*)args[0]);
2966 3219 }
2967 3220 }
2968 3221 }
2969 3222 if (result) { Py_DECREF(result); }
2970 3223 Py_DECREF(obj);
2971 3224 return returnValue;
3225 } else {
3226 PyErr_Clear();
2972 3227 }
2973 3228 }
2974 3229 return QHexSpinBox::inputMethodQuery(arg__1);
2975 3230 }
2976 void PythonQtShell_QHexSpinBox::keyPressEvent(QKeyEvent* event)
2977 {
2978 if (_wrapper) {
2979 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
2980 PyErr_Clear();
2981 if (obj && !PythonQtSlotFunction_Check(obj)) {
3231 void PythonQtShell_QHexSpinBox::keyPressEvent(QKeyEvent* event0)
3232 {
3233 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3234 static PyObject* name = PyString_FromString("keyPressEvent");
3235 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3236 if (obj) {
2982 3237 static const char* argumentList[] ={"" , "QKeyEvent*"};
2983 3238 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2984 void* args[2] = {NULL, (void*)&event};
2985 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2986 if (result) { Py_DECREF(result); }
2987 Py_DECREF(obj);
2988 return;
2989 }
2990 }
2991 QHexSpinBox::keyPressEvent(event);
2992 }
2993 void PythonQtShell_QHexSpinBox::keyReleaseEvent(QKeyEvent* event)
2994 {
2995 if (_wrapper) {
2996 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
2997 PyErr_Clear();
2998 if (obj && !PythonQtSlotFunction_Check(obj)) {
3239 void* args[2] = {NULL, (void*)&event0};
3240 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3241 if (result) { Py_DECREF(result); }
3242 Py_DECREF(obj);
3243 return;
3244 } else {
3245 PyErr_Clear();
3246 }
3247 }
3248 QHexSpinBox::keyPressEvent(event0);
3249 }
3250 void PythonQtShell_QHexSpinBox::keyReleaseEvent(QKeyEvent* event0)
3251 {
3252 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3253 static PyObject* name = PyString_FromString("keyReleaseEvent");
3254 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3255 if (obj) {
2999 3256 static const char* argumentList[] ={"" , "QKeyEvent*"};
3000 3257 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3001 void* args[2] = {NULL, (void*)&event};
3002 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3003 if (result) { Py_DECREF(result); }
3004 Py_DECREF(obj);
3005 return;
3006 }
3007 }
3008 QHexSpinBox::keyReleaseEvent(event);
3258 void* args[2] = {NULL, (void*)&event0};
3259 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3260 if (result) { Py_DECREF(result); }
3261 Py_DECREF(obj);
3262 return;
3263 } else {
3264 PyErr_Clear();
3265 }
3266 }
3267 QHexSpinBox::keyReleaseEvent(event0);
3009 3268 }
3010 3269 void PythonQtShell_QHexSpinBox::leaveEvent(QEvent* arg__1)
3011 3270 {
3012 if (_wrapper) {
3013 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
3014 PyErr_Clear();
3015 if (obj && !PythonQtSlotFunction_Check(obj)) {
3271 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3272 static PyObject* name = PyString_FromString("leaveEvent");
3273 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3274 if (obj) {
3016 3275 static const char* argumentList[] ={"" , "QEvent*"};
3017 3276 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3018 3277 void* args[2] = {NULL, (void*)&arg__1};
3019 3278 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3020 3279 if (result) { Py_DECREF(result); }
3021 3280 Py_DECREF(obj);
3022 3281 return;
3282 } else {
3283 PyErr_Clear();
3023 3284 }
3024 3285 }
3025 3286 QHexSpinBox::leaveEvent(arg__1);
3026 3287 }
3027 3288 int PythonQtShell_QHexSpinBox::metric(QPaintDevice::PaintDeviceMetric arg__1) const
3028 3289 {
3029 if (_wrapper) {
3030 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
3031 PyErr_Clear();
3032 if (obj && !PythonQtSlotFunction_Check(obj)) {
3290 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3291 static PyObject* name = PyString_FromString("metric");
3292 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3293 if (obj) {
3033 3294 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
3034 3295 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3035 3296 int returnValue;
3036 3297 void* args[2] = {NULL, (void*)&arg__1};
3037 3298 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3038 3299 if (result) {
3039 3300 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3040 3301 if (args[0]!=&returnValue) {
3041 3302 if (args[0]==NULL) {
3042 3303 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
3043 3304 } else {
3044 3305 returnValue = *((int*)args[0]);
3045 3306 }
3046 3307 }
3047 3308 }
3048 3309 if (result) { Py_DECREF(result); }
3049 3310 Py_DECREF(obj);
3050 3311 return returnValue;
3312 } else {
3313 PyErr_Clear();
3051 3314 }
3052 3315 }
3053 3316 return QHexSpinBox::metric(arg__1);
3054 3317 }
3055 3318 void PythonQtShell_QHexSpinBox::mouseDoubleClickEvent(QMouseEvent* arg__1)
3056 3319 {
3057 if (_wrapper) {
3058 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
3059 PyErr_Clear();
3060 if (obj && !PythonQtSlotFunction_Check(obj)) {
3320 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3321 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
3322 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3323 if (obj) {
3061 3324 static const char* argumentList[] ={"" , "QMouseEvent*"};
3062 3325 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3063 3326 void* args[2] = {NULL, (void*)&arg__1};
3064 3327 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3065 3328 if (result) { Py_DECREF(result); }
3066 3329 Py_DECREF(obj);
3067 3330 return;
3331 } else {
3332 PyErr_Clear();
3068 3333 }
3069 3334 }
3070 3335 QHexSpinBox::mouseDoubleClickEvent(arg__1);
3071 3336 }
3072 void PythonQtShell_QHexSpinBox::mouseMoveEvent(QMouseEvent* event)
3073 {
3074 if (_wrapper) {
3075 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
3076 PyErr_Clear();
3077 if (obj && !PythonQtSlotFunction_Check(obj)) {
3337 void PythonQtShell_QHexSpinBox::mouseMoveEvent(QMouseEvent* event0)
3338 {
3339 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3340 static PyObject* name = PyString_FromString("mouseMoveEvent");
3341 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3342 if (obj) {
3078 3343 static const char* argumentList[] ={"" , "QMouseEvent*"};
3079 3344 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3080 void* args[2] = {NULL, (void*)&event};
3081 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3082 if (result) { Py_DECREF(result); }
3083 Py_DECREF(obj);
3084 return;
3085 }
3086 }
3087 QHexSpinBox::mouseMoveEvent(event);
3088 }
3089 void PythonQtShell_QHexSpinBox::mousePressEvent(QMouseEvent* event)
3090 {
3091 if (_wrapper) {
3092 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
3093 PyErr_Clear();
3094 if (obj && !PythonQtSlotFunction_Check(obj)) {
3345 void* args[2] = {NULL, (void*)&event0};
3346 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3347 if (result) { Py_DECREF(result); }
3348 Py_DECREF(obj);
3349 return;
3350 } else {
3351 PyErr_Clear();
3352 }
3353 }
3354 QHexSpinBox::mouseMoveEvent(event0);
3355 }
3356 void PythonQtShell_QHexSpinBox::mousePressEvent(QMouseEvent* event0)
3357 {
3358 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3359 static PyObject* name = PyString_FromString("mousePressEvent");
3360 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3361 if (obj) {
3095 3362 static const char* argumentList[] ={"" , "QMouseEvent*"};
3096 3363 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3097 void* args[2] = {NULL, (void*)&event};
3098 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3099 if (result) { Py_DECREF(result); }
3100 Py_DECREF(obj);
3101 return;
3102 }
3103 }
3104 QHexSpinBox::mousePressEvent(event);
3105 }
3106 void PythonQtShell_QHexSpinBox::mouseReleaseEvent(QMouseEvent* event)
3107 {
3108 if (_wrapper) {
3109 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
3110 PyErr_Clear();
3111 if (obj && !PythonQtSlotFunction_Check(obj)) {
3364 void* args[2] = {NULL, (void*)&event0};
3365 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3366 if (result) { Py_DECREF(result); }
3367 Py_DECREF(obj);
3368 return;
3369 } else {
3370 PyErr_Clear();
3371 }
3372 }
3373 QHexSpinBox::mousePressEvent(event0);
3374 }
3375 void PythonQtShell_QHexSpinBox::mouseReleaseEvent(QMouseEvent* event0)
3376 {
3377 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3378 static PyObject* name = PyString_FromString("mouseReleaseEvent");
3379 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3380 if (obj) {
3112 3381 static const char* argumentList[] ={"" , "QMouseEvent*"};
3113 3382 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3114 void* args[2] = {NULL, (void*)&event};
3115 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3116 if (result) { Py_DECREF(result); }
3117 Py_DECREF(obj);
3118 return;
3119 }
3120 }
3121 QHexSpinBox::mouseReleaseEvent(event);
3383 void* args[2] = {NULL, (void*)&event0};
3384 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3385 if (result) { Py_DECREF(result); }
3386 Py_DECREF(obj);
3387 return;
3388 } else {
3389 PyErr_Clear();
3390 }
3391 }
3392 QHexSpinBox::mouseReleaseEvent(event0);
3122 3393 }
3123 3394 void PythonQtShell_QHexSpinBox::moveEvent(QMoveEvent* arg__1)
3124 3395 {
3125 if (_wrapper) {
3126 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
3127 PyErr_Clear();
3128 if (obj && !PythonQtSlotFunction_Check(obj)) {
3396 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3397 static PyObject* name = PyString_FromString("moveEvent");
3398 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3399 if (obj) {
3129 3400 static const char* argumentList[] ={"" , "QMoveEvent*"};
3130 3401 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3131 3402 void* args[2] = {NULL, (void*)&arg__1};
3132 3403 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3133 3404 if (result) { Py_DECREF(result); }
3134 3405 Py_DECREF(obj);
3135 3406 return;
3407 } else {
3408 PyErr_Clear();
3136 3409 }
3137 3410 }
3138 3411 QHexSpinBox::moveEvent(arg__1);
3139 3412 }
3140 bool PythonQtShell_QHexSpinBox::nativeEvent(const QByteArray& eventType, void* message, long* result)
3141 {
3142 if (_wrapper) {
3143 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
3144 PyErr_Clear();
3145 if (obj && !PythonQtSlotFunction_Check(obj)) {
3413 bool PythonQtShell_QHexSpinBox::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
3414 {
3415 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3416 static PyObject* name = PyString_FromString("nativeEvent");
3417 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3418 if (obj) {
3146 3419 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
3147 3420 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
3148 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 3423 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3151 3424 if (result) {
3152 3425 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3153 3426 if (args[0]!=&returnValue) {
3154 3427 if (args[0]==NULL) {
3155 3428 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
3156 3429 } else {
3157 3430 returnValue = *((bool*)args[0]);
3158 3431 }
3159 3432 }
3160 3433 }
3161 3434 if (result) { Py_DECREF(result); }
3162 3435 Py_DECREF(obj);
3163 3436 return returnValue;
3164 }
3165 }
3166 return QHexSpinBox::nativeEvent(eventType, message, result);
3437 } else {
3438 PyErr_Clear();
3439 }
3440 }
3441 return QHexSpinBox::nativeEvent(eventType0, message1, result2);
3167 3442 }
3168 3443 QPaintEngine* PythonQtShell_QHexSpinBox::paintEngine() const
3169 3444 {
3170 if (_wrapper) {
3171 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
3172 PyErr_Clear();
3173 if (obj && !PythonQtSlotFunction_Check(obj)) {
3445 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3446 static PyObject* name = PyString_FromString("paintEngine");
3447 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3448 if (obj) {
3174 3449 static const char* argumentList[] ={"QPaintEngine*"};
3175 3450 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3176 3451 QPaintEngine* returnValue;
3177 3452 void* args[1] = {NULL};
3178 3453 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3179 3454 if (result) {
3180 3455 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3181 3456 if (args[0]!=&returnValue) {
3182 3457 if (args[0]==NULL) {
3183 3458 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
3184 3459 } else {
3185 3460 returnValue = *((QPaintEngine**)args[0]);
3186 3461 }
3187 3462 }
3188 3463 }
3189 3464 if (result) { Py_DECREF(result); }
3190 3465 Py_DECREF(obj);
3191 3466 return returnValue;
3467 } else {
3468 PyErr_Clear();
3192 3469 }
3193 3470 }
3194 3471 return QHexSpinBox::paintEngine();
3195 3472 }
3196 void PythonQtShell_QHexSpinBox::paintEvent(QPaintEvent* event)
3197 {
3198 if (_wrapper) {
3199 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
3200 PyErr_Clear();
3201 if (obj && !PythonQtSlotFunction_Check(obj)) {
3473 void PythonQtShell_QHexSpinBox::paintEvent(QPaintEvent* event0)
3474 {
3475 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3476 static PyObject* name = PyString_FromString("paintEvent");
3477 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3478 if (obj) {
3202 3479 static const char* argumentList[] ={"" , "QPaintEvent*"};
3203 3480 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3204 void* args[2] = {NULL, (void*)&event};
3205 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3206 if (result) { Py_DECREF(result); }
3207 Py_DECREF(obj);
3208 return;
3209 }
3210 }
3211 QHexSpinBox::paintEvent(event);
3212 }
3213 QPaintDevice* PythonQtShell_QHexSpinBox::redirected(QPoint* offset) const
3214 {
3215 if (_wrapper) {
3216 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
3217 PyErr_Clear();
3218 if (obj && !PythonQtSlotFunction_Check(obj)) {
3481 void* args[2] = {NULL, (void*)&event0};
3482 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3483 if (result) { Py_DECREF(result); }
3484 Py_DECREF(obj);
3485 return;
3486 } else {
3487 PyErr_Clear();
3488 }
3489 }
3490 QHexSpinBox::paintEvent(event0);
3491 }
3492 QPaintDevice* PythonQtShell_QHexSpinBox::redirected(QPoint* offset0) const
3493 {
3494 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3495 static PyObject* name = PyString_FromString("redirected");
3496 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3497 if (obj) {
3219 3498 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
3220 3499 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3221 3500 QPaintDevice* returnValue;
3222 void* args[2] = {NULL, (void*)&offset};
3501 void* args[2] = {NULL, (void*)&offset0};
3223 3502 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3224 3503 if (result) {
3225 3504 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3226 3505 if (args[0]!=&returnValue) {
3227 3506 if (args[0]==NULL) {
3228 3507 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
3229 3508 } else {
3230 3509 returnValue = *((QPaintDevice**)args[0]);
3231 3510 }
3232 3511 }
3233 3512 }
3234 3513 if (result) { Py_DECREF(result); }
3235 3514 Py_DECREF(obj);
3236 3515 return returnValue;
3237 }
3238 }
3239 return QHexSpinBox::redirected(offset);
3240 }
3241 void PythonQtShell_QHexSpinBox::resizeEvent(QResizeEvent* event)
3242 {
3243 if (_wrapper) {
3244 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
3245 PyErr_Clear();
3246 if (obj && !PythonQtSlotFunction_Check(obj)) {
3516 } else {
3517 PyErr_Clear();
3518 }
3519 }
3520 return QHexSpinBox::redirected(offset0);
3521 }
3522 void PythonQtShell_QHexSpinBox::resizeEvent(QResizeEvent* event0)
3523 {
3524 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3525 static PyObject* name = PyString_FromString("resizeEvent");
3526 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3527 if (obj) {
3247 3528 static const char* argumentList[] ={"" , "QResizeEvent*"};
3248 3529 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3249 void* args[2] = {NULL, (void*)&event};
3250 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3251 if (result) { Py_DECREF(result); }
3252 Py_DECREF(obj);
3253 return;
3254 }
3255 }
3256 QHexSpinBox::resizeEvent(event);
3530 void* args[2] = {NULL, (void*)&event0};
3531 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3532 if (result) { Py_DECREF(result); }
3533 Py_DECREF(obj);
3534 return;
3535 } else {
3536 PyErr_Clear();
3537 }
3538 }
3539 QHexSpinBox::resizeEvent(event0);
3257 3540 }
3258 3541 QPainter* PythonQtShell_QHexSpinBox::sharedPainter() const
3259 3542 {
3260 if (_wrapper) {
3261 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
3262 PyErr_Clear();
3263 if (obj && !PythonQtSlotFunction_Check(obj)) {
3543 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3544 static PyObject* name = PyString_FromString("sharedPainter");
3545 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3546 if (obj) {
3264 3547 static const char* argumentList[] ={"QPainter*"};
3265 3548 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3266 3549 QPainter* returnValue;
3267 3550 void* args[1] = {NULL};
3268 3551 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3269 3552 if (result) {
3270 3553 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3271 3554 if (args[0]!=&returnValue) {
3272 3555 if (args[0]==NULL) {
3273 3556 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
3274 3557 } else {
3275 3558 returnValue = *((QPainter**)args[0]);
3276 3559 }
3277 3560 }
3278 3561 }
3279 3562 if (result) { Py_DECREF(result); }
3280 3563 Py_DECREF(obj);
3281 3564 return returnValue;
3565 } else {
3566 PyErr_Clear();
3282 3567 }
3283 3568 }
3284 3569 return QHexSpinBox::sharedPainter();
3285 3570 }
3286 void PythonQtShell_QHexSpinBox::showEvent(QShowEvent* event)
3287 {
3288 if (_wrapper) {
3289 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
3290 PyErr_Clear();
3291 if (obj && !PythonQtSlotFunction_Check(obj)) {
3571 void PythonQtShell_QHexSpinBox::showEvent(QShowEvent* event0)
3572 {
3573 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3574 static PyObject* name = PyString_FromString("showEvent");
3575 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3576 if (obj) {
3292 3577 static const char* argumentList[] ={"" , "QShowEvent*"};
3293 3578 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3294 void* args[2] = {NULL, (void*)&event};
3295 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3296 if (result) { Py_DECREF(result); }
3297 Py_DECREF(obj);
3298 return;
3299 }
3300 }
3301 QHexSpinBox::showEvent(event);
3302 }
3303 void PythonQtShell_QHexSpinBox::stepBy(int steps)
3304 {
3305 if (_wrapper) {
3306 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepBy");
3307 PyErr_Clear();
3308 if (obj && !PythonQtSlotFunction_Check(obj)) {
3579 void* args[2] = {NULL, (void*)&event0};
3580 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3581 if (result) { Py_DECREF(result); }
3582 Py_DECREF(obj);
3583 return;
3584 } else {
3585 PyErr_Clear();
3586 }
3587 }
3588 QHexSpinBox::showEvent(event0);
3589 }
3590 void PythonQtShell_QHexSpinBox::stepBy(int steps0)
3591 {
3592 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3593 static PyObject* name = PyString_FromString("stepBy");
3594 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3595 if (obj) {
3309 3596 static const char* argumentList[] ={"" , "int"};
3310 3597 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3311 void* args[2] = {NULL, (void*)&steps};
3312 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3313 if (result) { Py_DECREF(result); }
3314 Py_DECREF(obj);
3315 return;
3316 }
3317 }
3318 QHexSpinBox::stepBy(steps);
3598 void* args[2] = {NULL, (void*)&steps0};
3599 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3600 if (result) { Py_DECREF(result); }
3601 Py_DECREF(obj);
3602 return;
3603 } else {
3604 PyErr_Clear();
3605 }
3606 }
3607 QHexSpinBox::stepBy(steps0);
3319 3608 }
3320 3609 QAbstractSpinBox::StepEnabled PythonQtShell_QHexSpinBox::stepEnabled() const
3321 3610 {
3322 if (_wrapper) {
3323 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepEnabled");
3324 PyErr_Clear();
3325 if (obj && !PythonQtSlotFunction_Check(obj)) {
3611 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3612 static PyObject* name = PyString_FromString("stepEnabled");
3613 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3614 if (obj) {
3326 3615 static const char* argumentList[] ={"QAbstractSpinBox::StepEnabled"};
3327 3616 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3328 3617 QAbstractSpinBox::StepEnabled returnValue;
3329 3618 void* args[1] = {NULL};
3330 3619 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3331 3620 if (result) {
3332 3621 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3333 3622 if (args[0]!=&returnValue) {
3334 3623 if (args[0]==NULL) {
3335 3624 PythonQt::priv()->handleVirtualOverloadReturnError("stepEnabled", methodInfo, result);
3336 3625 } else {
3337 3626 returnValue = *((QAbstractSpinBox::StepEnabled*)args[0]);
3338 3627 }
3339 3628 }
3340 3629 }
3341 3630 if (result) { Py_DECREF(result); }
3342 3631 Py_DECREF(obj);
3343 3632 return returnValue;
3633 } else {
3634 PyErr_Clear();
3344 3635 }
3345 3636 }
3346 3637 return QHexSpinBox::stepEnabled();
3347 3638 }
3348 3639 void PythonQtShell_QHexSpinBox::tabletEvent(QTabletEvent* arg__1)
3349 3640 {
3350 if (_wrapper) {
3351 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
3352 PyErr_Clear();
3353 if (obj && !PythonQtSlotFunction_Check(obj)) {
3641 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3642 static PyObject* name = PyString_FromString("tabletEvent");
3643 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3644 if (obj) {
3354 3645 static const char* argumentList[] ={"" , "QTabletEvent*"};
3355 3646 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3356 3647 void* args[2] = {NULL, (void*)&arg__1};
3357 3648 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3358 3649 if (result) { Py_DECREF(result); }
3359 3650 Py_DECREF(obj);
3360 3651 return;
3652 } else {
3653 PyErr_Clear();
3361 3654 }
3362 3655 }
3363 3656 QHexSpinBox::tabletEvent(arg__1);
3364 3657 }
3365 QString PythonQtShell_QHexSpinBox::textFromValue(int value) const
3366 {
3367 if (_wrapper) {
3368 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "textFromValue");
3369 PyErr_Clear();
3370 if (obj && !PythonQtSlotFunction_Check(obj)) {
3658 QString PythonQtShell_QHexSpinBox::textFromValue(int value0) const
3659 {
3660 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3661 static PyObject* name = PyString_FromString("textFromValue");
3662 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3663 if (obj) {
3371 3664 static const char* argumentList[] ={"QString" , "int"};
3372 3665 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3373 3666 QString returnValue;
3374 void* args[2] = {NULL, (void*)&value};
3667 void* args[2] = {NULL, (void*)&value0};
3375 3668 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3376 3669 if (result) {
3377 3670 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3378 3671 if (args[0]!=&returnValue) {
3379 3672 if (args[0]==NULL) {
3380 3673 PythonQt::priv()->handleVirtualOverloadReturnError("textFromValue", methodInfo, result);
3381 3674 } else {
3382 3675 returnValue = *((QString*)args[0]);
3383 3676 }
3384 3677 }
3385 3678 }
3386 3679 if (result) { Py_DECREF(result); }
3387 3680 Py_DECREF(obj);
3388 3681 return returnValue;
3389 }
3390 }
3391 return QHexSpinBox::textFromValue(value);
3392 }
3393 void PythonQtShell_QHexSpinBox::timerEvent(QTimerEvent* event)
3394 {
3395 if (_wrapper) {
3396 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
3397 PyErr_Clear();
3398 if (obj && !PythonQtSlotFunction_Check(obj)) {
3682 } else {
3683 PyErr_Clear();
3684 }
3685 }
3686 return QHexSpinBox::textFromValue(value0);
3687 }
3688 void PythonQtShell_QHexSpinBox::timerEvent(QTimerEvent* event0)
3689 {
3690 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3691 static PyObject* name = PyString_FromString("timerEvent");
3692 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3693 if (obj) {
3399 3694 static const char* argumentList[] ={"" , "QTimerEvent*"};
3400 3695 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3401 void* args[2] = {NULL, (void*)&event};
3402 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3403 if (result) { Py_DECREF(result); }
3404 Py_DECREF(obj);
3405 return;
3406 }
3407 }
3408 QHexSpinBox::timerEvent(event);
3409 }
3410 QValidator::State PythonQtShell_QHexSpinBox::validate(QString& input, int& pos) const
3411 {
3412 if (_wrapper) {
3413 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "validate");
3414 PyErr_Clear();
3415 if (obj && !PythonQtSlotFunction_Check(obj)) {
3696 void* args[2] = {NULL, (void*)&event0};
3697 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3698 if (result) { Py_DECREF(result); }
3699 Py_DECREF(obj);
3700 return;
3701 } else {
3702 PyErr_Clear();
3703 }
3704 }
3705 QHexSpinBox::timerEvent(event0);
3706 }
3707 QValidator::State PythonQtShell_QHexSpinBox::validate(QString& input0, int& pos1) const
3708 {
3709 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3710 static PyObject* name = PyString_FromString("validate");
3711 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3712 if (obj) {
3416 3713 static const char* argumentList[] ={"QValidator::State" , "QString&" , "int&"};
3417 3714 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3418 3715 QValidator::State returnValue;
3419 void* args[3] = {NULL, (void*)&input, (void*)&pos};
3716 void* args[3] = {NULL, (void*)&input0, (void*)&pos1};
3420 3717 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3421 3718 if (result) {
3422 3719 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3423 3720 if (args[0]!=&returnValue) {
3424 3721 if (args[0]==NULL) {
3425 3722 PythonQt::priv()->handleVirtualOverloadReturnError("validate", methodInfo, result);
3426 3723 } else {
3427 3724 returnValue = *((QValidator::State*)args[0]);
3428 3725 }
3429 3726 }
3430 3727 }
3431 3728 if (result) { Py_DECREF(result); }
3432 3729 Py_DECREF(obj);
3433 3730 return returnValue;
3434 }
3435 }
3436 return QHexSpinBox::validate(input, pos);
3437 }
3438 int PythonQtShell_QHexSpinBox::valueFromText(const QString& text) const
3439 {
3440 if (_wrapper) {
3441 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "valueFromText");
3442 PyErr_Clear();
3443 if (obj && !PythonQtSlotFunction_Check(obj)) {
3731 } else {
3732 PyErr_Clear();
3733 }
3734 }
3735 return QHexSpinBox::validate(input0, pos1);
3736 }
3737 int PythonQtShell_QHexSpinBox::valueFromText(const QString& text0) const
3738 {
3739 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3740 static PyObject* name = PyString_FromString("valueFromText");
3741 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3742 if (obj) {
3444 3743 static const char* argumentList[] ={"int" , "const QString&"};
3445 3744 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3446 3745 int returnValue;
3447 void* args[2] = {NULL, (void*)&text};
3746 void* args[2] = {NULL, (void*)&text0};
3448 3747 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3449 3748 if (result) {
3450 3749 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3451 3750 if (args[0]!=&returnValue) {
3452 3751 if (args[0]==NULL) {
3453 3752 PythonQt::priv()->handleVirtualOverloadReturnError("valueFromText", methodInfo, result);
3454 3753 } else {
3455 3754 returnValue = *((int*)args[0]);
3456 3755 }
3457 3756 }
3458 3757 }
3459 3758 if (result) { Py_DECREF(result); }
3460 3759 Py_DECREF(obj);
3461 3760 return returnValue;
3462 }
3463 }
3464 return QHexSpinBox::valueFromText(text);
3465 }
3466 void PythonQtShell_QHexSpinBox::wheelEvent(QWheelEvent* event)
3467 {
3468 if (_wrapper) {
3469 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
3470 PyErr_Clear();
3471 if (obj && !PythonQtSlotFunction_Check(obj)) {
3761 } else {
3762 PyErr_Clear();
3763 }
3764 }
3765 return QHexSpinBox::valueFromText(text0);
3766 }
3767 void PythonQtShell_QHexSpinBox::wheelEvent(QWheelEvent* event0)
3768 {
3769 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3770 static PyObject* name = PyString_FromString("wheelEvent");
3771 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3772 if (obj) {
3472 3773 static const char* argumentList[] ={"" , "QWheelEvent*"};
3473 3774 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3474 void* args[2] = {NULL, (void*)&event};
3475 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3476 if (result) { Py_DECREF(result); }
3477 Py_DECREF(obj);
3478 return;
3479 }
3480 }
3481 QHexSpinBox::wheelEvent(event);
3775 void* args[2] = {NULL, (void*)&event0};
3776 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3777 if (result) { Py_DECREF(result); }
3778 Py_DECREF(obj);
3779 return;
3780 } else {
3781 PyErr_Clear();
3782 }
3783 }
3784 QHexSpinBox::wheelEvent(event0);
3482 3785 }
3483 3786 QHexSpinBox* PythonQtWrapper_QHexSpinBox::new_QHexSpinBox(QWidget* parent)
3484 3787 {
3485 3788 return new PythonQtShell_QHexSpinBox(parent); }
3486 3789
3487 3790 void PythonQtWrapper_QHexSpinBox::show(QHexSpinBox* theWrappedObject)
3488 3791 {
3489 3792 ( theWrappedObject->show());
3490 3793 }
3491 3794
3492 3795 QString PythonQtWrapper_QHexSpinBox::textFromValue(QHexSpinBox* theWrappedObject, int value) const
3493 3796 {
3494 3797 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_textFromValue(value));
3495 3798 }
3496 3799
3497 3800 QValidator::State PythonQtWrapper_QHexSpinBox::validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const
3498 3801 {
3499 3802 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_validate(input, pos));
3500 3803 }
3501 3804
3502 3805 int PythonQtWrapper_QHexSpinBox::valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const
3503 3806 {
3504 3807 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_valueFromText(text));
3505 3808 }
3506 3809
3507 3810
3508 3811
3509 3812 PythonQtShell_SocExplorerPlot::~PythonQtShell_SocExplorerPlot() {
3510 3813 PythonQtPrivate* priv = PythonQt::priv();
3511 3814 if (priv) { priv->shellClassDeleted(this); }
3512 3815 }
3513 3816 void PythonQtShell_SocExplorerPlot::actionEvent(QActionEvent* arg__1)
3514 3817 {
3515 if (_wrapper) {
3516 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
3517 PyErr_Clear();
3518 if (obj && !PythonQtSlotFunction_Check(obj)) {
3818 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3819 static PyObject* name = PyString_FromString("actionEvent");
3820 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3821 if (obj) {
3519 3822 static const char* argumentList[] ={"" , "QActionEvent*"};
3520 3823 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3521 3824 void* args[2] = {NULL, (void*)&arg__1};
3522 3825 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3523 3826 if (result) { Py_DECREF(result); }
3524 3827 Py_DECREF(obj);
3525 3828 return;
3829 } else {
3830 PyErr_Clear();
3526 3831 }
3527 3832 }
3528 3833 SocExplorerPlot::actionEvent(arg__1);
3529 3834 }
3530 3835 void PythonQtShell_SocExplorerPlot::changeEvent(QEvent* arg__1)
3531 3836 {
3532 if (_wrapper) {
3533 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
3534 PyErr_Clear();
3535 if (obj && !PythonQtSlotFunction_Check(obj)) {
3837 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3838 static PyObject* name = PyString_FromString("changeEvent");
3839 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3840 if (obj) {
3536 3841 static const char* argumentList[] ={"" , "QEvent*"};
3537 3842 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3538 3843 void* args[2] = {NULL, (void*)&arg__1};
3539 3844 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3540 3845 if (result) { Py_DECREF(result); }
3541 3846 Py_DECREF(obj);
3542 3847 return;
3848 } else {
3849 PyErr_Clear();
3543 3850 }
3544 3851 }
3545 3852 SocExplorerPlot::changeEvent(arg__1);
3546 3853 }
3547 3854 void PythonQtShell_SocExplorerPlot::childEvent(QChildEvent* arg__1)
3548 3855 {
3549 if (_wrapper) {
3550 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
3551 PyErr_Clear();
3552 if (obj && !PythonQtSlotFunction_Check(obj)) {
3856 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3857 static PyObject* name = PyString_FromString("childEvent");
3858 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3859 if (obj) {
3553 3860 static const char* argumentList[] ={"" , "QChildEvent*"};
3554 3861 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3555 3862 void* args[2] = {NULL, (void*)&arg__1};
3556 3863 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3557 3864 if (result) { Py_DECREF(result); }
3558 3865 Py_DECREF(obj);
3559 3866 return;
3867 } else {
3868 PyErr_Clear();
3560 3869 }
3561 3870 }
3562 3871 SocExplorerPlot::childEvent(arg__1);
3563 3872 }
3564 3873 void PythonQtShell_SocExplorerPlot::closeEvent(QCloseEvent* arg__1)
3565 3874 {
3566 if (_wrapper) {
3567 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
3568 PyErr_Clear();
3569 if (obj && !PythonQtSlotFunction_Check(obj)) {
3875 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3876 static PyObject* name = PyString_FromString("closeEvent");
3877 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3878 if (obj) {
3570 3879 static const char* argumentList[] ={"" , "QCloseEvent*"};
3571 3880 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3572 3881 void* args[2] = {NULL, (void*)&arg__1};
3573 3882 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3574 3883 if (result) { Py_DECREF(result); }
3575 3884 Py_DECREF(obj);
3576 3885 return;
3886 } else {
3887 PyErr_Clear();
3577 3888 }
3578 3889 }
3579 3890 SocExplorerPlot::closeEvent(arg__1);
3580 3891 }
3581 3892 void PythonQtShell_SocExplorerPlot::contextMenuEvent(QContextMenuEvent* arg__1)
3582 3893 {
3583 if (_wrapper) {
3584 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
3585 PyErr_Clear();
3586 if (obj && !PythonQtSlotFunction_Check(obj)) {
3894 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3895 static PyObject* name = PyString_FromString("contextMenuEvent");
3896 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3897 if (obj) {
3587 3898 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
3588 3899 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3589 3900 void* args[2] = {NULL, (void*)&arg__1};
3590 3901 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3591 3902 if (result) { Py_DECREF(result); }
3592 3903 Py_DECREF(obj);
3593 3904 return;
3905 } else {
3906 PyErr_Clear();
3594 3907 }
3595 3908 }
3596 3909 SocExplorerPlot::contextMenuEvent(arg__1);
3597 3910 }
3598 3911 void PythonQtShell_SocExplorerPlot::customEvent(QEvent* arg__1)
3599 3912 {
3600 if (_wrapper) {
3601 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
3602 PyErr_Clear();
3603 if (obj && !PythonQtSlotFunction_Check(obj)) {
3913 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3914 static PyObject* name = PyString_FromString("customEvent");
3915 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3916 if (obj) {
3604 3917 static const char* argumentList[] ={"" , "QEvent*"};
3605 3918 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3606 3919 void* args[2] = {NULL, (void*)&arg__1};
3607 3920 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3608 3921 if (result) { Py_DECREF(result); }
3609 3922 Py_DECREF(obj);
3610 3923 return;
3924 } else {
3925 PyErr_Clear();
3611 3926 }
3612 3927 }
3613 3928 SocExplorerPlot::customEvent(arg__1);
3614 3929 }
3615 3930 int PythonQtShell_SocExplorerPlot::devType() const
3616 3931 {
3617 if (_wrapper) {
3618 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
3619 PyErr_Clear();
3620 if (obj && !PythonQtSlotFunction_Check(obj)) {
3932 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3933 static PyObject* name = PyString_FromString("devType");
3934 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3935 if (obj) {
3621 3936 static const char* argumentList[] ={"int"};
3622 3937 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3623 3938 int returnValue;
3624 3939 void* args[1] = {NULL};
3625 3940 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3626 3941 if (result) {
3627 3942 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3628 3943 if (args[0]!=&returnValue) {
3629 3944 if (args[0]==NULL) {
3630 3945 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
3631 3946 } else {
3632 3947 returnValue = *((int*)args[0]);
3633 3948 }
3634 3949 }
3635 3950 }
3636 3951 if (result) { Py_DECREF(result); }
3637 3952 Py_DECREF(obj);
3638 3953 return returnValue;
3954 } else {
3955 PyErr_Clear();
3639 3956 }
3640 3957 }
3641 3958 return SocExplorerPlot::devType();
3642 3959 }
3643 3960 void PythonQtShell_SocExplorerPlot::dragEnterEvent(QDragEnterEvent* arg__1)
3644 3961 {
3645 if (_wrapper) {
3646 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
3647 PyErr_Clear();
3648 if (obj && !PythonQtSlotFunction_Check(obj)) {
3962 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3963 static PyObject* name = PyString_FromString("dragEnterEvent");
3964 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3965 if (obj) {
3649 3966 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
3650 3967 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3651 3968 void* args[2] = {NULL, (void*)&arg__1};
3652 3969 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3653 3970 if (result) { Py_DECREF(result); }
3654 3971 Py_DECREF(obj);
3655 3972 return;
3973 } else {
3974 PyErr_Clear();
3656 3975 }
3657 3976 }
3658 3977 SocExplorerPlot::dragEnterEvent(arg__1);
3659 3978 }
3660 3979 void PythonQtShell_SocExplorerPlot::dragLeaveEvent(QDragLeaveEvent* arg__1)
3661 3980 {
3662 if (_wrapper) {
3663 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
3664 PyErr_Clear();
3665 if (obj && !PythonQtSlotFunction_Check(obj)) {
3981 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3982 static PyObject* name = PyString_FromString("dragLeaveEvent");
3983 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3984 if (obj) {
3666 3985 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
3667 3986 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3668 3987 void* args[2] = {NULL, (void*)&arg__1};
3669 3988 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3670 3989 if (result) { Py_DECREF(result); }
3671 3990 Py_DECREF(obj);
3672 3991 return;
3992 } else {
3993 PyErr_Clear();
3673 3994 }
3674 3995 }
3675 3996 SocExplorerPlot::dragLeaveEvent(arg__1);
3676 3997 }
3677 3998 void PythonQtShell_SocExplorerPlot::dragMoveEvent(QDragMoveEvent* arg__1)
3678 3999 {
3679 if (_wrapper) {
3680 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
3681 PyErr_Clear();
3682 if (obj && !PythonQtSlotFunction_Check(obj)) {
4000 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4001 static PyObject* name = PyString_FromString("dragMoveEvent");
4002 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4003 if (obj) {
3683 4004 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
3684 4005 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3685 4006 void* args[2] = {NULL, (void*)&arg__1};
3686 4007 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3687 4008 if (result) { Py_DECREF(result); }
3688 4009 Py_DECREF(obj);
3689 4010 return;
4011 } else {
4012 PyErr_Clear();
3690 4013 }
3691 4014 }
3692 4015 SocExplorerPlot::dragMoveEvent(arg__1);
3693 4016 }
3694 4017 void PythonQtShell_SocExplorerPlot::dropEvent(QDropEvent* arg__1)
3695 4018 {
3696 if (_wrapper) {
3697 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
3698 PyErr_Clear();
3699 if (obj && !PythonQtSlotFunction_Check(obj)) {
4019 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4020 static PyObject* name = PyString_FromString("dropEvent");
4021 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4022 if (obj) {
3700 4023 static const char* argumentList[] ={"" , "QDropEvent*"};
3701 4024 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3702 4025 void* args[2] = {NULL, (void*)&arg__1};
3703 4026 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3704 4027 if (result) { Py_DECREF(result); }
3705 4028 Py_DECREF(obj);
3706 4029 return;
4030 } else {
4031 PyErr_Clear();
3707 4032 }
3708 4033 }
3709 4034 SocExplorerPlot::dropEvent(arg__1);
3710 4035 }
3711 4036 void PythonQtShell_SocExplorerPlot::enterEvent(QEvent* arg__1)
3712 4037 {
3713 if (_wrapper) {
3714 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
3715 PyErr_Clear();
3716 if (obj && !PythonQtSlotFunction_Check(obj)) {
4038 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4039 static PyObject* name = PyString_FromString("enterEvent");
4040 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4041 if (obj) {
3717 4042 static const char* argumentList[] ={"" , "QEvent*"};
3718 4043 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3719 4044 void* args[2] = {NULL, (void*)&arg__1};
3720 4045 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3721 4046 if (result) { Py_DECREF(result); }
3722 4047 Py_DECREF(obj);
3723 4048 return;
4049 } else {
4050 PyErr_Clear();
3724 4051 }
3725 4052 }
3726 4053 SocExplorerPlot::enterEvent(arg__1);
3727 4054 }
3728 4055 bool PythonQtShell_SocExplorerPlot::event(QEvent* arg__1)
3729 4056 {
3730 if (_wrapper) {
3731 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
3732 PyErr_Clear();
3733 if (obj && !PythonQtSlotFunction_Check(obj)) {
4057 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4058 static PyObject* name = PyString_FromString("event");
4059 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4060 if (obj) {
3734 4061 static const char* argumentList[] ={"bool" , "QEvent*"};
3735 4062 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3736 4063 bool returnValue;
3737 4064 void* args[2] = {NULL, (void*)&arg__1};
3738 4065 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3739 4066 if (result) {
3740 4067 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3741 4068 if (args[0]!=&returnValue) {
3742 4069 if (args[0]==NULL) {
3743 4070 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
3744 4071 } else {
3745 4072 returnValue = *((bool*)args[0]);
3746 4073 }
3747 4074 }
3748 4075 }
3749 4076 if (result) { Py_DECREF(result); }
3750 4077 Py_DECREF(obj);
3751 4078 return returnValue;
4079 } else {
4080 PyErr_Clear();
3752 4081 }
3753 4082 }
3754 4083 return SocExplorerPlot::event(arg__1);
3755 4084 }
3756 4085 bool PythonQtShell_SocExplorerPlot::eventFilter(QObject* arg__1, QEvent* arg__2)
3757 4086 {
3758 if (_wrapper) {
3759 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
3760 PyErr_Clear();
3761 if (obj && !PythonQtSlotFunction_Check(obj)) {
4087 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4088 static PyObject* name = PyString_FromString("eventFilter");
4089 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4090 if (obj) {
3762 4091 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
3763 4092 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3764 4093 bool returnValue;
3765 4094 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
3766 4095 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3767 4096 if (result) {
3768 4097 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3769 4098 if (args[0]!=&returnValue) {
3770 4099 if (args[0]==NULL) {
3771 4100 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
3772 4101 } else {
3773 4102 returnValue = *((bool*)args[0]);
3774 4103 }
3775 4104 }
3776 4105 }
3777 4106 if (result) { Py_DECREF(result); }
3778 4107 Py_DECREF(obj);
3779 4108 return returnValue;
4109 } else {
4110 PyErr_Clear();
3780 4111 }
3781 4112 }
3782 4113 return SocExplorerPlot::eventFilter(arg__1, arg__2);
3783 4114 }
3784 4115 void PythonQtShell_SocExplorerPlot::focusInEvent(QFocusEvent* arg__1)
3785 4116 {
3786 if (_wrapper) {
3787 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
3788 PyErr_Clear();
3789 if (obj && !PythonQtSlotFunction_Check(obj)) {
4117 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4118 static PyObject* name = PyString_FromString("focusInEvent");
4119 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4120 if (obj) {
3790 4121 static const char* argumentList[] ={"" , "QFocusEvent*"};
3791 4122 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3792 4123 void* args[2] = {NULL, (void*)&arg__1};
3793 4124 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3794 4125 if (result) { Py_DECREF(result); }
3795 4126 Py_DECREF(obj);
3796 4127 return;
4128 } else {
4129 PyErr_Clear();
3797 4130 }
3798 4131 }
3799 4132 SocExplorerPlot::focusInEvent(arg__1);
3800 4133 }
3801 bool PythonQtShell_SocExplorerPlot::focusNextPrevChild(bool next)
3802 {
3803 if (_wrapper) {
3804 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
3805 PyErr_Clear();
3806 if (obj && !PythonQtSlotFunction_Check(obj)) {
4134 bool PythonQtShell_SocExplorerPlot::focusNextPrevChild(bool next0)
4135 {
4136 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4137 static PyObject* name = PyString_FromString("focusNextPrevChild");
4138 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4139 if (obj) {
3807 4140 static const char* argumentList[] ={"bool" , "bool"};
3808 4141 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3809 4142 bool returnValue;
3810 void* args[2] = {NULL, (void*)&next};
4143 void* args[2] = {NULL, (void*)&next0};
3811 4144 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3812 4145 if (result) {
3813 4146 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3814 4147 if (args[0]!=&returnValue) {
3815 4148 if (args[0]==NULL) {
3816 4149 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
3817 4150 } else {
3818 4151 returnValue = *((bool*)args[0]);
3819 4152 }
3820 4153 }
3821 4154 }
3822 4155 if (result) { Py_DECREF(result); }
3823 4156 Py_DECREF(obj);
3824 4157 return returnValue;
3825 }
3826 }
3827 return SocExplorerPlot::focusNextPrevChild(next);
4158 } else {
4159 PyErr_Clear();
4160 }
4161 }
4162 return SocExplorerPlot::focusNextPrevChild(next0);
3828 4163 }
3829 4164 void PythonQtShell_SocExplorerPlot::focusOutEvent(QFocusEvent* arg__1)
3830 4165 {
3831 if (_wrapper) {
3832 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
3833 PyErr_Clear();
3834 if (obj && !PythonQtSlotFunction_Check(obj)) {
4166 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4167 static PyObject* name = PyString_FromString("focusOutEvent");
4168 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4169 if (obj) {
3835 4170 static const char* argumentList[] ={"" , "QFocusEvent*"};
3836 4171 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3837 4172 void* args[2] = {NULL, (void*)&arg__1};
3838 4173 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3839 4174 if (result) { Py_DECREF(result); }
3840 4175 Py_DECREF(obj);
3841 4176 return;
4177 } else {
4178 PyErr_Clear();
3842 4179 }
3843 4180 }
3844 4181 SocExplorerPlot::focusOutEvent(arg__1);
3845 4182 }
3846 4183 bool PythonQtShell_SocExplorerPlot::hasHeightForWidth() const
3847 4184 {
3848 if (_wrapper) {
3849 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
3850 PyErr_Clear();
3851 if (obj && !PythonQtSlotFunction_Check(obj)) {
4185 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4186 static PyObject* name = PyString_FromString("hasHeightForWidth");
4187 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4188 if (obj) {
3852 4189 static const char* argumentList[] ={"bool"};
3853 4190 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3854 4191 bool returnValue;
3855 4192 void* args[1] = {NULL};
3856 4193 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3857 4194 if (result) {
3858 4195 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3859 4196 if (args[0]!=&returnValue) {
3860 4197 if (args[0]==NULL) {
3861 4198 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
3862 4199 } else {
3863 4200 returnValue = *((bool*)args[0]);
3864 4201 }
3865 4202 }
3866 4203 }
3867 4204 if (result) { Py_DECREF(result); }
3868 4205 Py_DECREF(obj);
3869 4206 return returnValue;
4207 } else {
4208 PyErr_Clear();
3870 4209 }
3871 4210 }
3872 4211 return SocExplorerPlot::hasHeightForWidth();
3873 4212 }
3874 4213 int PythonQtShell_SocExplorerPlot::heightForWidth(int arg__1) const
3875 4214 {
3876 if (_wrapper) {
3877 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
3878 PyErr_Clear();
3879 if (obj && !PythonQtSlotFunction_Check(obj)) {
4215 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4216 static PyObject* name = PyString_FromString("heightForWidth");
4217 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4218 if (obj) {
3880 4219 static const char* argumentList[] ={"int" , "int"};
3881 4220 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3882 4221 int returnValue;
3883 4222 void* args[2] = {NULL, (void*)&arg__1};
3884 4223 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3885 4224 if (result) {
3886 4225 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3887 4226 if (args[0]!=&returnValue) {
3888 4227 if (args[0]==NULL) {
3889 4228 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
3890 4229 } else {
3891 4230 returnValue = *((int*)args[0]);
3892 4231 }
3893 4232 }
3894 4233 }
3895 4234 if (result) { Py_DECREF(result); }
3896 4235 Py_DECREF(obj);
3897 4236 return returnValue;
4237 } else {
4238 PyErr_Clear();
3898 4239 }
3899 4240 }
3900 4241 return SocExplorerPlot::heightForWidth(arg__1);
3901 4242 }
3902 4243 void PythonQtShell_SocExplorerPlot::hideEvent(QHideEvent* arg__1)
3903 4244 {
3904 if (_wrapper) {
3905 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
3906 PyErr_Clear();
3907 if (obj && !PythonQtSlotFunction_Check(obj)) {
4245 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4246 static PyObject* name = PyString_FromString("hideEvent");
4247 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4248 if (obj) {
3908 4249 static const char* argumentList[] ={"" , "QHideEvent*"};
3909 4250 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3910 4251 void* args[2] = {NULL, (void*)&arg__1};
3911 4252 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3912 4253 if (result) { Py_DECREF(result); }
3913 4254 Py_DECREF(obj);
3914 4255 return;
4256 } else {
4257 PyErr_Clear();
3915 4258 }
3916 4259 }
3917 4260 SocExplorerPlot::hideEvent(arg__1);
3918 4261 }
3919 void PythonQtShell_SocExplorerPlot::initPainter(QPainter* painter) const
3920 {
3921 if (_wrapper) {
3922 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
3923 PyErr_Clear();
3924 if (obj && !PythonQtSlotFunction_Check(obj)) {
4262 void PythonQtShell_SocExplorerPlot::initPainter(QPainter* painter0) const
4263 {
4264 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4265 static PyObject* name = PyString_FromString("initPainter");
4266 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4267 if (obj) {
3925 4268 static const char* argumentList[] ={"" , "QPainter*"};
3926 4269 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3927 void* args[2] = {NULL, (void*)&painter};
3928 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3929 if (result) { Py_DECREF(result); }
3930 Py_DECREF(obj);
3931 return;
3932 }
3933 }
3934 SocExplorerPlot::initPainter(painter);
4270 void* args[2] = {NULL, (void*)&painter0};
4271 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4272 if (result) { Py_DECREF(result); }
4273 Py_DECREF(obj);
4274 return;
4275 } else {
4276 PyErr_Clear();
4277 }
4278 }
4279 SocExplorerPlot::initPainter(painter0);
3935 4280 }
3936 4281 void PythonQtShell_SocExplorerPlot::inputMethodEvent(QInputMethodEvent* arg__1)
3937 4282 {
3938 if (_wrapper) {
3939 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
3940 PyErr_Clear();
3941 if (obj && !PythonQtSlotFunction_Check(obj)) {
4283 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4284 static PyObject* name = PyString_FromString("inputMethodEvent");
4285 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4286 if (obj) {
3942 4287 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
3943 4288 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3944 4289 void* args[2] = {NULL, (void*)&arg__1};
3945 4290 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3946 4291 if (result) { Py_DECREF(result); }
3947 4292 Py_DECREF(obj);
3948 4293 return;
4294 } else {
4295 PyErr_Clear();
3949 4296 }
3950 4297 }
3951 4298 SocExplorerPlot::inputMethodEvent(arg__1);
3952 4299 }
3953 4300 QVariant PythonQtShell_SocExplorerPlot::inputMethodQuery(Qt::InputMethodQuery arg__1) const
3954 4301 {
3955 if (_wrapper) {
3956 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
3957 PyErr_Clear();
3958 if (obj && !PythonQtSlotFunction_Check(obj)) {
4302 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4303 static PyObject* name = PyString_FromString("inputMethodQuery");
4304 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4305 if (obj) {
3959 4306 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
3960 4307 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3961 4308 QVariant returnValue;
3962 4309 void* args[2] = {NULL, (void*)&arg__1};
3963 4310 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3964 4311 if (result) {
3965 4312 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3966 4313 if (args[0]!=&returnValue) {
3967 4314 if (args[0]==NULL) {
3968 4315 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
3969 4316 } else {
3970 4317 returnValue = *((QVariant*)args[0]);
3971 4318 }
3972 4319 }
3973 4320 }
3974 4321 if (result) { Py_DECREF(result); }
3975 4322 Py_DECREF(obj);
3976 4323 return returnValue;
4324 } else {
4325 PyErr_Clear();
3977 4326 }
3978 4327 }
3979 4328 return SocExplorerPlot::inputMethodQuery(arg__1);
3980 4329 }
3981 4330 void PythonQtShell_SocExplorerPlot::keyPressEvent(QKeyEvent* arg__1)
3982 4331 {
3983 if (_wrapper) {
3984 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
3985 PyErr_Clear();
3986 if (obj && !PythonQtSlotFunction_Check(obj)) {
4332 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4333 static PyObject* name = PyString_FromString("keyPressEvent");
4334 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4335 if (obj) {
3987 4336 static const char* argumentList[] ={"" , "QKeyEvent*"};
3988 4337 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3989 4338 void* args[2] = {NULL, (void*)&arg__1};
3990 4339 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3991 4340 if (result) { Py_DECREF(result); }
3992 4341 Py_DECREF(obj);
3993 4342 return;
4343 } else {
4344 PyErr_Clear();
3994 4345 }
3995 4346 }
3996 4347 SocExplorerPlot::keyPressEvent(arg__1);
3997 4348 }
3998 4349 void PythonQtShell_SocExplorerPlot::keyReleaseEvent(QKeyEvent* arg__1)
3999 4350 {
4000 if (_wrapper) {
4001 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
4002 PyErr_Clear();
4003 if (obj && !PythonQtSlotFunction_Check(obj)) {
4351 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4352 static PyObject* name = PyString_FromString("keyReleaseEvent");
4353 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4354 if (obj) {
4004 4355 static const char* argumentList[] ={"" , "QKeyEvent*"};
4005 4356 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4006 4357 void* args[2] = {NULL, (void*)&arg__1};
4007 4358 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4008 4359 if (result) { Py_DECREF(result); }
4009 4360 Py_DECREF(obj);
4010 4361 return;
4362 } else {
4363 PyErr_Clear();
4011 4364 }
4012 4365 }
4013 4366 SocExplorerPlot::keyReleaseEvent(arg__1);
4014 4367 }
4015 4368 void PythonQtShell_SocExplorerPlot::leaveEvent(QEvent* arg__1)
4016 4369 {
4017 if (_wrapper) {
4018 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
4019 PyErr_Clear();
4020 if (obj && !PythonQtSlotFunction_Check(obj)) {
4370 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4371 static PyObject* name = PyString_FromString("leaveEvent");
4372 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4373 if (obj) {
4021 4374 static const char* argumentList[] ={"" , "QEvent*"};
4022 4375 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4023 4376 void* args[2] = {NULL, (void*)&arg__1};
4024 4377 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4025 4378 if (result) { Py_DECREF(result); }
4026 4379 Py_DECREF(obj);
4027 4380 return;
4381 } else {
4382 PyErr_Clear();
4028 4383 }
4029 4384 }
4030 4385 SocExplorerPlot::leaveEvent(arg__1);
4031 4386 }
4032 4387 int PythonQtShell_SocExplorerPlot::metric(QPaintDevice::PaintDeviceMetric arg__1) const
4033 4388 {
4034 if (_wrapper) {
4035 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
4036 PyErr_Clear();
4037 if (obj && !PythonQtSlotFunction_Check(obj)) {
4389 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4390 static PyObject* name = PyString_FromString("metric");
4391 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4392 if (obj) {
4038 4393 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
4039 4394 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4040 4395 int returnValue;
4041 4396 void* args[2] = {NULL, (void*)&arg__1};
4042 4397 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4043 4398 if (result) {
4044 4399 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4045 4400 if (args[0]!=&returnValue) {
4046 4401 if (args[0]==NULL) {
4047 4402 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
4048 4403 } else {
4049 4404 returnValue = *((int*)args[0]);
4050 4405 }
4051 4406 }
4052 4407 }
4053 4408 if (result) { Py_DECREF(result); }
4054 4409 Py_DECREF(obj);
4055 4410 return returnValue;
4411 } else {
4412 PyErr_Clear();
4056 4413 }
4057 4414 }
4058 4415 return SocExplorerPlot::metric(arg__1);
4059 4416 }
4060 4417 QSize PythonQtShell_SocExplorerPlot::minimumSizeHint() const
4061 4418 {
4062 if (_wrapper) {
4063 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
4064 PyErr_Clear();
4065 if (obj && !PythonQtSlotFunction_Check(obj)) {
4419 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4420 static PyObject* name = PyString_FromString("getMinimumSizeHint");
4421 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4422 if (obj) {
4066 4423 static const char* argumentList[] ={"QSize"};
4067 4424 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4068 4425 QSize returnValue;
4069 4426 void* args[1] = {NULL};
4070 4427 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4071 4428 if (result) {
4072 4429 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4073 4430 if (args[0]!=&returnValue) {
4074 4431 if (args[0]==NULL) {
4075 4432 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
4076 4433 } else {
4077 4434 returnValue = *((QSize*)args[0]);
4078 4435 }
4079 4436 }
4080 4437 }
4081 4438 if (result) { Py_DECREF(result); }
4082 4439 Py_DECREF(obj);
4083 4440 return returnValue;
4441 } else {
4442 PyErr_Clear();
4084 4443 }
4085 4444 }
4086 4445 return SocExplorerPlot::minimumSizeHint();
4087 4446 }
4088 4447 void PythonQtShell_SocExplorerPlot::mouseDoubleClickEvent(QMouseEvent* arg__1)
4089 4448 {
4090 if (_wrapper) {
4091 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
4092 PyErr_Clear();
4093 if (obj && !PythonQtSlotFunction_Check(obj)) {
4449 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4450 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
4451 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4452 if (obj) {
4094 4453 static const char* argumentList[] ={"" , "QMouseEvent*"};
4095 4454 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4096 4455 void* args[2] = {NULL, (void*)&arg__1};
4097 4456 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4098 4457 if (result) { Py_DECREF(result); }
4099 4458 Py_DECREF(obj);
4100 4459 return;
4460 } else {
4461 PyErr_Clear();
4101 4462 }
4102 4463 }
4103 4464 SocExplorerPlot::mouseDoubleClickEvent(arg__1);
4104 4465 }
4105 4466 void PythonQtShell_SocExplorerPlot::mouseMoveEvent(QMouseEvent* arg__1)
4106 4467 {
4107 if (_wrapper) {
4108 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
4109 PyErr_Clear();
4110 if (obj && !PythonQtSlotFunction_Check(obj)) {
4468 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4469 static PyObject* name = PyString_FromString("mouseMoveEvent");
4470 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4471 if (obj) {
4111 4472 static const char* argumentList[] ={"" , "QMouseEvent*"};
4112 4473 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4113 4474 void* args[2] = {NULL, (void*)&arg__1};
4114 4475 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4115 4476 if (result) { Py_DECREF(result); }
4116 4477 Py_DECREF(obj);
4117 4478 return;
4479 } else {
4480 PyErr_Clear();
4118 4481 }
4119 4482 }
4120 4483 SocExplorerPlot::mouseMoveEvent(arg__1);
4121 4484 }
4122 4485 void PythonQtShell_SocExplorerPlot::mousePressEvent(QMouseEvent* arg__1)
4123 4486 {
4124 if (_wrapper) {
4125 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
4126 PyErr_Clear();
4127 if (obj && !PythonQtSlotFunction_Check(obj)) {
4487 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4488 static PyObject* name = PyString_FromString("mousePressEvent");
4489 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4490 if (obj) {
4128 4491 static const char* argumentList[] ={"" , "QMouseEvent*"};
4129 4492 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4130 4493 void* args[2] = {NULL, (void*)&arg__1};
4131 4494 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4132 4495 if (result) { Py_DECREF(result); }
4133 4496 Py_DECREF(obj);
4134 4497 return;
4498 } else {
4499 PyErr_Clear();
4135 4500 }
4136 4501 }
4137 4502 SocExplorerPlot::mousePressEvent(arg__1);
4138 4503 }
4139 4504 void PythonQtShell_SocExplorerPlot::mouseReleaseEvent(QMouseEvent* arg__1)
4140 4505 {
4141 if (_wrapper) {
4142 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
4143 PyErr_Clear();
4144 if (obj && !PythonQtSlotFunction_Check(obj)) {
4506 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4507 static PyObject* name = PyString_FromString("mouseReleaseEvent");
4508 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4509 if (obj) {
4145 4510 static const char* argumentList[] ={"" , "QMouseEvent*"};
4146 4511 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4147 4512 void* args[2] = {NULL, (void*)&arg__1};
4148 4513 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4149 4514 if (result) { Py_DECREF(result); }
4150 4515 Py_DECREF(obj);
4151 4516 return;
4517 } else {
4518 PyErr_Clear();
4152 4519 }
4153 4520 }
4154 4521 SocExplorerPlot::mouseReleaseEvent(arg__1);
4155 4522 }
4156 4523 void PythonQtShell_SocExplorerPlot::moveEvent(QMoveEvent* arg__1)
4157 4524 {
4158 if (_wrapper) {
4159 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
4160 PyErr_Clear();
4161 if (obj && !PythonQtSlotFunction_Check(obj)) {
4525 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4526 static PyObject* name = PyString_FromString("moveEvent");
4527 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4528 if (obj) {
4162 4529 static const char* argumentList[] ={"" , "QMoveEvent*"};
4163 4530 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4164 4531 void* args[2] = {NULL, (void*)&arg__1};
4165 4532 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4166 4533 if (result) { Py_DECREF(result); }
4167 4534 Py_DECREF(obj);
4168 4535 return;
4536 } else {
4537 PyErr_Clear();
4169 4538 }
4170 4539 }
4171 4540 SocExplorerPlot::moveEvent(arg__1);
4172 4541 }
4173 bool PythonQtShell_SocExplorerPlot::nativeEvent(const QByteArray& eventType, void* message, long* result)
4174 {
4175 if (_wrapper) {
4176 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
4177 PyErr_Clear();
4178 if (obj && !PythonQtSlotFunction_Check(obj)) {
4542 bool PythonQtShell_SocExplorerPlot::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
4543 {
4544 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4545 static PyObject* name = PyString_FromString("nativeEvent");
4546 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4547 if (obj) {
4179 4548 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
4180 4549 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
4181 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 4552 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4184 4553 if (result) {
4185 4554 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4186 4555 if (args[0]!=&returnValue) {
4187 4556 if (args[0]==NULL) {
4188 4557 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
4189 4558 } else {
4190 4559 returnValue = *((bool*)args[0]);
4191 4560 }
4192 4561 }
4193 4562 }
4194 4563 if (result) { Py_DECREF(result); }
4195 4564 Py_DECREF(obj);
4196 4565 return returnValue;
4197 }
4198 }
4199 return SocExplorerPlot::nativeEvent(eventType, message, result);
4566 } else {
4567 PyErr_Clear();
4568 }
4569 }
4570 return SocExplorerPlot::nativeEvent(eventType0, message1, result2);
4200 4571 }
4201 4572 QPaintEngine* PythonQtShell_SocExplorerPlot::paintEngine() const
4202 4573 {
4203 if (_wrapper) {
4204 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
4205 PyErr_Clear();
4206 if (obj && !PythonQtSlotFunction_Check(obj)) {
4574 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4575 static PyObject* name = PyString_FromString("paintEngine");
4576 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4577 if (obj) {
4207 4578 static const char* argumentList[] ={"QPaintEngine*"};
4208 4579 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4209 4580 QPaintEngine* returnValue;
4210 4581 void* args[1] = {NULL};
4211 4582 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4212 4583 if (result) {
4213 4584 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4214 4585 if (args[0]!=&returnValue) {
4215 4586 if (args[0]==NULL) {
4216 4587 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
4217 4588 } else {
4218 4589 returnValue = *((QPaintEngine**)args[0]);
4219 4590 }
4220 4591 }
4221 4592 }
4222 4593 if (result) { Py_DECREF(result); }
4223 4594 Py_DECREF(obj);
4224 4595 return returnValue;
4596 } else {
4597 PyErr_Clear();
4225 4598 }
4226 4599 }
4227 4600 return SocExplorerPlot::paintEngine();
4228 4601 }
4229 4602 void PythonQtShell_SocExplorerPlot::paintEvent(QPaintEvent* arg__1)
4230 4603 {
4231 if (_wrapper) {
4232 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
4233 PyErr_Clear();
4234 if (obj && !PythonQtSlotFunction_Check(obj)) {
4604 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4605 static PyObject* name = PyString_FromString("paintEvent");
4606 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4607 if (obj) {
4235 4608 static const char* argumentList[] ={"" , "QPaintEvent*"};
4236 4609 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4237 4610 void* args[2] = {NULL, (void*)&arg__1};
4238 4611 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4239 4612 if (result) { Py_DECREF(result); }
4240 4613 Py_DECREF(obj);
4241 4614 return;
4615 } else {
4616 PyErr_Clear();
4242 4617 }
4243 4618 }
4244 4619 SocExplorerPlot::paintEvent(arg__1);
4245 4620 }
4246 QPaintDevice* PythonQtShell_SocExplorerPlot::redirected(QPoint* offset) const
4247 {
4248 if (_wrapper) {
4249 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
4250 PyErr_Clear();
4251 if (obj && !PythonQtSlotFunction_Check(obj)) {
4621 QPaintDevice* PythonQtShell_SocExplorerPlot::redirected(QPoint* offset0) const
4622 {
4623 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4624 static PyObject* name = PyString_FromString("redirected");
4625 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4626 if (obj) {
4252 4627 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
4253 4628 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4254 4629 QPaintDevice* returnValue;
4255 void* args[2] = {NULL, (void*)&offset};
4630 void* args[2] = {NULL, (void*)&offset0};
4256 4631 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4257 4632 if (result) {
4258 4633 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4259 4634 if (args[0]!=&returnValue) {
4260 4635 if (args[0]==NULL) {
4261 4636 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
4262 4637 } else {
4263 4638 returnValue = *((QPaintDevice**)args[0]);
4264 4639 }
4265 4640 }
4266 4641 }
4267 4642 if (result) { Py_DECREF(result); }
4268 4643 Py_DECREF(obj);
4269 4644 return returnValue;
4270 }
4271 }
4272 return SocExplorerPlot::redirected(offset);
4645 } else {
4646 PyErr_Clear();
4647 }
4648 }
4649 return SocExplorerPlot::redirected(offset0);
4273 4650 }
4274 4651 void PythonQtShell_SocExplorerPlot::resizeEvent(QResizeEvent* arg__1)
4275 4652 {
4276 if (_wrapper) {
4277 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
4278 PyErr_Clear();
4279 if (obj && !PythonQtSlotFunction_Check(obj)) {
4653 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4654 static PyObject* name = PyString_FromString("resizeEvent");
4655 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4656 if (obj) {
4280 4657 static const char* argumentList[] ={"" , "QResizeEvent*"};
4281 4658 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4282 4659 void* args[2] = {NULL, (void*)&arg__1};
4283 4660 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4284 4661 if (result) { Py_DECREF(result); }
4285 4662 Py_DECREF(obj);
4286 4663 return;
4664 } else {
4665 PyErr_Clear();
4287 4666 }
4288 4667 }
4289 4668 SocExplorerPlot::resizeEvent(arg__1);
4290 4669 }
4291 4670 QPainter* PythonQtShell_SocExplorerPlot::sharedPainter() const
4292 4671 {
4293 if (_wrapper) {
4294 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
4295 PyErr_Clear();
4296 if (obj && !PythonQtSlotFunction_Check(obj)) {
4672 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4673 static PyObject* name = PyString_FromString("sharedPainter");
4674 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4675 if (obj) {
4297 4676 static const char* argumentList[] ={"QPainter*"};
4298 4677 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4299 4678 QPainter* returnValue;
4300 4679 void* args[1] = {NULL};
4301 4680 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4302 4681 if (result) {
4303 4682 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4304 4683 if (args[0]!=&returnValue) {
4305 4684 if (args[0]==NULL) {
4306 4685 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
4307 4686 } else {
4308 4687 returnValue = *((QPainter**)args[0]);
4309 4688 }
4310 4689 }
4311 4690 }
4312 4691 if (result) { Py_DECREF(result); }
4313 4692 Py_DECREF(obj);
4314 4693 return returnValue;
4694 } else {
4695 PyErr_Clear();
4315 4696 }
4316 4697 }
4317 4698 return SocExplorerPlot::sharedPainter();
4318 4699 }
4319 4700 void PythonQtShell_SocExplorerPlot::showEvent(QShowEvent* arg__1)
4320 4701 {
4321 if (_wrapper) {
4322 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
4323 PyErr_Clear();
4324 if (obj && !PythonQtSlotFunction_Check(obj)) {
4702 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4703 static PyObject* name = PyString_FromString("showEvent");
4704 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4705 if (obj) {
4325 4706 static const char* argumentList[] ={"" , "QShowEvent*"};
4326 4707 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4327 4708 void* args[2] = {NULL, (void*)&arg__1};
4328 4709 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4329 4710 if (result) { Py_DECREF(result); }
4330 4711 Py_DECREF(obj);
4331 4712 return;
4713 } else {
4714 PyErr_Clear();
4332 4715 }
4333 4716 }
4334 4717 SocExplorerPlot::showEvent(arg__1);
4335 4718 }
4336 4719 QSize PythonQtShell_SocExplorerPlot::sizeHint() const
4337 4720 {
4338 if (_wrapper) {
4339 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
4340 PyErr_Clear();
4341 if (obj && !PythonQtSlotFunction_Check(obj)) {
4721 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4722 static PyObject* name = PyString_FromString("getSizeHint");
4723 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4724 if (obj) {
4342 4725 static const char* argumentList[] ={"QSize"};
4343 4726 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4344 4727 QSize returnValue;
4345 4728 void* args[1] = {NULL};
4346 4729 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4347 4730 if (result) {
4348 4731 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4349 4732 if (args[0]!=&returnValue) {
4350 4733 if (args[0]==NULL) {
4351 4734 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
4352 4735 } else {
4353 4736 returnValue = *((QSize*)args[0]);
4354 4737 }
4355 4738 }
4356 4739 }
4357 4740 if (result) { Py_DECREF(result); }
4358 4741 Py_DECREF(obj);
4359 4742 return returnValue;
4743 } else {
4744 PyErr_Clear();
4360 4745 }
4361 4746 }
4362 4747 return SocExplorerPlot::sizeHint();
4363 4748 }
4364 4749 void PythonQtShell_SocExplorerPlot::tabletEvent(QTabletEvent* arg__1)
4365 4750 {
4366 if (_wrapper) {
4367 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
4368 PyErr_Clear();
4369 if (obj && !PythonQtSlotFunction_Check(obj)) {
4751 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4752 static PyObject* name = PyString_FromString("tabletEvent");
4753 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4754 if (obj) {
4370 4755 static const char* argumentList[] ={"" , "QTabletEvent*"};
4371 4756 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4372 4757 void* args[2] = {NULL, (void*)&arg__1};
4373 4758 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4374 4759 if (result) { Py_DECREF(result); }
4375 4760 Py_DECREF(obj);
4376 4761 return;
4762 } else {
4763 PyErr_Clear();
4377 4764 }
4378 4765 }
4379 4766 SocExplorerPlot::tabletEvent(arg__1);
4380 4767 }
4381 4768 void PythonQtShell_SocExplorerPlot::timerEvent(QTimerEvent* arg__1)
4382 4769 {
4383 if (_wrapper) {
4384 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
4385 PyErr_Clear();
4386 if (obj && !PythonQtSlotFunction_Check(obj)) {
4770 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4771 static PyObject* name = PyString_FromString("timerEvent");
4772 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4773 if (obj) {
4387 4774 static const char* argumentList[] ={"" , "QTimerEvent*"};
4388 4775 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4389 4776 void* args[2] = {NULL, (void*)&arg__1};
4390 4777 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4391 4778 if (result) { Py_DECREF(result); }
4392 4779 Py_DECREF(obj);
4393 4780 return;
4781 } else {
4782 PyErr_Clear();
4394 4783 }
4395 4784 }
4396 4785 SocExplorerPlot::timerEvent(arg__1);
4397 4786 }
4398 4787 void PythonQtShell_SocExplorerPlot::wheelEvent(QWheelEvent* arg__1)
4399 4788 {
4400 if (_wrapper) {
4401 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
4402 PyErr_Clear();
4403 if (obj && !PythonQtSlotFunction_Check(obj)) {
4789 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4790 static PyObject* name = PyString_FromString("wheelEvent");
4791 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4792 if (obj) {
4404 4793 static const char* argumentList[] ={"" , "QWheelEvent*"};
4405 4794 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4406 4795 void* args[2] = {NULL, (void*)&arg__1};
4407 4796 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4408 4797 if (result) { Py_DECREF(result); }
4409 4798 Py_DECREF(obj);
4410 4799 return;
4800 } else {
4801 PyErr_Clear();
4411 4802 }
4412 4803 }
4413 4804 SocExplorerPlot::wheelEvent(arg__1);
4414 4805 }
4415 4806 SocExplorerPlot* PythonQtWrapper_SocExplorerPlot::new_SocExplorerPlot(QWidget* parent)
4416 4807 {
4417 4808 return new PythonQtShell_SocExplorerPlot(parent); }
4418 4809
4419 4810 int PythonQtWrapper_SocExplorerPlot::addGraph(SocExplorerPlot* theWrappedObject)
4420 4811 {
4421 4812 return ( theWrappedObject->addGraph());
4422 4813 }
4423 4814
4424 4815 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4425 4816 {
4426 4817 ( theWrappedObject->addGraphData(graphIndex, x, y));
4427 4818 }
4428 4819
4429 4820 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y)
4430 4821 {
4431 4822 ( theWrappedObject->addGraphData(graphIndex, x, y));
4432 4823 }
4433 4824
4434 4825 QPen PythonQtWrapper_SocExplorerPlot::getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex)
4435 4826 {
4436 4827 return ( theWrappedObject->getGraphPen(graphIndex));
4437 4828 }
4438 4829
4439 4830 void PythonQtWrapper_SocExplorerPlot::keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4440 4831 {
4441 4832 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyPressEvent(arg__1));
4442 4833 }
4443 4834
4444 4835 void PythonQtWrapper_SocExplorerPlot::keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4445 4836 {
4446 4837 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyReleaseEvent(arg__1));
4447 4838 }
4448 4839
4449 4840 void PythonQtWrapper_SocExplorerPlot::mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4450 4841 {
4451 4842 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseMoveEvent(arg__1));
4452 4843 }
4453 4844
4454 4845 void PythonQtWrapper_SocExplorerPlot::mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4455 4846 {
4456 4847 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mousePressEvent(arg__1));
4457 4848 }
4458 4849
4459 4850 void PythonQtWrapper_SocExplorerPlot::mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4460 4851 {
4461 4852 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseReleaseEvent(arg__1));
4462 4853 }
4463 4854
4464 4855 void PythonQtWrapper_SocExplorerPlot::rescaleAxis(SocExplorerPlot* theWrappedObject)
4465 4856 {
4466 4857 ( theWrappedObject->rescaleAxis());
4467 4858 }
4468 4859
4469 4860 void PythonQtWrapper_SocExplorerPlot::setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable)
4470 4861 {
4471 4862 ( theWrappedObject->setAdaptativeSampling(graphIndex, enable));
4472 4863 }
4473 4864
4474 4865 void PythonQtWrapper_SocExplorerPlot::setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4475 4866 {
4476 4867 ( theWrappedObject->setGraphData(graphIndex, x, y));
4477 4868 }
4478 4869
4479 4870 void PythonQtWrapper_SocExplorerPlot::setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle)
4480 4871 {
4481 4872 ( theWrappedObject->setGraphLineStyle(graphIndex, lineStyle));
4482 4873 }
4483 4874
4484 4875 void PythonQtWrapper_SocExplorerPlot::setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name)
4485 4876 {
4486 4877 ( theWrappedObject->setGraphName(graphIndex, name));
4487 4878 }
4488 4879
4489 4880 void PythonQtWrapper_SocExplorerPlot::setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen)
4490 4881 {
4491 4882 ( theWrappedObject->setGraphPen(graphIndex, pen));
4492 4883 }
4493 4884
4494 4885 void PythonQtWrapper_SocExplorerPlot::setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle)
4495 4886 {
4496 4887 ( theWrappedObject->setGraphScatterStyle(graphIndex, scatterStyle));
4497 4888 }
4498 4889
4499 4890 void PythonQtWrapper_SocExplorerPlot::setLegendFont(SocExplorerPlot* theWrappedObject, QFont font)
4500 4891 {
4501 4892 ( theWrappedObject->setLegendFont(font));
4502 4893 }
4503 4894
4504 4895 void PythonQtWrapper_SocExplorerPlot::setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font)
4505 4896 {
4506 4897 ( theWrappedObject->setLegendSelectedFont(font));
4507 4898 }
4508 4899
4509 4900 void PythonQtWrapper_SocExplorerPlot::setTitle(SocExplorerPlot* theWrappedObject, QString title)
4510 4901 {
4511 4902 ( theWrappedObject->setTitle(title));
4512 4903 }
4513 4904
4514 4905 void PythonQtWrapper_SocExplorerPlot::setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4515 4906 {
4516 4907 ( theWrappedObject->setXaxisLabel(label));
4517 4908 }
4518 4909
4519 4910 void PythonQtWrapper_SocExplorerPlot::setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4520 4911 {
4521 4912 ( theWrappedObject->setXaxisRange(lower, upper));
4522 4913 }
4523 4914
4524 4915 void PythonQtWrapper_SocExplorerPlot::setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4525 4916 {
4526 4917 ( theWrappedObject->setYaxisLabel(label));
4527 4918 }
4528 4919
4529 4920 void PythonQtWrapper_SocExplorerPlot::setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4530 4921 {
4531 4922 ( theWrappedObject->setYaxisRange(lower, upper));
4532 4923 }
4533 4924
4534 4925 void PythonQtWrapper_SocExplorerPlot::show(SocExplorerPlot* theWrappedObject)
4535 4926 {
4536 4927 ( theWrappedObject->show());
4537 4928 }
4538 4929
4539 4930 void PythonQtWrapper_SocExplorerPlot::wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1)
4540 4931 {
4541 4932 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_wheelEvent(arg__1));
4542 4933 }
4543 4934
4544 4935
4545 4936
4546 4937 PythonQtShell_TCP_Terminal_Client::~PythonQtShell_TCP_Terminal_Client() {
4547 4938 PythonQtPrivate* priv = PythonQt::priv();
4548 4939 if (priv) { priv->shellClassDeleted(this); }
4549 4940 }
4550 4941 void PythonQtShell_TCP_Terminal_Client::childEvent(QChildEvent* arg__1)
4551 4942 {
4552 if (_wrapper) {
4553 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
4554 PyErr_Clear();
4555 if (obj && !PythonQtSlotFunction_Check(obj)) {
4943 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4944 static PyObject* name = PyString_FromString("childEvent");
4945 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4946 if (obj) {
4556 4947 static const char* argumentList[] ={"" , "QChildEvent*"};
4557 4948 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4558 4949 void* args[2] = {NULL, (void*)&arg__1};
4559 4950 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4560 4951 if (result) { Py_DECREF(result); }
4561 4952 Py_DECREF(obj);
4562 4953 return;
4954 } else {
4955 PyErr_Clear();
4563 4956 }
4564 4957 }
4565 4958 TCP_Terminal_Client::childEvent(arg__1);
4566 4959 }
4567 4960 void PythonQtShell_TCP_Terminal_Client::customEvent(QEvent* arg__1)
4568 4961 {
4569 if (_wrapper) {
4570 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
4571 PyErr_Clear();
4572 if (obj && !PythonQtSlotFunction_Check(obj)) {
4962 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4963 static PyObject* name = PyString_FromString("customEvent");
4964 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4965 if (obj) {
4573 4966 static const char* argumentList[] ={"" , "QEvent*"};
4574 4967 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4575 4968 void* args[2] = {NULL, (void*)&arg__1};
4576 4969 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4577 4970 if (result) { Py_DECREF(result); }
4578 4971 Py_DECREF(obj);
4579 4972 return;
4973 } else {
4974 PyErr_Clear();
4580 4975 }
4581 4976 }
4582 4977 TCP_Terminal_Client::customEvent(arg__1);
4583 4978 }
4584 4979 bool PythonQtShell_TCP_Terminal_Client::event(QEvent* arg__1)
4585 4980 {
4586 if (_wrapper) {
4587 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
4588 PyErr_Clear();
4589 if (obj && !PythonQtSlotFunction_Check(obj)) {
4981 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4982 static PyObject* name = PyString_FromString("event");
4983 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4984 if (obj) {
4590 4985 static const char* argumentList[] ={"bool" , "QEvent*"};
4591 4986 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4592 4987 bool returnValue;
4593 4988 void* args[2] = {NULL, (void*)&arg__1};
4594 4989 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4595 4990 if (result) {
4596 4991 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4597 4992 if (args[0]!=&returnValue) {
4598 4993 if (args[0]==NULL) {
4599 4994 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
4600 4995 } else {
4601 4996 returnValue = *((bool*)args[0]);
4602 4997 }
4603 4998 }
4604 4999 }
4605 5000 if (result) { Py_DECREF(result); }
4606 5001 Py_DECREF(obj);
4607 5002 return returnValue;
5003 } else {
5004 PyErr_Clear();
4608 5005 }
4609 5006 }
4610 5007 return TCP_Terminal_Client::event(arg__1);
4611 5008 }
4612 5009 bool PythonQtShell_TCP_Terminal_Client::eventFilter(QObject* arg__1, QEvent* arg__2)
4613 5010 {
4614 if (_wrapper) {
4615 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
4616 PyErr_Clear();
4617 if (obj && !PythonQtSlotFunction_Check(obj)) {
5011 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5012 static PyObject* name = PyString_FromString("eventFilter");
5013 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5014 if (obj) {
4618 5015 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4619 5016 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4620 5017 bool returnValue;
4621 5018 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
4622 5019 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4623 5020 if (result) {
4624 5021 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4625 5022 if (args[0]!=&returnValue) {
4626 5023 if (args[0]==NULL) {
4627 5024 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
4628 5025 } else {
4629 5026 returnValue = *((bool*)args[0]);
4630 5027 }
4631 5028 }
4632 5029 }
4633 5030 if (result) { Py_DECREF(result); }
4634 5031 Py_DECREF(obj);
4635 5032 return returnValue;
5033 } else {
5034 PyErr_Clear();
4636 5035 }
4637 5036 }
4638 5037 return TCP_Terminal_Client::eventFilter(arg__1, arg__2);
4639 5038 }
4640 5039 void PythonQtShell_TCP_Terminal_Client::timerEvent(QTimerEvent* arg__1)
4641 5040 {
4642 if (_wrapper) {
4643 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
4644 PyErr_Clear();
4645 if (obj && !PythonQtSlotFunction_Check(obj)) {
5041 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5042 static PyObject* name = PyString_FromString("timerEvent");
5043 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5044 if (obj) {
4646 5045 static const char* argumentList[] ={"" , "QTimerEvent*"};
4647 5046 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4648 5047 void* args[2] = {NULL, (void*)&arg__1};
4649 5048 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4650 5049 if (result) { Py_DECREF(result); }
4651 5050 Py_DECREF(obj);
4652 5051 return;
5052 } else {
5053 PyErr_Clear();
4653 5054 }
4654 5055 }
4655 5056 TCP_Terminal_Client::timerEvent(arg__1);
4656 5057 }
4657 5058 TCP_Terminal_Client* PythonQtWrapper_TCP_Terminal_Client::new_TCP_Terminal_Client(QObject* parent)
4658 5059 {
4659 5060 return new PythonQtShell_TCP_Terminal_Client(parent); }
4660 5061
4661 5062 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject)
4662 5063 {
4663 5064 ( theWrappedObject->connectToServer());
4664 5065 }
4665 5066
4666 5067 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port)
4667 5068 {
4668 5069 ( theWrappedObject->connectToServer(IP, port));
4669 5070 }
4670 5071
4671 5072 bool PythonQtWrapper_TCP_Terminal_Client::isConnected(TCP_Terminal_Client* theWrappedObject)
4672 5073 {
4673 5074 return ( theWrappedObject->isConnected());
4674 5075 }
4675 5076
4676 5077 void PythonQtWrapper_TCP_Terminal_Client::sendText(TCP_Terminal_Client* theWrappedObject, const QString& text)
4677 5078 {
4678 5079 ( theWrappedObject->sendText(text));
4679 5080 }
4680 5081
4681 5082 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject)
4682 5083 {
4683 5084 ( theWrappedObject->startServer());
4684 5085 }
4685 5086
4686 5087 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject, int port)
4687 5088 {
4688 5089 ( theWrappedObject->startServer(port));
4689 5090 }
4690 5091
4691 5092
4692 5093
4693 5094 XByteArray* PythonQtWrapper_XByteArray::new_XByteArray()
4694 5095 {
4695 5096 return new XByteArray(); }
4696 5097
4697 5098 int PythonQtWrapper_XByteArray::addressOffset(XByteArray* theWrappedObject)
4698 5099 {
4699 5100 return ( theWrappedObject->addressOffset());
4700 5101 }
4701 5102
4702 5103 int PythonQtWrapper_XByteArray::addressWidth(XByteArray* theWrappedObject)
4703 5104 {
4704 5105 return ( theWrappedObject->addressWidth());
4705 5106 }
4706 5107
4707 5108 QChar PythonQtWrapper_XByteArray::asciiChar(XByteArray* theWrappedObject, int index)
4708 5109 {
4709 5110 return ( theWrappedObject->asciiChar(index));
4710 5111 }
4711 5112
4712 5113 QByteArray* PythonQtWrapper_XByteArray::data(XByteArray* theWrappedObject)
4713 5114 {
4714 5115 return &( theWrappedObject->data());
4715 5116 }
4716 5117
4717 5118 bool PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i)
4718 5119 {
4719 5120 return ( theWrappedObject->dataChanged(i));
4720 5121 }
4721 5122
4722 5123 QByteArray PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i, int len)
4723 5124 {
4724 5125 return ( theWrappedObject->dataChanged(i, len));
4725 5126 }
4726 5127
4727 5128 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, char ch)
4728 5129 {
4729 5130 return &( theWrappedObject->insert(i, ch));
4730 5131 }
4731 5132
4732 5133 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, const QByteArray& ba)
4733 5134 {
4734 5135 return &( theWrappedObject->insert(i, ba));
4735 5136 }
4736 5137
4737 5138 int PythonQtWrapper_XByteArray::realAddressNumbers(XByteArray* theWrappedObject)
4738 5139 {
4739 5140 return ( theWrappedObject->realAddressNumbers());
4740 5141 }
4741 5142
4742 5143 QByteArray* PythonQtWrapper_XByteArray::remove(XByteArray* theWrappedObject, int pos, int len)
4743 5144 {
4744 5145 return &( theWrappedObject->remove(pos, len));
4745 5146 }
4746 5147
4747 5148 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, char ch)
4748 5149 {
4749 5150 return &( theWrappedObject->replace(index, ch));
4750 5151 }
4751 5152
4752 5153 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, const QByteArray& ba)
4753 5154 {
4754 5155 return &( theWrappedObject->replace(index, ba));
4755 5156 }
4756 5157
4757 5158 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba)
4758 5159 {
4759 5160 return &( theWrappedObject->replace(index, length, ba));
4760 5161 }
4761 5162
4762 5163 void PythonQtWrapper_XByteArray::setAddressOffset(XByteArray* theWrappedObject, int offset)
4763 5164 {
4764 5165 ( theWrappedObject->setAddressOffset(offset));
4765 5166 }
4766 5167
4767 5168 void PythonQtWrapper_XByteArray::setAddressWidth(XByteArray* theWrappedObject, int width)
4768 5169 {
4769 5170 ( theWrappedObject->setAddressWidth(width));
4770 5171 }
4771 5172
4772 5173 void PythonQtWrapper_XByteArray::setData(XByteArray* theWrappedObject, QByteArray data)
4773 5174 {
4774 5175 ( theWrappedObject->setData(data));
4775 5176 }
4776 5177
4777 5178 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, bool state)
4778 5179 {
4779 5180 ( theWrappedObject->setDataChanged(i, state));
4780 5181 }
4781 5182
4782 5183 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state)
4783 5184 {
4784 5185 ( theWrappedObject->setDataChanged(i, state));
4785 5186 }
4786 5187
4787 5188 int PythonQtWrapper_XByteArray::size(XByteArray* theWrappedObject)
4788 5189 {
4789 5190 return ( theWrappedObject->size());
4790 5191 }
4791 5192
4792 5193 QString PythonQtWrapper_XByteArray::toRedableString(XByteArray* theWrappedObject, int start, int end)
4793 5194 {
4794 5195 return ( theWrappedObject->toRedableString(start, end));
4795 5196 }
4796 5197
4797 5198
4798 5199
4799 5200 PythonQtShell_abstractBinFile::~PythonQtShell_abstractBinFile() {
4800 5201 PythonQtPrivate* priv = PythonQt::priv();
4801 5202 if (priv) { priv->shellClassDeleted(this); }
4802 5203 }
4803 5204 void PythonQtShell_abstractBinFile::childEvent(QChildEvent* arg__1)
4804 5205 {
4805 if (_wrapper) {
4806 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
4807 PyErr_Clear();
4808 if (obj && !PythonQtSlotFunction_Check(obj)) {
5206 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5207 static PyObject* name = PyString_FromString("childEvent");
5208 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5209 if (obj) {
4809 5210 static const char* argumentList[] ={"" , "QChildEvent*"};
4810 5211 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4811 5212 void* args[2] = {NULL, (void*)&arg__1};
4812 5213 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4813 5214 if (result) { Py_DECREF(result); }
4814 5215 Py_DECREF(obj);
4815 5216 return;
5217 } else {
5218 PyErr_Clear();
4816 5219 }
4817 5220 }
4818 5221 abstractBinFile::childEvent(arg__1);
4819 5222 }
4820 5223 int PythonQtShell_abstractBinFile::closeFile()
4821 5224 {
4822 if (_wrapper) {
4823 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
4824 PyErr_Clear();
4825 if (obj && !PythonQtSlotFunction_Check(obj)) {
5225 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5226 static PyObject* name = PyString_FromString("closeFile");
5227 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5228 if (obj) {
4826 5229 static const char* argumentList[] ={"int"};
4827 5230 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4828 5231 int returnValue;
4829 5232 void* args[1] = {NULL};
4830 5233 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4831 5234 if (result) {
4832 5235 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4833 5236 if (args[0]!=&returnValue) {
4834 5237 if (args[0]==NULL) {
4835 5238 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
4836 5239 } else {
4837 5240 returnValue = *((int*)args[0]);
4838 5241 }
4839 5242 }
4840 5243 }
4841 5244 if (result) { Py_DECREF(result); }
4842 5245 Py_DECREF(obj);
4843 5246 return returnValue;
5247 } else {
5248 PyErr_Clear();
4844 5249 }
4845 5250 }
4846 5251 return int();
4847 5252 }
4848 5253 void PythonQtShell_abstractBinFile::customEvent(QEvent* arg__1)
4849 5254 {
4850 if (_wrapper) {
4851 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
4852 PyErr_Clear();
4853 if (obj && !PythonQtSlotFunction_Check(obj)) {
5255 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5256 static PyObject* name = PyString_FromString("customEvent");
5257 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5258 if (obj) {
4854 5259 static const char* argumentList[] ={"" , "QEvent*"};
4855 5260 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4856 5261 void* args[2] = {NULL, (void*)&arg__1};
4857 5262 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4858 5263 if (result) { Py_DECREF(result); }
4859 5264 Py_DECREF(obj);
4860 5265 return;
5266 } else {
5267 PyErr_Clear();
4861 5268 }
4862 5269 }
4863 5270 abstractBinFile::customEvent(arg__1);
4864 5271 }
4865 5272 bool PythonQtShell_abstractBinFile::event(QEvent* arg__1)
4866 5273 {
4867 if (_wrapper) {
4868 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
4869 PyErr_Clear();
4870 if (obj && !PythonQtSlotFunction_Check(obj)) {
5274 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5275 static PyObject* name = PyString_FromString("event");
5276 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5277 if (obj) {
4871 5278 static const char* argumentList[] ={"bool" , "QEvent*"};
4872 5279 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4873 5280 bool returnValue;
4874 5281 void* args[2] = {NULL, (void*)&arg__1};
4875 5282 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4876 5283 if (result) {
4877 5284 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4878 5285 if (args[0]!=&returnValue) {
4879 5286 if (args[0]==NULL) {
4880 5287 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
4881 5288 } else {
4882 5289 returnValue = *((bool*)args[0]);
4883 5290 }
4884 5291 }
4885 5292 }
4886 5293 if (result) { Py_DECREF(result); }
4887 5294 Py_DECREF(obj);
4888 5295 return returnValue;
5296 } else {
5297 PyErr_Clear();
4889 5298 }
4890 5299 }
4891 5300 return abstractBinFile::event(arg__1);
4892 5301 }
4893 5302 bool PythonQtShell_abstractBinFile::eventFilter(QObject* arg__1, QEvent* arg__2)
4894 5303 {
4895 if (_wrapper) {
4896 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
4897 PyErr_Clear();
4898 if (obj && !PythonQtSlotFunction_Check(obj)) {
5304 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5305 static PyObject* name = PyString_FromString("eventFilter");
5306 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5307 if (obj) {
4899 5308 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4900 5309 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4901 5310 bool returnValue;
4902 5311 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
4903 5312 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4904 5313 if (result) {
4905 5314 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4906 5315 if (args[0]!=&returnValue) {
4907 5316 if (args[0]==NULL) {
4908 5317 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
4909 5318 } else {
4910 5319 returnValue = *((bool*)args[0]);
4911 5320 }
4912 5321 }
4913 5322 }
4914 5323 if (result) { Py_DECREF(result); }
4915 5324 Py_DECREF(obj);
4916 5325 return returnValue;
5326 } else {
5327 PyErr_Clear();
4917 5328 }
4918 5329 }
4919 5330 return abstractBinFile::eventFilter(arg__1, arg__2);
4920 5331 }
4921 5332 QList<codeFragment* > PythonQtShell_abstractBinFile::getFragments()
4922 5333 {
4923 if (_wrapper) {
4924 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
4925 PyErr_Clear();
4926 if (obj && !PythonQtSlotFunction_Check(obj)) {
5334 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5335 static PyObject* name = PyString_FromString("getFragments");
5336 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5337 if (obj) {
4927 5338 static const char* argumentList[] ={"QList<codeFragment* >"};
4928 5339 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4929 5340 QList<codeFragment* > returnValue;
4930 5341 void* args[1] = {NULL};
4931 5342 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4932 5343 if (result) {
4933 5344 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4934 5345 if (args[0]!=&returnValue) {
4935 5346 if (args[0]==NULL) {
4936 5347 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
4937 5348 } else {
4938 5349 returnValue = *((QList<codeFragment* >*)args[0]);
4939 5350 }
4940 5351 }
4941 5352 }
4942 5353 if (result) { Py_DECREF(result); }
4943 5354 Py_DECREF(obj);
4944 5355 return returnValue;
5356 } else {
5357 PyErr_Clear();
4945 5358 }
4946 5359 }
4947 5360 return QList<codeFragment* >();
4948 5361 }
4949 5362 bool PythonQtShell_abstractBinFile::isopened()
4950 5363 {
4951 if (_wrapper) {
4952 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
4953 PyErr_Clear();
4954 if (obj && !PythonQtSlotFunction_Check(obj)) {
5364 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5365 static PyObject* name = PyString_FromString("isopened");
5366 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5367 if (obj) {
4955 5368 static const char* argumentList[] ={"bool"};
4956 5369 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4957 5370 bool returnValue;
4958 5371 void* args[1] = {NULL};
4959 5372 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4960 5373 if (result) {
4961 5374 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4962 5375 if (args[0]!=&returnValue) {
4963 5376 if (args[0]==NULL) {
4964 5377 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
4965 5378 } else {
4966 5379 returnValue = *((bool*)args[0]);
4967 5380 }
4968 5381 }
4969 5382 }
4970 5383 if (result) { Py_DECREF(result); }
4971 5384 Py_DECREF(obj);
4972 5385 return returnValue;
5386 } else {
5387 PyErr_Clear();
4973 5388 }
4974 5389 }
4975 5390 return bool();
4976 5391 }
4977 bool PythonQtShell_abstractBinFile::openFile(const QString& File)
4978 {
4979 if (_wrapper) {
4980 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
4981 PyErr_Clear();
4982 if (obj && !PythonQtSlotFunction_Check(obj)) {
5392 bool PythonQtShell_abstractBinFile::openFile(const QString& File0)
5393 {
5394 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5395 static PyObject* name = PyString_FromString("openFile");
5396 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5397 if (obj) {
4983 5398 static const char* argumentList[] ={"bool" , "const QString&"};
4984 5399 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4985 5400 bool returnValue;
4986 void* args[2] = {NULL, (void*)&File};
5401 void* args[2] = {NULL, (void*)&File0};
4987 5402 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4988 5403 if (result) {
4989 5404 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4990 5405 if (args[0]!=&returnValue) {
4991 5406 if (args[0]==NULL) {
4992 5407 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
4993 5408 } else {
4994 5409 returnValue = *((bool*)args[0]);
4995 5410 }
4996 5411 }
4997 5412 }
4998 5413 if (result) { Py_DECREF(result); }
4999 5414 Py_DECREF(obj);
5000 5415 return returnValue;
5416 } else {
5417 PyErr_Clear();
5001 5418 }
5002 5419 }
5003 5420 return bool();
5004 5421 }
5005 5422 void PythonQtShell_abstractBinFile::timerEvent(QTimerEvent* arg__1)
5006 5423 {
5007 if (_wrapper) {
5008 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
5009 PyErr_Clear();
5010 if (obj && !PythonQtSlotFunction_Check(obj)) {
5424 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5425 static PyObject* name = PyString_FromString("timerEvent");
5426 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5427 if (obj) {
5011 5428 static const char* argumentList[] ={"" , "QTimerEvent*"};
5012 5429 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5013 5430 void* args[2] = {NULL, (void*)&arg__1};
5014 5431 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5015 5432 if (result) { Py_DECREF(result); }
5016 5433 Py_DECREF(obj);
5017 5434 return;
5435 } else {
5436 PyErr_Clear();
5018 5437 }
5019 5438 }
5020 5439 abstractBinFile::timerEvent(arg__1);
5021 5440 }
5022 bool PythonQtShell_abstractBinFile::toBinary(const QString& File)
5023 {
5024 if (_wrapper) {
5025 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
5026 PyErr_Clear();
5027 if (obj && !PythonQtSlotFunction_Check(obj)) {
5441 bool PythonQtShell_abstractBinFile::toBinary(const QString& File0)
5442 {
5443 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5444 static PyObject* name = PyString_FromString("toBinary");
5445 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5446 if (obj) {
5028 5447 static const char* argumentList[] ={"bool" , "const QString&"};
5029 5448 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5030 5449 bool returnValue;
5031 void* args[2] = {NULL, (void*)&File};
5450 void* args[2] = {NULL, (void*)&File0};
5032 5451 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5033 5452 if (result) {
5034 5453 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5035 5454 if (args[0]!=&returnValue) {
5036 5455 if (args[0]==NULL) {
5037 5456 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
5038 5457 } else {
5039 5458 returnValue = *((bool*)args[0]);
5040 5459 }
5041 5460 }
5042 5461 }
5043 5462 if (result) { Py_DECREF(result); }
5044 5463 Py_DECREF(obj);
5045 5464 return returnValue;
5465 } else {
5466 PyErr_Clear();
5046 5467 }
5047 5468 }
5048 5469 return bool();
5049 5470 }
5050 bool PythonQtShell_abstractBinFile::toSrec(const QString& File)
5051 {
5052 if (_wrapper) {
5053 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
5054 PyErr_Clear();
5055 if (obj && !PythonQtSlotFunction_Check(obj)) {
5471 bool PythonQtShell_abstractBinFile::toSrec(const QString& File0)
5472 {
5473 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5474 static PyObject* name = PyString_FromString("toSrec");
5475 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5476 if (obj) {
5056 5477 static const char* argumentList[] ={"bool" , "const QString&"};
5057 5478 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5058 5479 bool returnValue;
5059 void* args[2] = {NULL, (void*)&File};
5480 void* args[2] = {NULL, (void*)&File0};
5060 5481 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5061 5482 if (result) {
5062 5483 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5063 5484 if (args[0]!=&returnValue) {
5064 5485 if (args[0]==NULL) {
5065 5486 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
5066 5487 } else {
5067 5488 returnValue = *((bool*)args[0]);
5068 5489 }
5069 5490 }
5070 5491 }
5071 5492 if (result) { Py_DECREF(result); }
5072 5493 Py_DECREF(obj);
5073 5494 return returnValue;
5495 } else {
5496 PyErr_Clear();
5074 5497 }
5075 5498 }
5076 5499 return bool();
5077 5500 }
5078 5501 abstractBinFile* PythonQtWrapper_abstractBinFile::new_abstractBinFile()
5079 5502 {
5080 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 5537 PythonQtShell_abstractBinFileWidget::~PythonQtShell_abstractBinFileWidget() {
5085 5538 PythonQtPrivate* priv = PythonQt::priv();
5086 5539 if (priv) { priv->shellClassDeleted(this); }
5087 5540 }
5088 5541 void PythonQtShell_abstractBinFileWidget::actionEvent(QActionEvent* arg__1)
5089 5542 {
5090 if (_wrapper) {
5091 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
5092 PyErr_Clear();
5093 if (obj && !PythonQtSlotFunction_Check(obj)) {
5543 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5544 static PyObject* name = PyString_FromString("actionEvent");
5545 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5546 if (obj) {
5094 5547 static const char* argumentList[] ={"" , "QActionEvent*"};
5095 5548 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5096 5549 void* args[2] = {NULL, (void*)&arg__1};
5097 5550 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5098 5551 if (result) { Py_DECREF(result); }
5099 5552 Py_DECREF(obj);
5100 5553 return;
5554 } else {
5555 PyErr_Clear();
5101 5556 }
5102 5557 }
5103 5558 abstractBinFileWidget::actionEvent(arg__1);
5104 5559 }
5105 5560 void PythonQtShell_abstractBinFileWidget::changeEvent(QEvent* arg__1)
5106 5561 {
5107 if (_wrapper) {
5108 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
5109 PyErr_Clear();
5110 if (obj && !PythonQtSlotFunction_Check(obj)) {
5562 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5563 static PyObject* name = PyString_FromString("changeEvent");
5564 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5565 if (obj) {
5111 5566 static const char* argumentList[] ={"" , "QEvent*"};
5112 5567 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5113 5568 void* args[2] = {NULL, (void*)&arg__1};
5114 5569 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5115 5570 if (result) { Py_DECREF(result); }
5116 5571 Py_DECREF(obj);
5117 5572 return;
5573 } else {
5574 PyErr_Clear();
5118 5575 }
5119 5576 }
5120 5577 abstractBinFileWidget::changeEvent(arg__1);
5121 5578 }
5122 5579 void PythonQtShell_abstractBinFileWidget::childEvent(QChildEvent* arg__1)
5123 5580 {
5124 if (_wrapper) {
5125 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
5126 PyErr_Clear();
5127 if (obj && !PythonQtSlotFunction_Check(obj)) {
5581 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5582 static PyObject* name = PyString_FromString("childEvent");
5583 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5584 if (obj) {
5128 5585 static const char* argumentList[] ={"" , "QChildEvent*"};
5129 5586 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5130 5587 void* args[2] = {NULL, (void*)&arg__1};
5131 5588 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5132 5589 if (result) { Py_DECREF(result); }
5133 5590 Py_DECREF(obj);
5134 5591 return;
5592 } else {
5593 PyErr_Clear();
5135 5594 }
5136 5595 }
5137 5596 abstractBinFileWidget::childEvent(arg__1);
5138 5597 }
5139 5598 void PythonQtShell_abstractBinFileWidget::closeEvent(QCloseEvent* arg__1)
5140 5599 {
5141 if (_wrapper) {
5142 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
5143 PyErr_Clear();
5144 if (obj && !PythonQtSlotFunction_Check(obj)) {
5600 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5601 static PyObject* name = PyString_FromString("closeEvent");
5602 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5603 if (obj) {
5145 5604 static const char* argumentList[] ={"" , "QCloseEvent*"};
5146 5605 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5147 5606 void* args[2] = {NULL, (void*)&arg__1};
5148 5607 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5149 5608 if (result) { Py_DECREF(result); }
5150 5609 Py_DECREF(obj);
5151 5610 return;
5611 } else {
5612 PyErr_Clear();
5152 5613 }
5153 5614 }
5154 5615 abstractBinFileWidget::closeEvent(arg__1);
5155 5616 }
5156 5617 void PythonQtShell_abstractBinFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
5157 5618 {
5158 if (_wrapper) {
5159 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
5160 PyErr_Clear();
5161 if (obj && !PythonQtSlotFunction_Check(obj)) {
5619 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5620 static PyObject* name = PyString_FromString("contextMenuEvent");
5621 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5622 if (obj) {
5162 5623 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
5163 5624 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5164 5625 void* args[2] = {NULL, (void*)&arg__1};
5165 5626 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5166 5627 if (result) { Py_DECREF(result); }
5167 5628 Py_DECREF(obj);
5168 5629 return;
5630 } else {
5631 PyErr_Clear();
5169 5632 }
5170 5633 }
5171 5634 abstractBinFileWidget::contextMenuEvent(arg__1);
5172 5635 }
5173 5636 void PythonQtShell_abstractBinFileWidget::customEvent(QEvent* arg__1)
5174 5637 {
5175 if (_wrapper) {
5176 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
5177 PyErr_Clear();
5178 if (obj && !PythonQtSlotFunction_Check(obj)) {
5638 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5639 static PyObject* name = PyString_FromString("customEvent");
5640 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5641 if (obj) {
5179 5642 static const char* argumentList[] ={"" , "QEvent*"};
5180 5643 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5181 5644 void* args[2] = {NULL, (void*)&arg__1};
5182 5645 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5183 5646 if (result) { Py_DECREF(result); }
5184 5647 Py_DECREF(obj);
5185 5648 return;
5649 } else {
5650 PyErr_Clear();
5186 5651 }
5187 5652 }
5188 5653 abstractBinFileWidget::customEvent(arg__1);
5189 5654 }
5190 5655 int PythonQtShell_abstractBinFileWidget::devType() const
5191 5656 {
5192 if (_wrapper) {
5193 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
5194 PyErr_Clear();
5195 if (obj && !PythonQtSlotFunction_Check(obj)) {
5657 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5658 static PyObject* name = PyString_FromString("devType");
5659 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5660 if (obj) {
5196 5661 static const char* argumentList[] ={"int"};
5197 5662 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5198 5663 int returnValue;
5199 5664 void* args[1] = {NULL};
5200 5665 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5201 5666 if (result) {
5202 5667 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5203 5668 if (args[0]!=&returnValue) {
5204 5669 if (args[0]==NULL) {
5205 5670 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
5206 5671 } else {
5207 5672 returnValue = *((int*)args[0]);
5208 5673 }
5209 5674 }
5210 5675 }
5211 5676 if (result) { Py_DECREF(result); }
5212 5677 Py_DECREF(obj);
5213 5678 return returnValue;
5679 } else {
5680 PyErr_Clear();
5214 5681 }
5215 5682 }
5216 5683 return abstractBinFileWidget::devType();
5217 5684 }
5218 5685 void PythonQtShell_abstractBinFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
5219 5686 {
5220 if (_wrapper) {
5221 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
5222 PyErr_Clear();
5223 if (obj && !PythonQtSlotFunction_Check(obj)) {
5687 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5688 static PyObject* name = PyString_FromString("dragEnterEvent");
5689 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5690 if (obj) {
5224 5691 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
5225 5692 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5226 5693 void* args[2] = {NULL, (void*)&arg__1};
5227 5694 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5228 5695 if (result) { Py_DECREF(result); }
5229 5696 Py_DECREF(obj);
5230 5697 return;
5698 } else {
5699 PyErr_Clear();
5231 5700 }
5232 5701 }
5233 5702 abstractBinFileWidget::dragEnterEvent(arg__1);
5234 5703 }
5235 5704 void PythonQtShell_abstractBinFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
5236 5705 {
5237 if (_wrapper) {
5238 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
5239 PyErr_Clear();
5240 if (obj && !PythonQtSlotFunction_Check(obj)) {
5706 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5707 static PyObject* name = PyString_FromString("dragLeaveEvent");
5708 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5709 if (obj) {
5241 5710 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
5242 5711 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5243 5712 void* args[2] = {NULL, (void*)&arg__1};
5244 5713 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5245 5714 if (result) { Py_DECREF(result); }
5246 5715 Py_DECREF(obj);
5247 5716 return;
5717 } else {
5718 PyErr_Clear();
5248 5719 }
5249 5720 }
5250 5721 abstractBinFileWidget::dragLeaveEvent(arg__1);
5251 5722 }
5252 5723 void PythonQtShell_abstractBinFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
5253 5724 {
5254 if (_wrapper) {
5255 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
5256 PyErr_Clear();
5257 if (obj && !PythonQtSlotFunction_Check(obj)) {
5725 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5726 static PyObject* name = PyString_FromString("dragMoveEvent");
5727 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5728 if (obj) {
5258 5729 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
5259 5730 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5260 5731 void* args[2] = {NULL, (void*)&arg__1};
5261 5732 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5262 5733 if (result) { Py_DECREF(result); }
5263 5734 Py_DECREF(obj);
5264 5735 return;
5736 } else {
5737 PyErr_Clear();
5265 5738 }
5266 5739 }
5267 5740 abstractBinFileWidget::dragMoveEvent(arg__1);
5268 5741 }
5269 5742 void PythonQtShell_abstractBinFileWidget::dropEvent(QDropEvent* arg__1)
5270 5743 {
5271 if (_wrapper) {
5272 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
5273 PyErr_Clear();
5274 if (obj && !PythonQtSlotFunction_Check(obj)) {
5744 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5745 static PyObject* name = PyString_FromString("dropEvent");
5746 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5747 if (obj) {
5275 5748 static const char* argumentList[] ={"" , "QDropEvent*"};
5276 5749 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5277 5750 void* args[2] = {NULL, (void*)&arg__1};
5278 5751 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5279 5752 if (result) { Py_DECREF(result); }
5280 5753 Py_DECREF(obj);
5281 5754 return;
5755 } else {
5756 PyErr_Clear();
5282 5757 }
5283 5758 }
5284 5759 abstractBinFileWidget::dropEvent(arg__1);
5285 5760 }
5286 5761 void PythonQtShell_abstractBinFileWidget::enterEvent(QEvent* arg__1)
5287 5762 {
5288 if (_wrapper) {
5289 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
5290 PyErr_Clear();
5291 if (obj && !PythonQtSlotFunction_Check(obj)) {
5763 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5764 static PyObject* name = PyString_FromString("enterEvent");
5765 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5766 if (obj) {
5292 5767 static const char* argumentList[] ={"" , "QEvent*"};
5293 5768 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5294 5769 void* args[2] = {NULL, (void*)&arg__1};
5295 5770 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5296 5771 if (result) { Py_DECREF(result); }
5297 5772 Py_DECREF(obj);
5298 5773 return;
5774 } else {
5775 PyErr_Clear();
5299 5776 }
5300 5777 }
5301 5778 abstractBinFileWidget::enterEvent(arg__1);
5302 5779 }
5303 5780 bool PythonQtShell_abstractBinFileWidget::event(QEvent* arg__1)
5304 5781 {
5305 if (_wrapper) {
5306 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
5307 PyErr_Clear();
5308 if (obj && !PythonQtSlotFunction_Check(obj)) {
5782 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5783 static PyObject* name = PyString_FromString("event");
5784 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5785 if (obj) {
5309 5786 static const char* argumentList[] ={"bool" , "QEvent*"};
5310 5787 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5311 5788 bool returnValue;
5312 5789 void* args[2] = {NULL, (void*)&arg__1};
5313 5790 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5314 5791 if (result) {
5315 5792 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5316 5793 if (args[0]!=&returnValue) {
5317 5794 if (args[0]==NULL) {
5318 5795 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
5319 5796 } else {
5320 5797 returnValue = *((bool*)args[0]);
5321 5798 }
5322 5799 }
5323 5800 }
5324 5801 if (result) { Py_DECREF(result); }
5325 5802 Py_DECREF(obj);
5326 5803 return returnValue;
5804 } else {
5805 PyErr_Clear();
5327 5806 }
5328 5807 }
5329 5808 return abstractBinFileWidget::event(arg__1);
5330 5809 }
5331 5810 bool PythonQtShell_abstractBinFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
5332 5811 {
5333 if (_wrapper) {
5334 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
5335 PyErr_Clear();
5336 if (obj && !PythonQtSlotFunction_Check(obj)) {
5812 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5813 static PyObject* name = PyString_FromString("eventFilter");
5814 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5815 if (obj) {
5337 5816 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5338 5817 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5339 5818 bool returnValue;
5340 5819 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
5341 5820 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5342 5821 if (result) {
5343 5822 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5344 5823 if (args[0]!=&returnValue) {
5345 5824 if (args[0]==NULL) {
5346 5825 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
5347 5826 } else {
5348 5827 returnValue = *((bool*)args[0]);
5349 5828 }
5350 5829 }
5351 5830 }
5352 5831 if (result) { Py_DECREF(result); }
5353 5832 Py_DECREF(obj);
5354 5833 return returnValue;
5834 } else {
5835 PyErr_Clear();
5355 5836 }
5356 5837 }
5357 5838 return abstractBinFileWidget::eventFilter(arg__1, arg__2);
5358 5839 }
5359 5840 void PythonQtShell_abstractBinFileWidget::focusInEvent(QFocusEvent* arg__1)
5360 5841 {
5361 if (_wrapper) {
5362 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
5363 PyErr_Clear();
5364 if (obj && !PythonQtSlotFunction_Check(obj)) {
5842 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5843 static PyObject* name = PyString_FromString("focusInEvent");
5844 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5845 if (obj) {
5365 5846 static const char* argumentList[] ={"" , "QFocusEvent*"};
5366 5847 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5367 5848 void* args[2] = {NULL, (void*)&arg__1};
5368 5849 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5369 5850 if (result) { Py_DECREF(result); }
5370 5851 Py_DECREF(obj);
5371 5852 return;
5853 } else {
5854 PyErr_Clear();
5372 5855 }
5373 5856 }
5374 5857 abstractBinFileWidget::focusInEvent(arg__1);
5375 5858 }
5376 bool PythonQtShell_abstractBinFileWidget::focusNextPrevChild(bool next)
5377 {
5378 if (_wrapper) {
5379 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
5380 PyErr_Clear();
5381 if (obj && !PythonQtSlotFunction_Check(obj)) {
5859 bool PythonQtShell_abstractBinFileWidget::focusNextPrevChild(bool next0)
5860 {
5861 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5862 static PyObject* name = PyString_FromString("focusNextPrevChild");
5863 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5864 if (obj) {
5382 5865 static const char* argumentList[] ={"bool" , "bool"};
5383 5866 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5384 5867 bool returnValue;
5385 void* args[2] = {NULL, (void*)&next};
5868 void* args[2] = {NULL, (void*)&next0};
5386 5869 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5387 5870 if (result) {
5388 5871 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5389 5872 if (args[0]!=&returnValue) {
5390 5873 if (args[0]==NULL) {
5391 5874 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
5392 5875 } else {
5393 5876 returnValue = *((bool*)args[0]);
5394 5877 }
5395 5878 }
5396 5879 }
5397 5880 if (result) { Py_DECREF(result); }
5398 5881 Py_DECREF(obj);
5399 5882 return returnValue;
5400 }
5401 }
5402 return abstractBinFileWidget::focusNextPrevChild(next);
5883 } else {
5884 PyErr_Clear();
5885 }
5886 }
5887 return abstractBinFileWidget::focusNextPrevChild(next0);
5403 5888 }
5404 5889 void PythonQtShell_abstractBinFileWidget::focusOutEvent(QFocusEvent* arg__1)
5405 5890 {
5406 if (_wrapper) {
5407 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
5408 PyErr_Clear();
5409 if (obj && !PythonQtSlotFunction_Check(obj)) {
5891 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5892 static PyObject* name = PyString_FromString("focusOutEvent");
5893 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5894 if (obj) {
5410 5895 static const char* argumentList[] ={"" , "QFocusEvent*"};
5411 5896 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5412 5897 void* args[2] = {NULL, (void*)&arg__1};
5413 5898 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5414 5899 if (result) { Py_DECREF(result); }
5415 5900 Py_DECREF(obj);
5416 5901 return;
5902 } else {
5903 PyErr_Clear();
5417 5904 }
5418 5905 }
5419 5906 abstractBinFileWidget::focusOutEvent(arg__1);
5420 5907 }
5421 5908 bool PythonQtShell_abstractBinFileWidget::hasHeightForWidth() const
5422 5909 {
5423 if (_wrapper) {
5424 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
5425 PyErr_Clear();
5426 if (obj && !PythonQtSlotFunction_Check(obj)) {
5910 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5911 static PyObject* name = PyString_FromString("hasHeightForWidth");
5912 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5913 if (obj) {
5427 5914 static const char* argumentList[] ={"bool"};
5428 5915 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5429 5916 bool returnValue;
5430 5917 void* args[1] = {NULL};
5431 5918 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5432 5919 if (result) {
5433 5920 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5434 5921 if (args[0]!=&returnValue) {
5435 5922 if (args[0]==NULL) {
5436 5923 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
5437 5924 } else {
5438 5925 returnValue = *((bool*)args[0]);
5439 5926 }
5440 5927 }
5441 5928 }
5442 5929 if (result) { Py_DECREF(result); }
5443 5930 Py_DECREF(obj);
5444 5931 return returnValue;
5932 } else {
5933 PyErr_Clear();
5445 5934 }
5446 5935 }
5447 5936 return abstractBinFileWidget::hasHeightForWidth();
5448 5937 }
5449 5938 int PythonQtShell_abstractBinFileWidget::heightForWidth(int arg__1) const
5450 5939 {
5451 if (_wrapper) {
5452 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
5453 PyErr_Clear();
5454 if (obj && !PythonQtSlotFunction_Check(obj)) {
5940 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5941 static PyObject* name = PyString_FromString("heightForWidth");
5942 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5943 if (obj) {
5455 5944 static const char* argumentList[] ={"int" , "int"};
5456 5945 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5457 5946 int returnValue;
5458 5947 void* args[2] = {NULL, (void*)&arg__1};
5459 5948 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5460 5949 if (result) {
5461 5950 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5462 5951 if (args[0]!=&returnValue) {
5463 5952 if (args[0]==NULL) {
5464 5953 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
5465 5954 } else {
5466 5955 returnValue = *((int*)args[0]);
5467 5956 }
5468 5957 }
5469 5958 }
5470 5959 if (result) { Py_DECREF(result); }
5471 5960 Py_DECREF(obj);
5472 5961 return returnValue;
5962 } else {
5963 PyErr_Clear();
5473 5964 }
5474 5965 }
5475 5966 return abstractBinFileWidget::heightForWidth(arg__1);
5476 5967 }
5477 5968 void PythonQtShell_abstractBinFileWidget::hideEvent(QHideEvent* arg__1)
5478 5969 {
5479 if (_wrapper) {
5480 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
5481 PyErr_Clear();
5482 if (obj && !PythonQtSlotFunction_Check(obj)) {
5970 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5971 static PyObject* name = PyString_FromString("hideEvent");
5972 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5973 if (obj) {
5483 5974 static const char* argumentList[] ={"" , "QHideEvent*"};
5484 5975 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5485 5976 void* args[2] = {NULL, (void*)&arg__1};
5486 5977 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5487 5978 if (result) { Py_DECREF(result); }
5488 5979 Py_DECREF(obj);
5489 5980 return;
5981 } else {
5982 PyErr_Clear();
5490 5983 }
5491 5984 }
5492 5985 abstractBinFileWidget::hideEvent(arg__1);
5493 5986 }
5494 void PythonQtShell_abstractBinFileWidget::initPainter(QPainter* painter) const
5495 {
5496 if (_wrapper) {
5497 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
5498 PyErr_Clear();
5499 if (obj && !PythonQtSlotFunction_Check(obj)) {
5987 void PythonQtShell_abstractBinFileWidget::initPainter(QPainter* painter0) const
5988 {
5989 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5990 static PyObject* name = PyString_FromString("initPainter");
5991 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5992 if (obj) {
5500 5993 static const char* argumentList[] ={"" , "QPainter*"};
5501 5994 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5502 void* args[2] = {NULL, (void*)&painter};
5503 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5504 if (result) { Py_DECREF(result); }
5505 Py_DECREF(obj);
5506 return;
5507 }
5508 }
5509 abstractBinFileWidget::initPainter(painter);
5995 void* args[2] = {NULL, (void*)&painter0};
5996 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5997 if (result) { Py_DECREF(result); }
5998 Py_DECREF(obj);
5999 return;
6000 } else {
6001 PyErr_Clear();
6002 }
6003 }
6004 abstractBinFileWidget::initPainter(painter0);
5510 6005 }
5511 6006 void PythonQtShell_abstractBinFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
5512 6007 {
5513 if (_wrapper) {
5514 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
5515 PyErr_Clear();
5516 if (obj && !PythonQtSlotFunction_Check(obj)) {
6008 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6009 static PyObject* name = PyString_FromString("inputMethodEvent");
6010 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6011 if (obj) {
5517 6012 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
5518 6013 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5519 6014 void* args[2] = {NULL, (void*)&arg__1};
5520 6015 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5521 6016 if (result) { Py_DECREF(result); }
5522 6017 Py_DECREF(obj);
5523 6018 return;
6019 } else {
6020 PyErr_Clear();
5524 6021 }
5525 6022 }
5526 6023 abstractBinFileWidget::inputMethodEvent(arg__1);
5527 6024 }
5528 6025 QVariant PythonQtShell_abstractBinFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
5529 6026 {
5530 if (_wrapper) {
5531 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
5532 PyErr_Clear();
5533 if (obj && !PythonQtSlotFunction_Check(obj)) {
6027 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6028 static PyObject* name = PyString_FromString("inputMethodQuery");
6029 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6030 if (obj) {
5534 6031 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
5535 6032 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5536 6033 QVariant returnValue;
5537 6034 void* args[2] = {NULL, (void*)&arg__1};
5538 6035 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5539 6036 if (result) {
5540 6037 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5541 6038 if (args[0]!=&returnValue) {
5542 6039 if (args[0]==NULL) {
5543 6040 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
5544 6041 } else {
5545 6042 returnValue = *((QVariant*)args[0]);
5546 6043 }
5547 6044 }
5548 6045 }
5549 6046 if (result) { Py_DECREF(result); }
5550 6047 Py_DECREF(obj);
5551 6048 return returnValue;
6049 } else {
6050 PyErr_Clear();
5552 6051 }
5553 6052 }
5554 6053 return abstractBinFileWidget::inputMethodQuery(arg__1);
5555 6054 }
5556 6055 void PythonQtShell_abstractBinFileWidget::keyPressEvent(QKeyEvent* arg__1)
5557 6056 {
5558 if (_wrapper) {
5559 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
5560 PyErr_Clear();
5561 if (obj && !PythonQtSlotFunction_Check(obj)) {
6057 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6058 static PyObject* name = PyString_FromString("keyPressEvent");
6059 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6060 if (obj) {
5562 6061 static const char* argumentList[] ={"" , "QKeyEvent*"};
5563 6062 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5564 6063 void* args[2] = {NULL, (void*)&arg__1};
5565 6064 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5566 6065 if (result) { Py_DECREF(result); }
5567 6066 Py_DECREF(obj);
5568 6067 return;
6068 } else {
6069 PyErr_Clear();
5569 6070 }
5570 6071 }
5571 6072 abstractBinFileWidget::keyPressEvent(arg__1);
5572 6073 }
5573 6074 void PythonQtShell_abstractBinFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
5574 6075 {
5575 if (_wrapper) {
5576 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
5577 PyErr_Clear();
5578 if (obj && !PythonQtSlotFunction_Check(obj)) {
6076 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6077 static PyObject* name = PyString_FromString("keyReleaseEvent");
6078 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6079 if (obj) {
5579 6080 static const char* argumentList[] ={"" , "QKeyEvent*"};
5580 6081 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5581 6082 void* args[2] = {NULL, (void*)&arg__1};
5582 6083 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5583 6084 if (result) { Py_DECREF(result); }
5584 6085 Py_DECREF(obj);
5585 6086 return;
6087 } else {
6088 PyErr_Clear();
5586 6089 }
5587 6090 }
5588 6091 abstractBinFileWidget::keyReleaseEvent(arg__1);
5589 6092 }
5590 6093 void PythonQtShell_abstractBinFileWidget::leaveEvent(QEvent* arg__1)
5591 6094 {
5592 if (_wrapper) {
5593 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
5594 PyErr_Clear();
5595 if (obj && !PythonQtSlotFunction_Check(obj)) {
6095 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6096 static PyObject* name = PyString_FromString("leaveEvent");
6097 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6098 if (obj) {
5596 6099 static const char* argumentList[] ={"" , "QEvent*"};
5597 6100 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5598 6101 void* args[2] = {NULL, (void*)&arg__1};
5599 6102 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5600 6103 if (result) { Py_DECREF(result); }
5601 6104 Py_DECREF(obj);
5602 6105 return;
6106 } else {
6107 PyErr_Clear();
5603 6108 }
5604 6109 }
5605 6110 abstractBinFileWidget::leaveEvent(arg__1);
5606 6111 }
5607 6112 int PythonQtShell_abstractBinFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
5608 6113 {
5609 if (_wrapper) {
5610 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
5611 PyErr_Clear();
5612 if (obj && !PythonQtSlotFunction_Check(obj)) {
6114 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6115 static PyObject* name = PyString_FromString("metric");
6116 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6117 if (obj) {
5613 6118 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
5614 6119 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5615 6120 int returnValue;
5616 6121 void* args[2] = {NULL, (void*)&arg__1};
5617 6122 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5618 6123 if (result) {
5619 6124 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5620 6125 if (args[0]!=&returnValue) {
5621 6126 if (args[0]==NULL) {
5622 6127 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
5623 6128 } else {
5624 6129 returnValue = *((int*)args[0]);
5625 6130 }
5626 6131 }
5627 6132 }
5628 6133 if (result) { Py_DECREF(result); }
5629 6134 Py_DECREF(obj);
5630 6135 return returnValue;
6136 } else {
6137 PyErr_Clear();
5631 6138 }
5632 6139 }
5633 6140 return abstractBinFileWidget::metric(arg__1);
5634 6141 }
5635 6142 QSize PythonQtShell_abstractBinFileWidget::minimumSizeHint() const
5636 6143 {
5637 if (_wrapper) {
5638 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
5639 PyErr_Clear();
5640 if (obj && !PythonQtSlotFunction_Check(obj)) {
6144 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6145 static PyObject* name = PyString_FromString("getMinimumSizeHint");
6146 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6147 if (obj) {
5641 6148 static const char* argumentList[] ={"QSize"};
5642 6149 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5643 6150 QSize returnValue;
5644 6151 void* args[1] = {NULL};
5645 6152 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5646 6153 if (result) {
5647 6154 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5648 6155 if (args[0]!=&returnValue) {
5649 6156 if (args[0]==NULL) {
5650 6157 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
5651 6158 } else {
5652 6159 returnValue = *((QSize*)args[0]);
5653 6160 }
5654 6161 }
5655 6162 }
5656 6163 if (result) { Py_DECREF(result); }
5657 6164 Py_DECREF(obj);
5658 6165 return returnValue;
6166 } else {
6167 PyErr_Clear();
5659 6168 }
5660 6169 }
5661 6170 return abstractBinFileWidget::minimumSizeHint();
5662 6171 }
5663 6172 void PythonQtShell_abstractBinFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
5664 6173 {
5665 if (_wrapper) {
5666 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
5667 PyErr_Clear();
5668 if (obj && !PythonQtSlotFunction_Check(obj)) {
6174 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6175 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
6176 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6177 if (obj) {
5669 6178 static const char* argumentList[] ={"" , "QMouseEvent*"};
5670 6179 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5671 6180 void* args[2] = {NULL, (void*)&arg__1};
5672 6181 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5673 6182 if (result) { Py_DECREF(result); }
5674 6183 Py_DECREF(obj);
5675 6184 return;
6185 } else {
6186 PyErr_Clear();
5676 6187 }
5677 6188 }
5678 6189 abstractBinFileWidget::mouseDoubleClickEvent(arg__1);
5679 6190 }
5680 6191 void PythonQtShell_abstractBinFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
5681 6192 {
5682 if (_wrapper) {
5683 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
5684 PyErr_Clear();
5685 if (obj && !PythonQtSlotFunction_Check(obj)) {
6193 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6194 static PyObject* name = PyString_FromString("mouseMoveEvent");
6195 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6196 if (obj) {
5686 6197 static const char* argumentList[] ={"" , "QMouseEvent*"};
5687 6198 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5688 6199 void* args[2] = {NULL, (void*)&arg__1};
5689 6200 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5690 6201 if (result) { Py_DECREF(result); }
5691 6202 Py_DECREF(obj);
5692 6203 return;
6204 } else {
6205 PyErr_Clear();
5693 6206 }
5694 6207 }
5695 6208 abstractBinFileWidget::mouseMoveEvent(arg__1);
5696 6209 }
5697 6210 void PythonQtShell_abstractBinFileWidget::mousePressEvent(QMouseEvent* arg__1)
5698 6211 {
5699 if (_wrapper) {
5700 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
5701 PyErr_Clear();
5702 if (obj && !PythonQtSlotFunction_Check(obj)) {
6212 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6213 static PyObject* name = PyString_FromString("mousePressEvent");
6214 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6215 if (obj) {
5703 6216 static const char* argumentList[] ={"" , "QMouseEvent*"};
5704 6217 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5705 6218 void* args[2] = {NULL, (void*)&arg__1};
5706 6219 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5707 6220 if (result) { Py_DECREF(result); }
5708 6221 Py_DECREF(obj);
5709 6222 return;
6223 } else {
6224 PyErr_Clear();
5710 6225 }
5711 6226 }
5712 6227 abstractBinFileWidget::mousePressEvent(arg__1);
5713 6228 }
5714 6229 void PythonQtShell_abstractBinFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
5715 6230 {
5716 if (_wrapper) {
5717 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
5718 PyErr_Clear();
5719 if (obj && !PythonQtSlotFunction_Check(obj)) {
6231 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6232 static PyObject* name = PyString_FromString("mouseReleaseEvent");
6233 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6234 if (obj) {
5720 6235 static const char* argumentList[] ={"" , "QMouseEvent*"};
5721 6236 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5722 6237 void* args[2] = {NULL, (void*)&arg__1};
5723 6238 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5724 6239 if (result) { Py_DECREF(result); }
5725 6240 Py_DECREF(obj);
5726 6241 return;
6242 } else {
6243 PyErr_Clear();
5727 6244 }
5728 6245 }
5729 6246 abstractBinFileWidget::mouseReleaseEvent(arg__1);
5730 6247 }
5731 6248 void PythonQtShell_abstractBinFileWidget::moveEvent(QMoveEvent* arg__1)
5732 6249 {
5733 if (_wrapper) {
5734 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
5735 PyErr_Clear();
5736 if (obj && !PythonQtSlotFunction_Check(obj)) {
6250 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6251 static PyObject* name = PyString_FromString("moveEvent");
6252 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6253 if (obj) {
5737 6254 static const char* argumentList[] ={"" , "QMoveEvent*"};
5738 6255 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5739 6256 void* args[2] = {NULL, (void*)&arg__1};
5740 6257 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5741 6258 if (result) { Py_DECREF(result); }
5742 6259 Py_DECREF(obj);
5743 6260 return;
6261 } else {
6262 PyErr_Clear();
5744 6263 }
5745 6264 }
5746 6265 abstractBinFileWidget::moveEvent(arg__1);
5747 6266 }
5748 bool PythonQtShell_abstractBinFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result)
5749 {
5750 if (_wrapper) {
5751 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
5752 PyErr_Clear();
5753 if (obj && !PythonQtSlotFunction_Check(obj)) {
6267 bool PythonQtShell_abstractBinFileWidget::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
6268 {
6269 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6270 static PyObject* name = PyString_FromString("nativeEvent");
6271 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6272 if (obj) {
5754 6273 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
5755 6274 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
5756 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 6277 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5759 6278 if (result) {
5760 6279 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5761 6280 if (args[0]!=&returnValue) {
5762 6281 if (args[0]==NULL) {
5763 6282 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
5764 6283 } else {
5765 6284 returnValue = *((bool*)args[0]);
5766 6285 }
5767 6286 }
5768 6287 }
5769 6288 if (result) { Py_DECREF(result); }
5770 6289 Py_DECREF(obj);
5771 6290 return returnValue;
5772 }
5773 }
5774 return abstractBinFileWidget::nativeEvent(eventType, message, result);
6291 } else {
6292 PyErr_Clear();
6293 }
6294 }
6295 return abstractBinFileWidget::nativeEvent(eventType0, message1, result2);
5775 6296 }
5776 6297 QPaintEngine* PythonQtShell_abstractBinFileWidget::paintEngine() const
5777 6298 {
5778 if (_wrapper) {
5779 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
5780 PyErr_Clear();
5781 if (obj && !PythonQtSlotFunction_Check(obj)) {
6299 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6300 static PyObject* name = PyString_FromString("paintEngine");
6301 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6302 if (obj) {
5782 6303 static const char* argumentList[] ={"QPaintEngine*"};
5783 6304 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5784 6305 QPaintEngine* returnValue;
5785 6306 void* args[1] = {NULL};
5786 6307 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5787 6308 if (result) {
5788 6309 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5789 6310 if (args[0]!=&returnValue) {
5790 6311 if (args[0]==NULL) {
5791 6312 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
5792 6313 } else {
5793 6314 returnValue = *((QPaintEngine**)args[0]);
5794 6315 }
5795 6316 }
5796 6317 }
5797 6318 if (result) { Py_DECREF(result); }
5798 6319 Py_DECREF(obj);
5799 6320 return returnValue;
6321 } else {
6322 PyErr_Clear();
5800 6323 }
5801 6324 }
5802 6325 return abstractBinFileWidget::paintEngine();
5803 6326 }
5804 6327 void PythonQtShell_abstractBinFileWidget::paintEvent(QPaintEvent* arg__1)
5805 6328 {
5806 if (_wrapper) {
5807 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
5808 PyErr_Clear();
5809 if (obj && !PythonQtSlotFunction_Check(obj)) {
6329 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6330 static PyObject* name = PyString_FromString("paintEvent");
6331 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6332 if (obj) {
5810 6333 static const char* argumentList[] ={"" , "QPaintEvent*"};
5811 6334 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5812 6335 void* args[2] = {NULL, (void*)&arg__1};
5813 6336 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5814 6337 if (result) { Py_DECREF(result); }
5815 6338 Py_DECREF(obj);
5816 6339 return;
6340 } else {
6341 PyErr_Clear();
5817 6342 }
5818 6343 }
5819 6344 abstractBinFileWidget::paintEvent(arg__1);
5820 6345 }
5821 QPaintDevice* PythonQtShell_abstractBinFileWidget::redirected(QPoint* offset) const
5822 {
5823 if (_wrapper) {
5824 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
5825 PyErr_Clear();
5826 if (obj && !PythonQtSlotFunction_Check(obj)) {
6346 QPaintDevice* PythonQtShell_abstractBinFileWidget::redirected(QPoint* offset0) const
6347 {
6348 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6349 static PyObject* name = PyString_FromString("redirected");
6350 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6351 if (obj) {
5827 6352 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
5828 6353 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5829 6354 QPaintDevice* returnValue;
5830 void* args[2] = {NULL, (void*)&offset};
6355 void* args[2] = {NULL, (void*)&offset0};
5831 6356 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5832 6357 if (result) {
5833 6358 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5834 6359 if (args[0]!=&returnValue) {
5835 6360 if (args[0]==NULL) {
5836 6361 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
5837 6362 } else {
5838 6363 returnValue = *((QPaintDevice**)args[0]);
5839 6364 }
5840 6365 }
5841 6366 }
5842 6367 if (result) { Py_DECREF(result); }
5843 6368 Py_DECREF(obj);
5844 6369 return returnValue;
5845 }
5846 }
5847 return abstractBinFileWidget::redirected(offset);
6370 } else {
6371 PyErr_Clear();
6372 }
6373 }
6374 return abstractBinFileWidget::redirected(offset0);
5848 6375 }
5849 6376 void PythonQtShell_abstractBinFileWidget::reloadFile()
5850 6377 {
5851 if (_wrapper) {
5852 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
5853 PyErr_Clear();
5854 if (obj && !PythonQtSlotFunction_Check(obj)) {
6378 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6379 static PyObject* name = PyString_FromString("reloadFile");
6380 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6381 if (obj) {
5855 6382 static const char* argumentList[] ={""};
5856 6383 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5857 6384 void* args[1] = {NULL};
5858 6385 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5859 6386 if (result) { Py_DECREF(result); }
5860 6387 Py_DECREF(obj);
5861 6388 return;
6389 } else {
6390 PyErr_Clear();
5862 6391 }
5863 6392 }
5864 6393
5865 6394 }
5866 6395 void PythonQtShell_abstractBinFileWidget::resizeEvent(QResizeEvent* arg__1)
5867 6396 {
5868 if (_wrapper) {
5869 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
5870 PyErr_Clear();
5871 if (obj && !PythonQtSlotFunction_Check(obj)) {
6397 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6398 static PyObject* name = PyString_FromString("resizeEvent");
6399 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6400 if (obj) {
5872 6401 static const char* argumentList[] ={"" , "QResizeEvent*"};
5873 6402 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5874 6403 void* args[2] = {NULL, (void*)&arg__1};
5875 6404 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5876 6405 if (result) { Py_DECREF(result); }
5877 6406 Py_DECREF(obj);
5878 6407 return;
6408 } else {
6409 PyErr_Clear();
5879 6410 }
5880 6411 }
5881 6412 abstractBinFileWidget::resizeEvent(arg__1);
5882 6413 }
5883 void PythonQtShell_abstractBinFileWidget::setFile(abstractBinFile* file)
5884 {
5885 if (_wrapper) {
5886 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
5887 PyErr_Clear();
5888 if (obj && !PythonQtSlotFunction_Check(obj)) {
6414 void PythonQtShell_abstractBinFileWidget::setFile(abstractBinFile* file0)
6415 {
6416 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6417 static PyObject* name = PyString_FromString("setFile");
6418 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6419 if (obj) {
5889 6420 static const char* argumentList[] ={"" , "abstractBinFile*"};
5890 6421 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5891 void* args[2] = {NULL, (void*)&file};
5892 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5893 if (result) { Py_DECREF(result); }
5894 Py_DECREF(obj);
5895 return;
6422 void* args[2] = {NULL, (void*)&file0};
6423 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6424 if (result) { Py_DECREF(result); }
6425 Py_DECREF(obj);
6426 return;
6427 } else {
6428 PyErr_Clear();
5896 6429 }
5897 6430 }
5898 6431
5899 6432 }
5900 6433 QPainter* PythonQtShell_abstractBinFileWidget::sharedPainter() const
5901 6434 {
5902 if (_wrapper) {
5903 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
5904 PyErr_Clear();
5905 if (obj && !PythonQtSlotFunction_Check(obj)) {
6435 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6436 static PyObject* name = PyString_FromString("sharedPainter");
6437 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6438 if (obj) {
5906 6439 static const char* argumentList[] ={"QPainter*"};
5907 6440 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5908 6441 QPainter* returnValue;
5909 6442 void* args[1] = {NULL};
5910 6443 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5911 6444 if (result) {
5912 6445 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5913 6446 if (args[0]!=&returnValue) {
5914 6447 if (args[0]==NULL) {
5915 6448 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
5916 6449 } else {
5917 6450 returnValue = *((QPainter**)args[0]);
5918 6451 }
5919 6452 }
5920 6453 }
5921 6454 if (result) { Py_DECREF(result); }
5922 6455 Py_DECREF(obj);
5923 6456 return returnValue;
6457 } else {
6458 PyErr_Clear();
5924 6459 }
5925 6460 }
5926 6461 return abstractBinFileWidget::sharedPainter();
5927 6462 }
5928 6463 void PythonQtShell_abstractBinFileWidget::showEvent(QShowEvent* arg__1)
5929 6464 {
5930 if (_wrapper) {
5931 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
5932 PyErr_Clear();
5933 if (obj && !PythonQtSlotFunction_Check(obj)) {
6465 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6466 static PyObject* name = PyString_FromString("showEvent");
6467 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6468 if (obj) {
5934 6469 static const char* argumentList[] ={"" , "QShowEvent*"};
5935 6470 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5936 6471 void* args[2] = {NULL, (void*)&arg__1};
5937 6472 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5938 6473 if (result) { Py_DECREF(result); }
5939 6474 Py_DECREF(obj);
5940 6475 return;
6476 } else {
6477 PyErr_Clear();
5941 6478 }
5942 6479 }
5943 6480 abstractBinFileWidget::showEvent(arg__1);
5944 6481 }
5945 6482 QSize PythonQtShell_abstractBinFileWidget::sizeHint() const
5946 6483 {
5947 if (_wrapper) {
5948 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
5949 PyErr_Clear();
5950 if (obj && !PythonQtSlotFunction_Check(obj)) {
6484 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6485 static PyObject* name = PyString_FromString("getSizeHint");
6486 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6487 if (obj) {
5951 6488 static const char* argumentList[] ={"QSize"};
5952 6489 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5953 6490 QSize returnValue;
5954 6491 void* args[1] = {NULL};
5955 6492 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5956 6493 if (result) {
5957 6494 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5958 6495 if (args[0]!=&returnValue) {
5959 6496 if (args[0]==NULL) {
5960 6497 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
5961 6498 } else {
5962 6499 returnValue = *((QSize*)args[0]);
5963 6500 }
5964 6501 }
5965 6502 }
5966 6503 if (result) { Py_DECREF(result); }
5967 6504 Py_DECREF(obj);
5968 6505 return returnValue;
6506 } else {
6507 PyErr_Clear();
5969 6508 }
5970 6509 }
5971 6510 return abstractBinFileWidget::sizeHint();
5972 6511 }
5973 6512 void PythonQtShell_abstractBinFileWidget::tabletEvent(QTabletEvent* arg__1)
5974 6513 {
5975 if (_wrapper) {
5976 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
5977 PyErr_Clear();
5978 if (obj && !PythonQtSlotFunction_Check(obj)) {
6514 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6515 static PyObject* name = PyString_FromString("tabletEvent");
6516 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6517 if (obj) {
5979 6518 static const char* argumentList[] ={"" , "QTabletEvent*"};
5980 6519 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5981 6520 void* args[2] = {NULL, (void*)&arg__1};
5982 6521 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5983 6522 if (result) { Py_DECREF(result); }
5984 6523 Py_DECREF(obj);
5985 6524 return;
6525 } else {
6526 PyErr_Clear();
5986 6527 }
5987 6528 }
5988 6529 abstractBinFileWidget::tabletEvent(arg__1);
5989 6530 }
5990 6531 void PythonQtShell_abstractBinFileWidget::timerEvent(QTimerEvent* arg__1)
5991 6532 {
5992 if (_wrapper) {
5993 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
5994 PyErr_Clear();
5995 if (obj && !PythonQtSlotFunction_Check(obj)) {
6533 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6534 static PyObject* name = PyString_FromString("timerEvent");
6535 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6536 if (obj) {
5996 6537 static const char* argumentList[] ={"" , "QTimerEvent*"};
5997 6538 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5998 6539 void* args[2] = {NULL, (void*)&arg__1};
5999 6540 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6000 6541 if (result) { Py_DECREF(result); }
6001 6542 Py_DECREF(obj);
6002 6543 return;
6544 } else {
6545 PyErr_Clear();
6003 6546 }
6004 6547 }
6005 6548 abstractBinFileWidget::timerEvent(arg__1);
6006 6549 }
6007 6550 void PythonQtShell_abstractBinFileWidget::wheelEvent(QWheelEvent* arg__1)
6008 6551 {
6009 if (_wrapper) {
6010 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
6011 PyErr_Clear();
6012 if (obj && !PythonQtSlotFunction_Check(obj)) {
6552 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6553 static PyObject* name = PyString_FromString("wheelEvent");
6554 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6555 if (obj) {
6013 6556 static const char* argumentList[] ={"" , "QWheelEvent*"};
6014 6557 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6015 6558 void* args[2] = {NULL, (void*)&arg__1};
6016 6559 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6017 6560 if (result) { Py_DECREF(result); }
6018 6561 Py_DECREF(obj);
6019 6562 return;
6563 } else {
6564 PyErr_Clear();
6020 6565 }
6021 6566 }
6022 6567 abstractBinFileWidget::wheelEvent(arg__1);
6023 6568 }
6024 6569 abstractBinFileWidget* PythonQtWrapper_abstractBinFileWidget::new_abstractBinFileWidget(QWidget* parent)
6025 6570 {
6026 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 6585 PythonQtShell_binaryFile::~PythonQtShell_binaryFile() {
6031 6586 PythonQtPrivate* priv = PythonQt::priv();
6032 6587 if (priv) { priv->shellClassDeleted(this); }
6033 6588 }
6034 6589 int PythonQtShell_binaryFile::closeFile()
6035 6590 {
6036 if (_wrapper) {
6037 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
6038 PyErr_Clear();
6039 if (obj && !PythonQtSlotFunction_Check(obj)) {
6591 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6592 static PyObject* name = PyString_FromString("closeFile");
6593 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6594 if (obj) {
6040 6595 static const char* argumentList[] ={"int"};
6041 6596 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6042 6597 int returnValue;
6043 6598 void* args[1] = {NULL};
6044 6599 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6045 6600 if (result) {
6046 6601 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6047 6602 if (args[0]!=&returnValue) {
6048 6603 if (args[0]==NULL) {
6049 6604 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
6050 6605 } else {
6051 6606 returnValue = *((int*)args[0]);
6052 6607 }
6053 6608 }
6054 6609 }
6055 6610 if (result) { Py_DECREF(result); }
6056 6611 Py_DECREF(obj);
6057 6612 return returnValue;
6613 } else {
6614 PyErr_Clear();
6058 6615 }
6059 6616 }
6060 6617 return binaryFile::closeFile();
6061 6618 }
6062 6619 QList<codeFragment* > PythonQtShell_binaryFile::getFragments()
6063 6620 {
6064 if (_wrapper) {
6065 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
6066 PyErr_Clear();
6067 if (obj && !PythonQtSlotFunction_Check(obj)) {
6621 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6622 static PyObject* name = PyString_FromString("getFragments");
6623 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6624 if (obj) {
6068 6625 static const char* argumentList[] ={"QList<codeFragment* >"};
6069 6626 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6070 6627 QList<codeFragment* > returnValue;
6071 6628 void* args[1] = {NULL};
6072 6629 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6073 6630 if (result) {
6074 6631 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6075 6632 if (args[0]!=&returnValue) {
6076 6633 if (args[0]==NULL) {
6077 6634 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
6078 6635 } else {
6079 6636 returnValue = *((QList<codeFragment* >*)args[0]);
6080 6637 }
6081 6638 }
6082 6639 }
6083 6640 if (result) { Py_DECREF(result); }
6084 6641 Py_DECREF(obj);
6085 6642 return returnValue;
6643 } else {
6644 PyErr_Clear();
6086 6645 }
6087 6646 }
6088 6647 return binaryFile::getFragments();
6089 6648 }
6090 6649 bool PythonQtShell_binaryFile::isopened()
6091 6650 {
6092 if (_wrapper) {
6093 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
6094 PyErr_Clear();
6095 if (obj && !PythonQtSlotFunction_Check(obj)) {
6651 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6652 static PyObject* name = PyString_FromString("isopened");
6653 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6654 if (obj) {
6096 6655 static const char* argumentList[] ={"bool"};
6097 6656 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6098 6657 bool returnValue;
6099 6658 void* args[1] = {NULL};
6100 6659 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6101 6660 if (result) {
6102 6661 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6103 6662 if (args[0]!=&returnValue) {
6104 6663 if (args[0]==NULL) {
6105 6664 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
6106 6665 } else {
6107 6666 returnValue = *((bool*)args[0]);
6108 6667 }
6109 6668 }
6110 6669 }
6111 6670 if (result) { Py_DECREF(result); }
6112 6671 Py_DECREF(obj);
6113 6672 return returnValue;
6673 } else {
6674 PyErr_Clear();
6114 6675 }
6115 6676 }
6116 6677 return binaryFile::isopened();
6117 6678 }
6118 bool PythonQtShell_binaryFile::openFile(const QString& File)
6119 {
6120 if (_wrapper) {
6121 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
6122 PyErr_Clear();
6123 if (obj && !PythonQtSlotFunction_Check(obj)) {
6679 bool PythonQtShell_binaryFile::openFile(const QString& File0)
6680 {
6681 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6682 static PyObject* name = PyString_FromString("openFile");
6683 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6684 if (obj) {
6124 6685 static const char* argumentList[] ={"bool" , "const QString&"};
6125 6686 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6126 6687 bool returnValue;
6127 void* args[2] = {NULL, (void*)&File};
6688 void* args[2] = {NULL, (void*)&File0};
6128 6689 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6129 6690 if (result) {
6130 6691 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6131 6692 if (args[0]!=&returnValue) {
6132 6693 if (args[0]==NULL) {
6133 6694 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
6134 6695 } else {
6135 6696 returnValue = *((bool*)args[0]);
6136 6697 }
6137 6698 }
6138 6699 }
6139 6700 if (result) { Py_DECREF(result); }
6140 6701 Py_DECREF(obj);
6141 6702 return returnValue;
6142 }
6143 }
6144 return binaryFile::openFile(File);
6145 }
6146 bool PythonQtShell_binaryFile::toBinary(const QString& fileName)
6147 {
6148 if (_wrapper) {
6149 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
6150 PyErr_Clear();
6151 if (obj && !PythonQtSlotFunction_Check(obj)) {
6703 } else {
6704 PyErr_Clear();
6705 }
6706 }
6707 return binaryFile::openFile(File0);
6708 }
6709 bool PythonQtShell_binaryFile::toBinary(const QString& fileName0)
6710 {
6711 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6712 static PyObject* name = PyString_FromString("toBinary");
6713 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6714 if (obj) {
6152 6715 static const char* argumentList[] ={"bool" , "const QString&"};
6153 6716 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6154 6717 bool returnValue;
6155 void* args[2] = {NULL, (void*)&fileName};
6718 void* args[2] = {NULL, (void*)&fileName0};
6156 6719 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6157 6720 if (result) {
6158 6721 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6159 6722 if (args[0]!=&returnValue) {
6160 6723 if (args[0]==NULL) {
6161 6724 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
6162 6725 } else {
6163 6726 returnValue = *((bool*)args[0]);
6164 6727 }
6165 6728 }
6166 6729 }
6167 6730 if (result) { Py_DECREF(result); }
6168 6731 Py_DECREF(obj);
6169 6732 return returnValue;
6170 }
6171 }
6172 return binaryFile::toBinary(fileName);
6173 }
6174 bool PythonQtShell_binaryFile::toSrec(const QString& fileName)
6175 {
6176 if (_wrapper) {
6177 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
6178 PyErr_Clear();
6179 if (obj && !PythonQtSlotFunction_Check(obj)) {
6733 } else {
6734 PyErr_Clear();
6735 }
6736 }
6737 return binaryFile::toBinary(fileName0);
6738 }
6739 bool PythonQtShell_binaryFile::toSrec(const QString& fileName0)
6740 {
6741 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6742 static PyObject* name = PyString_FromString("toSrec");
6743 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6744 if (obj) {
6180 6745 static const char* argumentList[] ={"bool" , "const QString&"};
6181 6746 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6182 6747 bool returnValue;
6183 void* args[2] = {NULL, (void*)&fileName};
6748 void* args[2] = {NULL, (void*)&fileName0};
6184 6749 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6185 6750 if (result) {
6186 6751 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6187 6752 if (args[0]!=&returnValue) {
6188 6753 if (args[0]==NULL) {
6189 6754 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
6190 6755 } else {
6191 6756 returnValue = *((bool*)args[0]);
6192 6757 }
6193 6758 }
6194 6759 }
6195 6760 if (result) { Py_DECREF(result); }
6196 6761 Py_DECREF(obj);
6197 6762 return returnValue;
6198 }
6199 }
6200 return binaryFile::toSrec(fileName);
6763 } else {
6764 PyErr_Clear();
6765 }
6766 }
6767 return binaryFile::toSrec(fileName0);
6201 6768 }
6202 6769 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile()
6203 6770 {
6204 6771 return new PythonQtShell_binaryFile(); }
6205 6772
6206 6773 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile(const QString& File)
6207 6774 {
6208 6775 return new PythonQtShell_binaryFile(File); }
6209 6776
6210 6777 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile(const QStringList& Files)
6211 6778 {
6212 6779 return new PythonQtShell_binaryFile(Files); }
6213 6780
6214 6781 int PythonQtWrapper_binaryFile::closeFile(binaryFile* theWrappedObject)
6215 6782 {
6216 6783 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_closeFile());
6217 6784 }
6218 6785
6219 6786 codeFragment* PythonQtWrapper_binaryFile::getFragment(binaryFile* theWrappedObject, int index)
6220 6787 {
6221 6788 return ( theWrappedObject->getFragment(index));
6222 6789 }
6223 6790
6224 6791 int PythonQtWrapper_binaryFile::getFragmentAddress(binaryFile* theWrappedObject, int index)
6225 6792 {
6226 6793 return ( theWrappedObject->getFragmentAddress(index));
6227 6794 }
6228 6795
6229 6796 bool PythonQtWrapper_binaryFile::getFragmentData(binaryFile* theWrappedObject, int index, char** buffer)
6230 6797 {
6231 6798 return ( theWrappedObject->getFragmentData(index, buffer));
6232 6799 }
6233 6800
6234 6801 QString PythonQtWrapper_binaryFile::getFragmentHeader(binaryFile* theWrappedObject, int index)
6235 6802 {
6236 6803 return ( theWrappedObject->getFragmentHeader(index));
6237 6804 }
6238 6805
6239 6806 int PythonQtWrapper_binaryFile::getFragmentSize(binaryFile* theWrappedObject, int index)
6240 6807 {
6241 6808 return ( theWrappedObject->getFragmentSize(index));
6242 6809 }
6243 6810
6244 6811 QList<codeFragment* > PythonQtWrapper_binaryFile::getFragments(binaryFile* theWrappedObject)
6245 6812 {
6246 6813 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_getFragments());
6247 6814 }
6248 6815
6249 6816 int PythonQtWrapper_binaryFile::getFragmentsCount(binaryFile* theWrappedObject)
6250 6817 {
6251 6818 return ( theWrappedObject->getFragmentsCount());
6252 6819 }
6253 6820
6254 6821 bool PythonQtWrapper_binaryFile::isopened(binaryFile* theWrappedObject)
6255 6822 {
6256 6823 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_isopened());
6257 6824 }
6258 6825
6259 6826 bool PythonQtWrapper_binaryFile::openFile(binaryFile* theWrappedObject, const QString& File)
6260 6827 {
6261 6828 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_openFile(File));
6262 6829 }
6263 6830
6264 6831 bool PythonQtWrapper_binaryFile::openFiles(binaryFile* theWrappedObject, const QStringList& Files)
6265 6832 {
6266 6833 return ( theWrappedObject->openFiles(Files));
6267 6834 }
6268 6835
6269 6836 bool PythonQtWrapper_binaryFile::static_binaryFile_toBinary(QList<codeFragment* > fragments, const QString& File)
6270 6837 {
6271 6838 return (binaryFile::toBinary(fragments, File));
6272 6839 }
6273 6840
6274 6841 bool PythonQtWrapper_binaryFile::toBinary(binaryFile* theWrappedObject, const QString& fileName)
6275 6842 {
6276 6843 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_toBinary(fileName));
6277 6844 }
6278 6845
6279 6846 bool PythonQtWrapper_binaryFile::toSrec(binaryFile* theWrappedObject, const QString& fileName)
6280 6847 {
6281 6848 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_toSrec(fileName));
6282 6849 }
6283 6850
6284 6851
6285 6852
6286 6853 PythonQtShell_binaryFileWidget::~PythonQtShell_binaryFileWidget() {
6287 6854 PythonQtPrivate* priv = PythonQt::priv();
6288 6855 if (priv) { priv->shellClassDeleted(this); }
6289 6856 }
6290 6857 void PythonQtShell_binaryFileWidget::reloadFile()
6291 6858 {
6292 if (_wrapper) {
6293 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
6294 PyErr_Clear();
6295 if (obj && !PythonQtSlotFunction_Check(obj)) {
6859 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6860 static PyObject* name = PyString_FromString("reloadFile");
6861 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6862 if (obj) {
6296 6863 static const char* argumentList[] ={""};
6297 6864 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6298 6865 void* args[1] = {NULL};
6299 6866 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6300 6867 if (result) { Py_DECREF(result); }
6301 6868 Py_DECREF(obj);
6302 6869 return;
6870 } else {
6871 PyErr_Clear();
6303 6872 }
6304 6873 }
6305 6874 binaryFileWidget::reloadFile();
6306 6875 }
6307 void PythonQtShell_binaryFileWidget::setFile(abstractBinFile* file)
6308 {
6309 if (_wrapper) {
6310 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
6311 PyErr_Clear();
6312 if (obj && !PythonQtSlotFunction_Check(obj)) {
6876 void PythonQtShell_binaryFileWidget::setFile(abstractBinFile* file0)
6877 {
6878 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6879 static PyObject* name = PyString_FromString("setFile");
6880 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6881 if (obj) {
6313 6882 static const char* argumentList[] ={"" , "abstractBinFile*"};
6314 6883 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6315 void* args[2] = {NULL, (void*)&file};
6316 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6317 if (result) { Py_DECREF(result); }
6318 Py_DECREF(obj);
6319 return;
6320 }
6321 }
6322 binaryFileWidget::setFile(file);
6884 void* args[2] = {NULL, (void*)&file0};
6885 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6886 if (result) { Py_DECREF(result); }
6887 Py_DECREF(obj);
6888 return;
6889 } else {
6890 PyErr_Clear();
6891 }
6892 }
6893 binaryFileWidget::setFile(file0);
6323 6894 }
6324 6895 binaryFileWidget* PythonQtWrapper_binaryFileWidget::new_binaryFileWidget(QWidget* parent)
6325 6896 {
6326 6897 return new PythonQtShell_binaryFileWidget(parent); }
6327 6898
6328 6899 void PythonQtWrapper_binaryFileWidget::reloadFile(binaryFileWidget* theWrappedObject)
6329 6900 {
6330 6901 ( ((PythonQtPublicPromoter_binaryFileWidget*)theWrappedObject)->promoted_reloadFile());
6331 6902 }
6332 6903
6333 6904 void PythonQtWrapper_binaryFileWidget::setFile(binaryFileWidget* theWrappedObject, abstractBinFile* file)
6334 6905 {
6335 6906 ( ((PythonQtPublicPromoter_binaryFileWidget*)theWrappedObject)->promoted_setFile(file));
6336 6907 }
6337 6908
6338 6909
6339 6910
6340 6911 PythonQtShell_codeFragment::~PythonQtShell_codeFragment() {
6341 6912 PythonQtPrivate* priv = PythonQt::priv();
6342 6913 if (priv) { priv->shellClassDeleted(this); }
6343 6914 }
6344 6915 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment()
6345 6916 {
6346 6917 return new PythonQtShell_codeFragment(); }
6347 6918
6348 6919 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment(char* data, quint64 size, quint64 address)
6349 6920 {
6350 6921 return new PythonQtShell_codeFragment(data, size, address); }
6351 6922
6352 6923
6353 6924
6354 6925 PythonQtShell_elfFileWidget::~PythonQtShell_elfFileWidget() {
6355 6926 PythonQtPrivate* priv = PythonQt::priv();
6356 6927 if (priv) { priv->shellClassDeleted(this); }
6357 6928 }
6358 6929 void PythonQtShell_elfFileWidget::reloadFile()
6359 6930 {
6360 if (_wrapper) {
6361 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
6362 PyErr_Clear();
6363 if (obj && !PythonQtSlotFunction_Check(obj)) {
6931 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6932 static PyObject* name = PyString_FromString("reloadFile");
6933 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6934 if (obj) {
6364 6935 static const char* argumentList[] ={""};
6365 6936 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6366 6937 void* args[1] = {NULL};
6367 6938 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6368 6939 if (result) { Py_DECREF(result); }
6369 6940 Py_DECREF(obj);
6370 6941 return;
6942 } else {
6943 PyErr_Clear();
6371 6944 }
6372 6945 }
6373 6946 elfFileWidget::reloadFile();
6374 6947 }
6375 void PythonQtShell_elfFileWidget::setFile(abstractBinFile* file)
6376 {
6377 if (_wrapper) {
6378 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
6379 PyErr_Clear();
6380 if (obj && !PythonQtSlotFunction_Check(obj)) {
6948 void PythonQtShell_elfFileWidget::setFile(abstractBinFile* file0)
6949 {
6950 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6951 static PyObject* name = PyString_FromString("setFile");
6952 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6953 if (obj) {
6381 6954 static const char* argumentList[] ={"" , "abstractBinFile*"};
6382 6955 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6383 void* args[2] = {NULL, (void*)&file};
6384 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6385 if (result) { Py_DECREF(result); }
6386 Py_DECREF(obj);
6387 return;
6388 }
6389 }
6390 elfFileWidget::setFile(file);
6956 void* args[2] = {NULL, (void*)&file0};
6957 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6958 if (result) { Py_DECREF(result); }
6959 Py_DECREF(obj);
6960 return;
6961 } else {
6962 PyErr_Clear();
6963 }
6964 }
6965 elfFileWidget::setFile(file0);
6391 6966 }
6392 6967 elfFileWidget* PythonQtWrapper_elfFileWidget::new_elfFileWidget(QWidget* parent)
6393 6968 {
6394 6969 return new PythonQtShell_elfFileWidget(parent); }
6395 6970
6396 6971 void PythonQtWrapper_elfFileWidget::reloadFile(elfFileWidget* theWrappedObject)
6397 6972 {
6398 6973 ( ((PythonQtPublicPromoter_elfFileWidget*)theWrappedObject)->promoted_reloadFile());
6399 6974 }
6400 6975
6401 6976 void PythonQtWrapper_elfFileWidget::setFile(elfFileWidget* theWrappedObject, abstractBinFile* file)
6402 6977 {
6403 6978 ( ((PythonQtPublicPromoter_elfFileWidget*)theWrappedObject)->promoted_setFile(file));
6404 6979 }
6405 6980
6406 6981
6407 6982
6408 6983 PythonQtShell_elfInfoWdgt::~PythonQtShell_elfInfoWdgt() {
6409 6984 PythonQtPrivate* priv = PythonQt::priv();
6410 6985 if (priv) { priv->shellClassDeleted(this); }
6411 6986 }
6412 6987 void PythonQtShell_elfInfoWdgt::actionEvent(QActionEvent* arg__1)
6413 6988 {
6414 if (_wrapper) {
6415 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
6416 PyErr_Clear();
6417 if (obj && !PythonQtSlotFunction_Check(obj)) {
6989 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6990 static PyObject* name = PyString_FromString("actionEvent");
6991 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6992 if (obj) {
6418 6993 static const char* argumentList[] ={"" , "QActionEvent*"};
6419 6994 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6420 6995 void* args[2] = {NULL, (void*)&arg__1};
6421 6996 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6422 6997 if (result) { Py_DECREF(result); }
6423 6998 Py_DECREF(obj);
6424 6999 return;
7000 } else {
7001 PyErr_Clear();
6425 7002 }
6426 7003 }
6427 7004 elfInfoWdgt::actionEvent(arg__1);
6428 7005 }
6429 7006 void PythonQtShell_elfInfoWdgt::changeEvent(QEvent* arg__1)
6430 7007 {
6431 if (_wrapper) {
6432 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
6433 PyErr_Clear();
6434 if (obj && !PythonQtSlotFunction_Check(obj)) {
7008 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7009 static PyObject* name = PyString_FromString("changeEvent");
7010 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7011 if (obj) {
6435 7012 static const char* argumentList[] ={"" , "QEvent*"};
6436 7013 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6437 7014 void* args[2] = {NULL, (void*)&arg__1};
6438 7015 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6439 7016 if (result) { Py_DECREF(result); }
6440 7017 Py_DECREF(obj);
6441 7018 return;
7019 } else {
7020 PyErr_Clear();
6442 7021 }
6443 7022 }
6444 7023 elfInfoWdgt::changeEvent(arg__1);
6445 7024 }
6446 7025 void PythonQtShell_elfInfoWdgt::childEvent(QChildEvent* arg__1)
6447 7026 {
6448 if (_wrapper) {
6449 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
6450 PyErr_Clear();
6451 if (obj && !PythonQtSlotFunction_Check(obj)) {
7027 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7028 static PyObject* name = PyString_FromString("childEvent");
7029 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7030 if (obj) {
6452 7031 static const char* argumentList[] ={"" , "QChildEvent*"};
6453 7032 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6454 7033 void* args[2] = {NULL, (void*)&arg__1};
6455 7034 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6456 7035 if (result) { Py_DECREF(result); }
6457 7036 Py_DECREF(obj);
6458 7037 return;
7038 } else {
7039 PyErr_Clear();
6459 7040 }
6460 7041 }
6461 7042 elfInfoWdgt::childEvent(arg__1);
6462 7043 }
6463 7044 void PythonQtShell_elfInfoWdgt::closeEvent(QCloseEvent* arg__1)
6464 7045 {
6465 if (_wrapper) {
6466 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
6467 PyErr_Clear();
6468 if (obj && !PythonQtSlotFunction_Check(obj)) {
7046 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7047 static PyObject* name = PyString_FromString("closeEvent");
7048 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7049 if (obj) {
6469 7050 static const char* argumentList[] ={"" , "QCloseEvent*"};
6470 7051 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6471 7052 void* args[2] = {NULL, (void*)&arg__1};
6472 7053 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6473 7054 if (result) { Py_DECREF(result); }
6474 7055 Py_DECREF(obj);
6475 7056 return;
7057 } else {
7058 PyErr_Clear();
6476 7059 }
6477 7060 }
6478 7061 elfInfoWdgt::closeEvent(arg__1);
6479 7062 }
6480 7063 void PythonQtShell_elfInfoWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
6481 7064 {
6482 if (_wrapper) {
6483 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
6484 PyErr_Clear();
6485 if (obj && !PythonQtSlotFunction_Check(obj)) {
7065 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7066 static PyObject* name = PyString_FromString("contextMenuEvent");
7067 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7068 if (obj) {
6486 7069 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
6487 7070 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6488 7071 void* args[2] = {NULL, (void*)&arg__1};
6489 7072 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6490 7073 if (result) { Py_DECREF(result); }
6491 7074 Py_DECREF(obj);
6492 7075 return;
7076 } else {
7077 PyErr_Clear();
6493 7078 }
6494 7079 }
6495 7080 elfInfoWdgt::contextMenuEvent(arg__1);
6496 7081 }
6497 7082 void PythonQtShell_elfInfoWdgt::customEvent(QEvent* arg__1)
6498 7083 {
6499 if (_wrapper) {
6500 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
6501 PyErr_Clear();
6502 if (obj && !PythonQtSlotFunction_Check(obj)) {
7084 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7085 static PyObject* name = PyString_FromString("customEvent");
7086 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7087 if (obj) {
6503 7088 static const char* argumentList[] ={"" , "QEvent*"};
6504 7089 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6505 7090 void* args[2] = {NULL, (void*)&arg__1};
6506 7091 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6507 7092 if (result) { Py_DECREF(result); }
6508 7093 Py_DECREF(obj);
6509 7094 return;
7095 } else {
7096 PyErr_Clear();
6510 7097 }
6511 7098 }
6512 7099 elfInfoWdgt::customEvent(arg__1);
6513 7100 }
6514 7101 int PythonQtShell_elfInfoWdgt::devType() const
6515 7102 {
6516 if (_wrapper) {
6517 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
6518 PyErr_Clear();
6519 if (obj && !PythonQtSlotFunction_Check(obj)) {
7103 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7104 static PyObject* name = PyString_FromString("devType");
7105 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7106 if (obj) {
6520 7107 static const char* argumentList[] ={"int"};
6521 7108 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6522 7109 int returnValue;
6523 7110 void* args[1] = {NULL};
6524 7111 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6525 7112 if (result) {
6526 7113 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6527 7114 if (args[0]!=&returnValue) {
6528 7115 if (args[0]==NULL) {
6529 7116 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
6530 7117 } else {
6531 7118 returnValue = *((int*)args[0]);
6532 7119 }
6533 7120 }
6534 7121 }
6535 7122 if (result) { Py_DECREF(result); }
6536 7123 Py_DECREF(obj);
6537 7124 return returnValue;
7125 } else {
7126 PyErr_Clear();
6538 7127 }
6539 7128 }
6540 7129 return elfInfoWdgt::devType();
6541 7130 }
6542 7131 void PythonQtShell_elfInfoWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
6543 7132 {
6544 if (_wrapper) {
6545 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
6546 PyErr_Clear();
6547 if (obj && !PythonQtSlotFunction_Check(obj)) {
7133 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7134 static PyObject* name = PyString_FromString("dragEnterEvent");
7135 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7136 if (obj) {
6548 7137 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
6549 7138 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6550 7139 void* args[2] = {NULL, (void*)&arg__1};
6551 7140 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6552 7141 if (result) { Py_DECREF(result); }
6553 7142 Py_DECREF(obj);
6554 7143 return;
7144 } else {
7145 PyErr_Clear();
6555 7146 }
6556 7147 }
6557 7148 elfInfoWdgt::dragEnterEvent(arg__1);
6558 7149 }
6559 7150 void PythonQtShell_elfInfoWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
6560 7151 {
6561 if (_wrapper) {
6562 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
6563 PyErr_Clear();
6564 if (obj && !PythonQtSlotFunction_Check(obj)) {
7152 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7153 static PyObject* name = PyString_FromString("dragLeaveEvent");
7154 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7155 if (obj) {
6565 7156 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
6566 7157 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6567 7158 void* args[2] = {NULL, (void*)&arg__1};
6568 7159 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6569 7160 if (result) { Py_DECREF(result); }
6570 7161 Py_DECREF(obj);
6571 7162 return;
7163 } else {
7164 PyErr_Clear();
6572 7165 }
6573 7166 }
6574 7167 elfInfoWdgt::dragLeaveEvent(arg__1);
6575 7168 }
6576 7169 void PythonQtShell_elfInfoWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
6577 7170 {
6578 if (_wrapper) {
6579 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
6580 PyErr_Clear();
6581 if (obj && !PythonQtSlotFunction_Check(obj)) {
7171 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7172 static PyObject* name = PyString_FromString("dragMoveEvent");
7173 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7174 if (obj) {
6582 7175 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
6583 7176 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6584 7177 void* args[2] = {NULL, (void*)&arg__1};
6585 7178 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6586 7179 if (result) { Py_DECREF(result); }
6587 7180 Py_DECREF(obj);
6588 7181 return;
7182 } else {
7183 PyErr_Clear();
6589 7184 }
6590 7185 }
6591 7186 elfInfoWdgt::dragMoveEvent(arg__1);
6592 7187 }
6593 7188 void PythonQtShell_elfInfoWdgt::dropEvent(QDropEvent* arg__1)
6594 7189 {
6595 if (_wrapper) {
6596 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
6597 PyErr_Clear();
6598 if (obj && !PythonQtSlotFunction_Check(obj)) {
7190 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7191 static PyObject* name = PyString_FromString("dropEvent");
7192 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7193 if (obj) {
6599 7194 static const char* argumentList[] ={"" , "QDropEvent*"};
6600 7195 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6601 7196 void* args[2] = {NULL, (void*)&arg__1};
6602 7197 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6603 7198 if (result) { Py_DECREF(result); }
6604 7199 Py_DECREF(obj);
6605 7200 return;
7201 } else {
7202 PyErr_Clear();
6606 7203 }
6607 7204 }
6608 7205 elfInfoWdgt::dropEvent(arg__1);
6609 7206 }
6610 7207 void PythonQtShell_elfInfoWdgt::enterEvent(QEvent* arg__1)
6611 7208 {
6612 if (_wrapper) {
6613 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
6614 PyErr_Clear();
6615 if (obj && !PythonQtSlotFunction_Check(obj)) {
7209 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7210 static PyObject* name = PyString_FromString("enterEvent");
7211 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7212 if (obj) {
6616 7213 static const char* argumentList[] ={"" , "QEvent*"};
6617 7214 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6618 7215 void* args[2] = {NULL, (void*)&arg__1};
6619 7216 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6620 7217 if (result) { Py_DECREF(result); }
6621 7218 Py_DECREF(obj);
6622 7219 return;
7220 } else {
7221 PyErr_Clear();
6623 7222 }
6624 7223 }
6625 7224 elfInfoWdgt::enterEvent(arg__1);
6626 7225 }
6627 7226 bool PythonQtShell_elfInfoWdgt::event(QEvent* arg__1)
6628 7227 {
6629 if (_wrapper) {
6630 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
6631 PyErr_Clear();
6632 if (obj && !PythonQtSlotFunction_Check(obj)) {
7228 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7229 static PyObject* name = PyString_FromString("event");
7230 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7231 if (obj) {
6633 7232 static const char* argumentList[] ={"bool" , "QEvent*"};
6634 7233 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6635 7234 bool returnValue;
6636 7235 void* args[2] = {NULL, (void*)&arg__1};
6637 7236 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6638 7237 if (result) {
6639 7238 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6640 7239 if (args[0]!=&returnValue) {
6641 7240 if (args[0]==NULL) {
6642 7241 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
6643 7242 } else {
6644 7243 returnValue = *((bool*)args[0]);
6645 7244 }
6646 7245 }
6647 7246 }
6648 7247 if (result) { Py_DECREF(result); }
6649 7248 Py_DECREF(obj);
6650 7249 return returnValue;
7250 } else {
7251 PyErr_Clear();
6651 7252 }
6652 7253 }
6653 7254 return elfInfoWdgt::event(arg__1);
6654 7255 }
6655 7256 bool PythonQtShell_elfInfoWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
6656 7257 {
6657 if (_wrapper) {
6658 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
6659 PyErr_Clear();
6660 if (obj && !PythonQtSlotFunction_Check(obj)) {
7258 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7259 static PyObject* name = PyString_FromString("eventFilter");
7260 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7261 if (obj) {
6661 7262 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
6662 7263 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
6663 7264 bool returnValue;
6664 7265 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
6665 7266 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6666 7267 if (result) {
6667 7268 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6668 7269 if (args[0]!=&returnValue) {
6669 7270 if (args[0]==NULL) {
6670 7271 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
6671 7272 } else {
6672 7273 returnValue = *((bool*)args[0]);
6673 7274 }
6674 7275 }
6675 7276 }
6676 7277 if (result) { Py_DECREF(result); }
6677 7278 Py_DECREF(obj);
6678 7279 return returnValue;
7280 } else {
7281 PyErr_Clear();
6679 7282 }
6680 7283 }
6681 7284 return elfInfoWdgt::eventFilter(arg__1, arg__2);
6682 7285 }
6683 7286 void PythonQtShell_elfInfoWdgt::focusInEvent(QFocusEvent* arg__1)
6684 7287 {
6685 if (_wrapper) {
6686 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
6687 PyErr_Clear();
6688 if (obj && !PythonQtSlotFunction_Check(obj)) {
7288 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7289 static PyObject* name = PyString_FromString("focusInEvent");
7290 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7291 if (obj) {
6689 7292 static const char* argumentList[] ={"" , "QFocusEvent*"};
6690 7293 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6691 7294 void* args[2] = {NULL, (void*)&arg__1};
6692 7295 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6693 7296 if (result) { Py_DECREF(result); }
6694 7297 Py_DECREF(obj);
6695 7298 return;
7299 } else {
7300 PyErr_Clear();
6696 7301 }
6697 7302 }
6698 7303 elfInfoWdgt::focusInEvent(arg__1);
6699 7304 }
6700 bool PythonQtShell_elfInfoWdgt::focusNextPrevChild(bool next)
6701 {
6702 if (_wrapper) {
6703 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
6704 PyErr_Clear();
6705 if (obj && !PythonQtSlotFunction_Check(obj)) {
7305 bool PythonQtShell_elfInfoWdgt::focusNextPrevChild(bool next0)
7306 {
7307 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7308 static PyObject* name = PyString_FromString("focusNextPrevChild");
7309 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7310 if (obj) {
6706 7311 static const char* argumentList[] ={"bool" , "bool"};
6707 7312 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6708 7313 bool returnValue;
6709 void* args[2] = {NULL, (void*)&next};
7314 void* args[2] = {NULL, (void*)&next0};
6710 7315 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6711 7316 if (result) {
6712 7317 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6713 7318 if (args[0]!=&returnValue) {
6714 7319 if (args[0]==NULL) {
6715 7320 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
6716 7321 } else {
6717 7322 returnValue = *((bool*)args[0]);
6718 7323 }
6719 7324 }
6720 7325 }
6721 7326 if (result) { Py_DECREF(result); }
6722 7327 Py_DECREF(obj);
6723 7328 return returnValue;
6724 }
6725 }
6726 return elfInfoWdgt::focusNextPrevChild(next);
7329 } else {
7330 PyErr_Clear();
7331 }
7332 }
7333 return elfInfoWdgt::focusNextPrevChild(next0);
6727 7334 }
6728 7335 void PythonQtShell_elfInfoWdgt::focusOutEvent(QFocusEvent* arg__1)
6729 7336 {
6730 if (_wrapper) {
6731 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
6732 PyErr_Clear();
6733 if (obj && !PythonQtSlotFunction_Check(obj)) {
7337 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7338 static PyObject* name = PyString_FromString("focusOutEvent");
7339 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7340 if (obj) {
6734 7341 static const char* argumentList[] ={"" , "QFocusEvent*"};
6735 7342 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6736 7343 void* args[2] = {NULL, (void*)&arg__1};
6737 7344 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6738 7345 if (result) { Py_DECREF(result); }
6739 7346 Py_DECREF(obj);
6740 7347 return;
7348 } else {
7349 PyErr_Clear();
6741 7350 }
6742 7351 }
6743 7352 elfInfoWdgt::focusOutEvent(arg__1);
6744 7353 }
6745 7354 bool PythonQtShell_elfInfoWdgt::hasHeightForWidth() const
6746 7355 {
6747 if (_wrapper) {
6748 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
6749 PyErr_Clear();
6750 if (obj && !PythonQtSlotFunction_Check(obj)) {
7356 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7357 static PyObject* name = PyString_FromString("hasHeightForWidth");
7358 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7359 if (obj) {
6751 7360 static const char* argumentList[] ={"bool"};
6752 7361 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6753 7362 bool returnValue;
6754 7363 void* args[1] = {NULL};
6755 7364 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6756 7365 if (result) {
6757 7366 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6758 7367 if (args[0]!=&returnValue) {
6759 7368 if (args[0]==NULL) {
6760 7369 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
6761 7370 } else {
6762 7371 returnValue = *((bool*)args[0]);
6763 7372 }
6764 7373 }
6765 7374 }
6766 7375 if (result) { Py_DECREF(result); }
6767 7376 Py_DECREF(obj);
6768 7377 return returnValue;
7378 } else {
7379 PyErr_Clear();
6769 7380 }
6770 7381 }
6771 7382 return elfInfoWdgt::hasHeightForWidth();
6772 7383 }
6773 7384 int PythonQtShell_elfInfoWdgt::heightForWidth(int arg__1) const
6774 7385 {
6775 if (_wrapper) {
6776 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
6777 PyErr_Clear();
6778 if (obj && !PythonQtSlotFunction_Check(obj)) {
7386 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7387 static PyObject* name = PyString_FromString("heightForWidth");
7388 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7389 if (obj) {
6779 7390 static const char* argumentList[] ={"int" , "int"};
6780 7391 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6781 7392 int returnValue;
6782 7393 void* args[2] = {NULL, (void*)&arg__1};
6783 7394 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6784 7395 if (result) {
6785 7396 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6786 7397 if (args[0]!=&returnValue) {
6787 7398 if (args[0]==NULL) {
6788 7399 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
6789 7400 } else {
6790 7401 returnValue = *((int*)args[0]);
6791 7402 }
6792 7403 }
6793 7404 }
6794 7405 if (result) { Py_DECREF(result); }
6795 7406 Py_DECREF(obj);
6796 7407 return returnValue;
7408 } else {
7409 PyErr_Clear();
6797 7410 }
6798 7411 }
6799 7412 return elfInfoWdgt::heightForWidth(arg__1);
6800 7413 }
6801 7414 void PythonQtShell_elfInfoWdgt::hideEvent(QHideEvent* arg__1)
6802 7415 {
6803 if (_wrapper) {
6804 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
6805 PyErr_Clear();
6806 if (obj && !PythonQtSlotFunction_Check(obj)) {
7416 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7417 static PyObject* name = PyString_FromString("hideEvent");
7418 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7419 if (obj) {
6807 7420 static const char* argumentList[] ={"" , "QHideEvent*"};
6808 7421 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6809 7422 void* args[2] = {NULL, (void*)&arg__1};
6810 7423 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6811 7424 if (result) { Py_DECREF(result); }
6812 7425 Py_DECREF(obj);
6813 7426 return;
7427 } else {
7428 PyErr_Clear();
6814 7429 }
6815 7430 }
6816 7431 elfInfoWdgt::hideEvent(arg__1);
6817 7432 }
6818 void PythonQtShell_elfInfoWdgt::initPainter(QPainter* painter) const
6819 {
6820 if (_wrapper) {
6821 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
6822 PyErr_Clear();
6823 if (obj && !PythonQtSlotFunction_Check(obj)) {
7433 void PythonQtShell_elfInfoWdgt::initPainter(QPainter* painter0) const
7434 {
7435 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7436 static PyObject* name = PyString_FromString("initPainter");
7437 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7438 if (obj) {
6824 7439 static const char* argumentList[] ={"" , "QPainter*"};
6825 7440 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6826 void* args[2] = {NULL, (void*)&painter};
6827 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6828 if (result) { Py_DECREF(result); }
6829 Py_DECREF(obj);
6830 return;
6831 }
6832 }
6833 elfInfoWdgt::initPainter(painter);
7441 void* args[2] = {NULL, (void*)&painter0};
7442 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7443 if (result) { Py_DECREF(result); }
7444 Py_DECREF(obj);
7445 return;
7446 } else {
7447 PyErr_Clear();
7448 }
7449 }
7450 elfInfoWdgt::initPainter(painter0);
6834 7451 }
6835 7452 void PythonQtShell_elfInfoWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
6836 7453 {
6837 if (_wrapper) {
6838 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
6839 PyErr_Clear();
6840 if (obj && !PythonQtSlotFunction_Check(obj)) {
7454 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7455 static PyObject* name = PyString_FromString("inputMethodEvent");
7456 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7457 if (obj) {
6841 7458 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
6842 7459 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6843 7460 void* args[2] = {NULL, (void*)&arg__1};
6844 7461 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6845 7462 if (result) { Py_DECREF(result); }
6846 7463 Py_DECREF(obj);
6847 7464 return;
7465 } else {
7466 PyErr_Clear();
6848 7467 }
6849 7468 }
6850 7469 elfInfoWdgt::inputMethodEvent(arg__1);
6851 7470 }
6852 7471 QVariant PythonQtShell_elfInfoWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
6853 7472 {
6854 if (_wrapper) {
6855 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
6856 PyErr_Clear();
6857 if (obj && !PythonQtSlotFunction_Check(obj)) {
7473 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7474 static PyObject* name = PyString_FromString("inputMethodQuery");
7475 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7476 if (obj) {
6858 7477 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
6859 7478 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6860 7479 QVariant returnValue;
6861 7480 void* args[2] = {NULL, (void*)&arg__1};
6862 7481 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6863 7482 if (result) {
6864 7483 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6865 7484 if (args[0]!=&returnValue) {
6866 7485 if (args[0]==NULL) {
6867 7486 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
6868 7487 } else {
6869 7488 returnValue = *((QVariant*)args[0]);
6870 7489 }
6871 7490 }
6872 7491 }
6873 7492 if (result) { Py_DECREF(result); }
6874 7493 Py_DECREF(obj);
6875 7494 return returnValue;
7495 } else {
7496 PyErr_Clear();
6876 7497 }
6877 7498 }
6878 7499 return elfInfoWdgt::inputMethodQuery(arg__1);
6879 7500 }
6880 7501 void PythonQtShell_elfInfoWdgt::keyPressEvent(QKeyEvent* arg__1)
6881 7502 {
6882 if (_wrapper) {
6883 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
6884 PyErr_Clear();
6885 if (obj && !PythonQtSlotFunction_Check(obj)) {
7503 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7504 static PyObject* name = PyString_FromString("keyPressEvent");
7505 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7506 if (obj) {
6886 7507 static const char* argumentList[] ={"" , "QKeyEvent*"};
6887 7508 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6888 7509 void* args[2] = {NULL, (void*)&arg__1};
6889 7510 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6890 7511 if (result) { Py_DECREF(result); }
6891 7512 Py_DECREF(obj);
6892 7513 return;
7514 } else {
7515 PyErr_Clear();
6893 7516 }
6894 7517 }
6895 7518 elfInfoWdgt::keyPressEvent(arg__1);
6896 7519 }
6897 7520 void PythonQtShell_elfInfoWdgt::keyReleaseEvent(QKeyEvent* arg__1)
6898 7521 {
6899 if (_wrapper) {
6900 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
6901 PyErr_Clear();
6902 if (obj && !PythonQtSlotFunction_Check(obj)) {
7522 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7523 static PyObject* name = PyString_FromString("keyReleaseEvent");
7524 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7525 if (obj) {
6903 7526 static const char* argumentList[] ={"" , "QKeyEvent*"};
6904 7527 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6905 7528 void* args[2] = {NULL, (void*)&arg__1};
6906 7529 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6907 7530 if (result) { Py_DECREF(result); }
6908 7531 Py_DECREF(obj);
6909 7532 return;
7533 } else {
7534 PyErr_Clear();
6910 7535 }
6911 7536 }
6912 7537 elfInfoWdgt::keyReleaseEvent(arg__1);
6913 7538 }
6914 7539 void PythonQtShell_elfInfoWdgt::leaveEvent(QEvent* arg__1)
6915 7540 {
6916 if (_wrapper) {
6917 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
6918 PyErr_Clear();
6919 if (obj && !PythonQtSlotFunction_Check(obj)) {
7541 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7542 static PyObject* name = PyString_FromString("leaveEvent");
7543 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7544 if (obj) {
6920 7545 static const char* argumentList[] ={"" , "QEvent*"};
6921 7546 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6922 7547 void* args[2] = {NULL, (void*)&arg__1};
6923 7548 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6924 7549 if (result) { Py_DECREF(result); }
6925 7550 Py_DECREF(obj);
6926 7551 return;
7552 } else {
7553 PyErr_Clear();
6927 7554 }
6928 7555 }
6929 7556 elfInfoWdgt::leaveEvent(arg__1);
6930 7557 }
6931 7558 int PythonQtShell_elfInfoWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
6932 7559 {
6933 if (_wrapper) {
6934 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
6935 PyErr_Clear();
6936 if (obj && !PythonQtSlotFunction_Check(obj)) {
7560 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7561 static PyObject* name = PyString_FromString("metric");
7562 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7563 if (obj) {
6937 7564 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
6938 7565 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6939 7566 int returnValue;
6940 7567 void* args[2] = {NULL, (void*)&arg__1};
6941 7568 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6942 7569 if (result) {
6943 7570 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6944 7571 if (args[0]!=&returnValue) {
6945 7572 if (args[0]==NULL) {
6946 7573 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
6947 7574 } else {
6948 7575 returnValue = *((int*)args[0]);
6949 7576 }
6950 7577 }
6951 7578 }
6952 7579 if (result) { Py_DECREF(result); }
6953 7580 Py_DECREF(obj);
6954 7581 return returnValue;
7582 } else {
7583 PyErr_Clear();
6955 7584 }
6956 7585 }
6957 7586 return elfInfoWdgt::metric(arg__1);
6958 7587 }
6959 7588 QSize PythonQtShell_elfInfoWdgt::minimumSizeHint() const
6960 7589 {
6961 if (_wrapper) {
6962 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
6963 PyErr_Clear();
6964 if (obj && !PythonQtSlotFunction_Check(obj)) {
7590 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7591 static PyObject* name = PyString_FromString("getMinimumSizeHint");
7592 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7593 if (obj) {
6965 7594 static const char* argumentList[] ={"QSize"};
6966 7595 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6967 7596 QSize returnValue;
6968 7597 void* args[1] = {NULL};
6969 7598 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6970 7599 if (result) {
6971 7600 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6972 7601 if (args[0]!=&returnValue) {
6973 7602 if (args[0]==NULL) {
6974 7603 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
6975 7604 } else {
6976 7605 returnValue = *((QSize*)args[0]);
6977 7606 }
6978 7607 }
6979 7608 }
6980 7609 if (result) { Py_DECREF(result); }
6981 7610 Py_DECREF(obj);
6982 7611 return returnValue;
7612 } else {
7613 PyErr_Clear();
6983 7614 }
6984 7615 }
6985 7616 return elfInfoWdgt::minimumSizeHint();
6986 7617 }
6987 7618 void PythonQtShell_elfInfoWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
6988 7619 {
6989 if (_wrapper) {
6990 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
6991 PyErr_Clear();
6992 if (obj && !PythonQtSlotFunction_Check(obj)) {
7620 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7621 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
7622 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7623 if (obj) {
6993 7624 static const char* argumentList[] ={"" , "QMouseEvent*"};
6994 7625 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6995 7626 void* args[2] = {NULL, (void*)&arg__1};
6996 7627 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6997 7628 if (result) { Py_DECREF(result); }
6998 7629 Py_DECREF(obj);
6999 7630 return;
7631 } else {
7632 PyErr_Clear();
7000 7633 }
7001 7634 }
7002 7635 elfInfoWdgt::mouseDoubleClickEvent(arg__1);
7003 7636 }
7004 7637 void PythonQtShell_elfInfoWdgt::mouseMoveEvent(QMouseEvent* arg__1)
7005 7638 {
7006 if (_wrapper) {
7007 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
7008 PyErr_Clear();
7009 if (obj && !PythonQtSlotFunction_Check(obj)) {
7639 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7640 static PyObject* name = PyString_FromString("mouseMoveEvent");
7641 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7642 if (obj) {
7010 7643 static const char* argumentList[] ={"" , "QMouseEvent*"};
7011 7644 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7012 7645 void* args[2] = {NULL, (void*)&arg__1};
7013 7646 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7014 7647 if (result) { Py_DECREF(result); }
7015 7648 Py_DECREF(obj);
7016 7649 return;
7650 } else {
7651 PyErr_Clear();
7017 7652 }
7018 7653 }
7019 7654 elfInfoWdgt::mouseMoveEvent(arg__1);
7020 7655 }
7021 7656 void PythonQtShell_elfInfoWdgt::mousePressEvent(QMouseEvent* arg__1)
7022 7657 {
7023 if (_wrapper) {
7024 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
7025 PyErr_Clear();
7026 if (obj && !PythonQtSlotFunction_Check(obj)) {
7658 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7659 static PyObject* name = PyString_FromString("mousePressEvent");
7660 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7661 if (obj) {
7027 7662 static const char* argumentList[] ={"" , "QMouseEvent*"};
7028 7663 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7029 7664 void* args[2] = {NULL, (void*)&arg__1};
7030 7665 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7031 7666 if (result) { Py_DECREF(result); }
7032 7667 Py_DECREF(obj);
7033 7668 return;
7669 } else {
7670 PyErr_Clear();
7034 7671 }
7035 7672 }
7036 7673 elfInfoWdgt::mousePressEvent(arg__1);
7037 7674 }
7038 7675 void PythonQtShell_elfInfoWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
7039 7676 {
7040 if (_wrapper) {
7041 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
7042 PyErr_Clear();
7043 if (obj && !PythonQtSlotFunction_Check(obj)) {
7677 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7678 static PyObject* name = PyString_FromString("mouseReleaseEvent");
7679 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7680 if (obj) {
7044 7681 static const char* argumentList[] ={"" , "QMouseEvent*"};
7045 7682 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7046 7683 void* args[2] = {NULL, (void*)&arg__1};
7047 7684 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7048 7685 if (result) { Py_DECREF(result); }
7049 7686 Py_DECREF(obj);
7050 7687 return;
7688 } else {
7689 PyErr_Clear();
7051 7690 }
7052 7691 }
7053 7692 elfInfoWdgt::mouseReleaseEvent(arg__1);
7054 7693 }
7055 7694 void PythonQtShell_elfInfoWdgt::moveEvent(QMoveEvent* arg__1)
7056 7695 {
7057 if (_wrapper) {
7058 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
7059 PyErr_Clear();
7060 if (obj && !PythonQtSlotFunction_Check(obj)) {
7696 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7697 static PyObject* name = PyString_FromString("moveEvent");
7698 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7699 if (obj) {
7061 7700 static const char* argumentList[] ={"" , "QMoveEvent*"};
7062 7701 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7063 7702 void* args[2] = {NULL, (void*)&arg__1};
7064 7703 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7065 7704 if (result) { Py_DECREF(result); }
7066 7705 Py_DECREF(obj);
7067 7706 return;
7707 } else {
7708 PyErr_Clear();
7068 7709 }
7069 7710 }
7070 7711 elfInfoWdgt::moveEvent(arg__1);
7071 7712 }
7072 bool PythonQtShell_elfInfoWdgt::nativeEvent(const QByteArray& eventType, void* message, long* result)
7073 {
7074 if (_wrapper) {
7075 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
7076 PyErr_Clear();
7077 if (obj && !PythonQtSlotFunction_Check(obj)) {
7713 bool PythonQtShell_elfInfoWdgt::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
7714 {
7715 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7716 static PyObject* name = PyString_FromString("nativeEvent");
7717 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7718 if (obj) {
7078 7719 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
7079 7720 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
7080 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 7723 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7083 7724 if (result) {
7084 7725 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7085 7726 if (args[0]!=&returnValue) {
7086 7727 if (args[0]==NULL) {
7087 7728 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
7088 7729 } else {
7089 7730 returnValue = *((bool*)args[0]);
7090 7731 }
7091 7732 }
7092 7733 }
7093 7734 if (result) { Py_DECREF(result); }
7094 7735 Py_DECREF(obj);
7095 7736 return returnValue;
7096 }
7097 }
7098 return elfInfoWdgt::nativeEvent(eventType, message, result);
7737 } else {
7738 PyErr_Clear();
7739 }
7740 }
7741 return elfInfoWdgt::nativeEvent(eventType0, message1, result2);
7099 7742 }
7100 7743 QPaintEngine* PythonQtShell_elfInfoWdgt::paintEngine() const
7101 7744 {
7102 if (_wrapper) {
7103 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
7104 PyErr_Clear();
7105 if (obj && !PythonQtSlotFunction_Check(obj)) {
7745 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7746 static PyObject* name = PyString_FromString("paintEngine");
7747 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7748 if (obj) {
7106 7749 static const char* argumentList[] ={"QPaintEngine*"};
7107 7750 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7108 7751 QPaintEngine* returnValue;
7109 7752 void* args[1] = {NULL};
7110 7753 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7111 7754 if (result) {
7112 7755 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7113 7756 if (args[0]!=&returnValue) {
7114 7757 if (args[0]==NULL) {
7115 7758 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
7116 7759 } else {
7117 7760 returnValue = *((QPaintEngine**)args[0]);
7118 7761 }
7119 7762 }
7120 7763 }
7121 7764 if (result) { Py_DECREF(result); }
7122 7765 Py_DECREF(obj);
7123 7766 return returnValue;
7767 } else {
7768 PyErr_Clear();
7124 7769 }
7125 7770 }
7126 7771 return elfInfoWdgt::paintEngine();
7127 7772 }
7128 7773 void PythonQtShell_elfInfoWdgt::paintEvent(QPaintEvent* arg__1)
7129 7774 {
7130 if (_wrapper) {
7131 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
7132 PyErr_Clear();
7133 if (obj && !PythonQtSlotFunction_Check(obj)) {
7775 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7776 static PyObject* name = PyString_FromString("paintEvent");
7777 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7778 if (obj) {
7134 7779 static const char* argumentList[] ={"" , "QPaintEvent*"};
7135 7780 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7136 7781 void* args[2] = {NULL, (void*)&arg__1};
7137 7782 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7138 7783 if (result) { Py_DECREF(result); }
7139 7784 Py_DECREF(obj);
7140 7785 return;
7786 } else {
7787 PyErr_Clear();
7141 7788 }
7142 7789 }
7143 7790 elfInfoWdgt::paintEvent(arg__1);
7144 7791 }
7145 QPaintDevice* PythonQtShell_elfInfoWdgt::redirected(QPoint* offset) const
7146 {
7147 if (_wrapper) {
7148 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
7149 PyErr_Clear();
7150 if (obj && !PythonQtSlotFunction_Check(obj)) {
7792 QPaintDevice* PythonQtShell_elfInfoWdgt::redirected(QPoint* offset0) const
7793 {
7794 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7795 static PyObject* name = PyString_FromString("redirected");
7796 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7797 if (obj) {
7151 7798 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
7152 7799 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7153 7800 QPaintDevice* returnValue;
7154 void* args[2] = {NULL, (void*)&offset};
7801 void* args[2] = {NULL, (void*)&offset0};
7155 7802 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7156 7803 if (result) {
7157 7804 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7158 7805 if (args[0]!=&returnValue) {
7159 7806 if (args[0]==NULL) {
7160 7807 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
7161 7808 } else {
7162 7809 returnValue = *((QPaintDevice**)args[0]);
7163 7810 }
7164 7811 }
7165 7812 }
7166 7813 if (result) { Py_DECREF(result); }
7167 7814 Py_DECREF(obj);
7168 7815 return returnValue;
7169 }
7170 }
7171 return elfInfoWdgt::redirected(offset);
7816 } else {
7817 PyErr_Clear();
7818 }
7819 }
7820 return elfInfoWdgt::redirected(offset0);
7172 7821 }
7173 7822 void PythonQtShell_elfInfoWdgt::resizeEvent(QResizeEvent* arg__1)
7174 7823 {
7175 if (_wrapper) {
7176 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
7177 PyErr_Clear();
7178 if (obj && !PythonQtSlotFunction_Check(obj)) {
7824 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7825 static PyObject* name = PyString_FromString("resizeEvent");
7826 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7827 if (obj) {
7179 7828 static const char* argumentList[] ={"" , "QResizeEvent*"};
7180 7829 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7181 7830 void* args[2] = {NULL, (void*)&arg__1};
7182 7831 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7183 7832 if (result) { Py_DECREF(result); }
7184 7833 Py_DECREF(obj);
7185 7834 return;
7835 } else {
7836 PyErr_Clear();
7186 7837 }
7187 7838 }
7188 7839 elfInfoWdgt::resizeEvent(arg__1);
7189 7840 }
7190 7841 QPainter* PythonQtShell_elfInfoWdgt::sharedPainter() const
7191 7842 {
7192 if (_wrapper) {
7193 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
7194 PyErr_Clear();
7195 if (obj && !PythonQtSlotFunction_Check(obj)) {
7843 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7844 static PyObject* name = PyString_FromString("sharedPainter");
7845 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7846 if (obj) {
7196 7847 static const char* argumentList[] ={"QPainter*"};
7197 7848 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7198 7849 QPainter* returnValue;
7199 7850 void* args[1] = {NULL};
7200 7851 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7201 7852 if (result) {
7202 7853 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7203 7854 if (args[0]!=&returnValue) {
7204 7855 if (args[0]==NULL) {
7205 7856 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
7206 7857 } else {
7207 7858 returnValue = *((QPainter**)args[0]);
7208 7859 }
7209 7860 }
7210 7861 }
7211 7862 if (result) { Py_DECREF(result); }
7212 7863 Py_DECREF(obj);
7213 7864 return returnValue;
7865 } else {
7866 PyErr_Clear();
7214 7867 }
7215 7868 }
7216 7869 return elfInfoWdgt::sharedPainter();
7217 7870 }
7218 7871 void PythonQtShell_elfInfoWdgt::showEvent(QShowEvent* arg__1)
7219 7872 {
7220 if (_wrapper) {
7221 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
7222 PyErr_Clear();
7223 if (obj && !PythonQtSlotFunction_Check(obj)) {
7873 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7874 static PyObject* name = PyString_FromString("showEvent");
7875 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7876 if (obj) {
7224 7877 static const char* argumentList[] ={"" , "QShowEvent*"};
7225 7878 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7226 7879 void* args[2] = {NULL, (void*)&arg__1};
7227 7880 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7228 7881 if (result) { Py_DECREF(result); }
7229 7882 Py_DECREF(obj);
7230 7883 return;
7884 } else {
7885 PyErr_Clear();
7231 7886 }
7232 7887 }
7233 7888 elfInfoWdgt::showEvent(arg__1);
7234 7889 }
7235 7890 QSize PythonQtShell_elfInfoWdgt::sizeHint() const
7236 7891 {
7237 if (_wrapper) {
7238 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
7239 PyErr_Clear();
7240 if (obj && !PythonQtSlotFunction_Check(obj)) {
7892 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7893 static PyObject* name = PyString_FromString("getSizeHint");
7894 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7895 if (obj) {
7241 7896 static const char* argumentList[] ={"QSize"};
7242 7897 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7243 7898 QSize returnValue;
7244 7899 void* args[1] = {NULL};
7245 7900 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7246 7901 if (result) {
7247 7902 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7248 7903 if (args[0]!=&returnValue) {
7249 7904 if (args[0]==NULL) {
7250 7905 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
7251 7906 } else {
7252 7907 returnValue = *((QSize*)args[0]);
7253 7908 }
7254 7909 }
7255 7910 }
7256 7911 if (result) { Py_DECREF(result); }
7257 7912 Py_DECREF(obj);
7258 7913 return returnValue;
7914 } else {
7915 PyErr_Clear();
7259 7916 }
7260 7917 }
7261 7918 return elfInfoWdgt::sizeHint();
7262 7919 }
7263 7920 void PythonQtShell_elfInfoWdgt::tabletEvent(QTabletEvent* arg__1)
7264 7921 {
7265 if (_wrapper) {
7266 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
7267 PyErr_Clear();
7268 if (obj && !PythonQtSlotFunction_Check(obj)) {
7922 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7923 static PyObject* name = PyString_FromString("tabletEvent");
7924 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7925 if (obj) {
7269 7926 static const char* argumentList[] ={"" , "QTabletEvent*"};
7270 7927 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7271 7928 void* args[2] = {NULL, (void*)&arg__1};
7272 7929 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7273 7930 if (result) { Py_DECREF(result); }
7274 7931 Py_DECREF(obj);
7275 7932 return;
7933 } else {
7934 PyErr_Clear();
7276 7935 }
7277 7936 }
7278 7937 elfInfoWdgt::tabletEvent(arg__1);
7279 7938 }
7280 7939 void PythonQtShell_elfInfoWdgt::timerEvent(QTimerEvent* arg__1)
7281 7940 {
7282 if (_wrapper) {
7283 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
7284 PyErr_Clear();
7285 if (obj && !PythonQtSlotFunction_Check(obj)) {
7941 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7942 static PyObject* name = PyString_FromString("timerEvent");
7943 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7944 if (obj) {
7286 7945 static const char* argumentList[] ={"" , "QTimerEvent*"};
7287 7946 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7288 7947 void* args[2] = {NULL, (void*)&arg__1};
7289 7948 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7290 7949 if (result) { Py_DECREF(result); }
7291 7950 Py_DECREF(obj);
7292 7951 return;
7952 } else {
7953 PyErr_Clear();
7293 7954 }
7294 7955 }
7295 7956 elfInfoWdgt::timerEvent(arg__1);
7296 7957 }
7297 7958 void PythonQtShell_elfInfoWdgt::wheelEvent(QWheelEvent* arg__1)
7298 7959 {
7299 if (_wrapper) {
7300 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
7301 PyErr_Clear();
7302 if (obj && !PythonQtSlotFunction_Check(obj)) {
7960 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7961 static PyObject* name = PyString_FromString("wheelEvent");
7962 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7963 if (obj) {
7303 7964 static const char* argumentList[] ={"" , "QWheelEvent*"};
7304 7965 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7305 7966 void* args[2] = {NULL, (void*)&arg__1};
7306 7967 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7307 7968 if (result) { Py_DECREF(result); }
7308 7969 Py_DECREF(obj);
7309 7970 return;
7971 } else {
7972 PyErr_Clear();
7310 7973 }
7311 7974 }
7312 7975 elfInfoWdgt::wheelEvent(arg__1);
7313 7976 }
7314 7977 elfInfoWdgt* PythonQtWrapper_elfInfoWdgt::new_elfInfoWdgt(QWidget* parent)
7315 7978 {
7316 7979 return new PythonQtShell_elfInfoWdgt(parent); }
7317 7980
7318 7981
7319 7982
7320 7983 elfparser* PythonQtWrapper_elfparser::new_elfparser()
7321 7984 {
7322 7985 return new elfparser(); }
7323 7986
7324 7987 int PythonQtWrapper_elfparser::closeFile(elfparser* theWrappedObject)
7325 7988 {
7326 7989 return ( theWrappedObject->closeFile());
7327 7990 }
7328 7991
7329 7992 QString PythonQtWrapper_elfparser::getABI(elfparser* theWrappedObject)
7330 7993 {
7331 7994 return ( theWrappedObject->getABI());
7332 7995 }
7333 7996
7334 7997 QString PythonQtWrapper_elfparser::getArchitecture(elfparser* theWrappedObject)
7335 7998 {
7336 7999 return ( theWrappedObject->getArchitecture());
7337 8000 }
7338 8001
7339 8002 QString PythonQtWrapper_elfparser::getClass(elfparser* theWrappedObject)
7340 8003 {
7341 8004 return ( theWrappedObject->getClass());
7342 8005 }
7343 8006
7344 8007 QString PythonQtWrapper_elfparser::getEndianness(elfparser* theWrappedObject)
7345 8008 {
7346 8009 return ( theWrappedObject->getEndianness());
7347 8010 }
7348 8011
7349 8012 qint64 PythonQtWrapper_elfparser::getEntryPointAddress(elfparser* theWrappedObject)
7350 8013 {
7351 8014 return ( theWrappedObject->getEntryPointAddress());
7352 8015 }
7353 8016
7354 8017 bool PythonQtWrapper_elfparser::getSectionData(elfparser* theWrappedObject, int index, char** buffer)
7355 8018 {
7356 8019 return ( theWrappedObject->getSectionData(index, buffer));
7357 8020 }
7358 8021
7359 8022 qint64 PythonQtWrapper_elfparser::getSectionDatasz(elfparser* theWrappedObject, int index)
7360 8023 {
7361 8024 return ( theWrappedObject->getSectionDatasz(index));
7362 8025 }
7363 8026
7364 8027 qint64 PythonQtWrapper_elfparser::getSectionMemsz(elfparser* theWrappedObject, int index)
7365 8028 {
7366 8029 return ( theWrappedObject->getSectionMemsz(index));
7367 8030 }
7368 8031
7369 8032 QString PythonQtWrapper_elfparser::getSectionName(elfparser* theWrappedObject, int index)
7370 8033 {
7371 8034 return ( theWrappedObject->getSectionName(index));
7372 8035 }
7373 8036
7374 8037 qint64 PythonQtWrapper_elfparser::getSectionPaddr(elfparser* theWrappedObject, int index)
7375 8038 {
7376 8039 return ( theWrappedObject->getSectionPaddr(index));
7377 8040 }
7378 8041
7379 8042 QString PythonQtWrapper_elfparser::getSectionType(elfparser* theWrappedObject, int index)
7380 8043 {
7381 8044 return ( theWrappedObject->getSectionType(index));
7382 8045 }
7383 8046
7384 8047 int PythonQtWrapper_elfparser::getSectioncount(elfparser* theWrappedObject)
7385 8048 {
7386 8049 return ( theWrappedObject->getSectioncount());
7387 8050 }
7388 8051
7389 8052 qint64 PythonQtWrapper_elfparser::getSegmentFilesz(elfparser* theWrappedObject, int index)
7390 8053 {
7391 8054 return ( theWrappedObject->getSegmentFilesz(index));
7392 8055 }
7393 8056
7394 8057 QString PythonQtWrapper_elfparser::getSegmentFlags(elfparser* theWrappedObject, int index)
7395 8058 {
7396 8059 return ( theWrappedObject->getSegmentFlags(index));
7397 8060 }
7398 8061
7399 8062 qint64 PythonQtWrapper_elfparser::getSegmentMemsz(elfparser* theWrappedObject, int index)
7400 8063 {
7401 8064 return ( theWrappedObject->getSegmentMemsz(index));
7402 8065 }
7403 8066
7404 8067 qint64 PythonQtWrapper_elfparser::getSegmentOffset(elfparser* theWrappedObject, int index)
7405 8068 {
7406 8069 return ( theWrappedObject->getSegmentOffset(index));
7407 8070 }
7408 8071
7409 8072 qint64 PythonQtWrapper_elfparser::getSegmentPaddr(elfparser* theWrappedObject, int index)
7410 8073 {
7411 8074 return ( theWrappedObject->getSegmentPaddr(index));
7412 8075 }
7413 8076
7414 8077 QString PythonQtWrapper_elfparser::getSegmentType(elfparser* theWrappedObject, int index)
7415 8078 {
7416 8079 return ( theWrappedObject->getSegmentType(index));
7417 8080 }
7418 8081
7419 8082 qint64 PythonQtWrapper_elfparser::getSegmentVaddr(elfparser* theWrappedObject, int index)
7420 8083 {
7421 8084 return ( theWrappedObject->getSegmentVaddr(index));
7422 8085 }
7423 8086
7424 8087 int PythonQtWrapper_elfparser::getSegmentcount(elfparser* theWrappedObject)
7425 8088 {
7426 8089 return ( theWrappedObject->getSegmentcount());
7427 8090 }
7428 8091
7429 8092 QString PythonQtWrapper_elfparser::getType(elfparser* theWrappedObject)
7430 8093 {
7431 8094 return ( theWrappedObject->getType());
7432 8095 }
7433 8096
7434 8097 qint64 PythonQtWrapper_elfparser::getVersion(elfparser* theWrappedObject)
7435 8098 {
7436 8099 return ( theWrappedObject->getVersion());
7437 8100 }
7438 8101
7439 8102 bool PythonQtWrapper_elfparser::static_elfparser_isElf(const QString& File)
7440 8103 {
7441 8104 return (elfparser::isElf(File));
7442 8105 }
7443 8106
7444 8107 bool PythonQtWrapper_elfparser::iself(elfparser* theWrappedObject)
7445 8108 {
7446 8109 return ( theWrappedObject->iself());
7447 8110 }
7448 8111
7449 8112 bool PythonQtWrapper_elfparser::isopened(elfparser* theWrappedObject)
7450 8113 {
7451 8114 return ( theWrappedObject->isopened());
7452 8115 }
7453 8116
7454 8117 int PythonQtWrapper_elfparser::setFilename(elfparser* theWrappedObject, const QString& name)
7455 8118 {
7456 8119 return ( theWrappedObject->setFilename(name));
7457 8120 }
7458 8121
7459 8122
7460 8123
7461 8124 PythonQtShell_genericBinaryFileWidget::~PythonQtShell_genericBinaryFileWidget() {
7462 8125 PythonQtPrivate* priv = PythonQt::priv();
7463 8126 if (priv) { priv->shellClassDeleted(this); }
7464 8127 }
7465 8128 void PythonQtShell_genericBinaryFileWidget::actionEvent(QActionEvent* arg__1)
7466 8129 {
7467 if (_wrapper) {
7468 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
7469 PyErr_Clear();
7470 if (obj && !PythonQtSlotFunction_Check(obj)) {
8130 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8131 static PyObject* name = PyString_FromString("actionEvent");
8132 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8133 if (obj) {
7471 8134 static const char* argumentList[] ={"" , "QActionEvent*"};
7472 8135 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7473 8136 void* args[2] = {NULL, (void*)&arg__1};
7474 8137 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7475 8138 if (result) { Py_DECREF(result); }
7476 8139 Py_DECREF(obj);
7477 8140 return;
8141 } else {
8142 PyErr_Clear();
7478 8143 }
7479 8144 }
7480 8145 genericBinaryFileWidget::actionEvent(arg__1);
7481 8146 }
7482 8147 void PythonQtShell_genericBinaryFileWidget::changeEvent(QEvent* arg__1)
7483 8148 {
7484 if (_wrapper) {
7485 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
7486 PyErr_Clear();
7487 if (obj && !PythonQtSlotFunction_Check(obj)) {
8149 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8150 static PyObject* name = PyString_FromString("changeEvent");
8151 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8152 if (obj) {
7488 8153 static const char* argumentList[] ={"" , "QEvent*"};
7489 8154 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7490 8155 void* args[2] = {NULL, (void*)&arg__1};
7491 8156 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7492 8157 if (result) { Py_DECREF(result); }
7493 8158 Py_DECREF(obj);
7494 8159 return;
8160 } else {
8161 PyErr_Clear();
7495 8162 }
7496 8163 }
7497 8164 genericBinaryFileWidget::changeEvent(arg__1);
7498 8165 }
7499 8166 void PythonQtShell_genericBinaryFileWidget::childEvent(QChildEvent* arg__1)
7500 8167 {
7501 if (_wrapper) {
7502 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
7503 PyErr_Clear();
7504 if (obj && !PythonQtSlotFunction_Check(obj)) {
8168 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8169 static PyObject* name = PyString_FromString("childEvent");
8170 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8171 if (obj) {
7505 8172 static const char* argumentList[] ={"" , "QChildEvent*"};
7506 8173 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7507 8174 void* args[2] = {NULL, (void*)&arg__1};
7508 8175 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7509 8176 if (result) { Py_DECREF(result); }
7510 8177 Py_DECREF(obj);
7511 8178 return;
8179 } else {
8180 PyErr_Clear();
7512 8181 }
7513 8182 }
7514 8183 genericBinaryFileWidget::childEvent(arg__1);
7515 8184 }
7516 8185 void PythonQtShell_genericBinaryFileWidget::closeEvent(QCloseEvent* arg__1)
7517 8186 {
7518 if (_wrapper) {
7519 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
7520 PyErr_Clear();
7521 if (obj && !PythonQtSlotFunction_Check(obj)) {
8187 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8188 static PyObject* name = PyString_FromString("closeEvent");
8189 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8190 if (obj) {
7522 8191 static const char* argumentList[] ={"" , "QCloseEvent*"};
7523 8192 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7524 8193 void* args[2] = {NULL, (void*)&arg__1};
7525 8194 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7526 8195 if (result) { Py_DECREF(result); }
7527 8196 Py_DECREF(obj);
7528 8197 return;
8198 } else {
8199 PyErr_Clear();
7529 8200 }
7530 8201 }
7531 8202 genericBinaryFileWidget::closeEvent(arg__1);
7532 8203 }
7533 8204 void PythonQtShell_genericBinaryFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
7534 8205 {
7535 if (_wrapper) {
7536 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
7537 PyErr_Clear();
7538 if (obj && !PythonQtSlotFunction_Check(obj)) {
8206 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8207 static PyObject* name = PyString_FromString("contextMenuEvent");
8208 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8209 if (obj) {
7539 8210 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
7540 8211 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7541 8212 void* args[2] = {NULL, (void*)&arg__1};
7542 8213 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7543 8214 if (result) { Py_DECREF(result); }
7544 8215 Py_DECREF(obj);
7545 8216 return;
8217 } else {
8218 PyErr_Clear();
7546 8219 }
7547 8220 }
7548 8221 genericBinaryFileWidget::contextMenuEvent(arg__1);
7549 8222 }
7550 8223 void PythonQtShell_genericBinaryFileWidget::customEvent(QEvent* arg__1)
7551 8224 {
7552 if (_wrapper) {
7553 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
7554 PyErr_Clear();
7555 if (obj && !PythonQtSlotFunction_Check(obj)) {
8225 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8226 static PyObject* name = PyString_FromString("customEvent");
8227 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8228 if (obj) {
7556 8229 static const char* argumentList[] ={"" , "QEvent*"};
7557 8230 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7558 8231 void* args[2] = {NULL, (void*)&arg__1};
7559 8232 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7560 8233 if (result) { Py_DECREF(result); }
7561 8234 Py_DECREF(obj);
7562 8235 return;
8236 } else {
8237 PyErr_Clear();
7563 8238 }
7564 8239 }
7565 8240 genericBinaryFileWidget::customEvent(arg__1);
7566 8241 }
7567 8242 int PythonQtShell_genericBinaryFileWidget::devType() const
7568 8243 {
7569 if (_wrapper) {
7570 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
7571 PyErr_Clear();
7572 if (obj && !PythonQtSlotFunction_Check(obj)) {
8244 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8245 static PyObject* name = PyString_FromString("devType");
8246 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8247 if (obj) {
7573 8248 static const char* argumentList[] ={"int"};
7574 8249 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7575 8250 int returnValue;
7576 8251 void* args[1] = {NULL};
7577 8252 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7578 8253 if (result) {
7579 8254 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7580 8255 if (args[0]!=&returnValue) {
7581 8256 if (args[0]==NULL) {
7582 8257 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
7583 8258 } else {
7584 8259 returnValue = *((int*)args[0]);
7585 8260 }
7586 8261 }
7587 8262 }
7588 8263 if (result) { Py_DECREF(result); }
7589 8264 Py_DECREF(obj);
7590 8265 return returnValue;
8266 } else {
8267 PyErr_Clear();
7591 8268 }
7592 8269 }
7593 8270 return genericBinaryFileWidget::devType();
7594 8271 }
7595 8272 void PythonQtShell_genericBinaryFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
7596 8273 {
7597 if (_wrapper) {
7598 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
7599 PyErr_Clear();
7600 if (obj && !PythonQtSlotFunction_Check(obj)) {
8274 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8275 static PyObject* name = PyString_FromString("dragEnterEvent");
8276 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8277 if (obj) {
7601 8278 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
7602 8279 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7603 8280 void* args[2] = {NULL, (void*)&arg__1};
7604 8281 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7605 8282 if (result) { Py_DECREF(result); }
7606 8283 Py_DECREF(obj);
7607 8284 return;
8285 } else {
8286 PyErr_Clear();
7608 8287 }
7609 8288 }
7610 8289 genericBinaryFileWidget::dragEnterEvent(arg__1);
7611 8290 }
7612 8291 void PythonQtShell_genericBinaryFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
7613 8292 {
7614 if (_wrapper) {
7615 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
7616 PyErr_Clear();
7617 if (obj && !PythonQtSlotFunction_Check(obj)) {
8293 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8294 static PyObject* name = PyString_FromString("dragLeaveEvent");
8295 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8296 if (obj) {
7618 8297 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
7619 8298 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7620 8299 void* args[2] = {NULL, (void*)&arg__1};
7621 8300 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7622 8301 if (result) { Py_DECREF(result); }
7623 8302 Py_DECREF(obj);
7624 8303 return;
8304 } else {
8305 PyErr_Clear();
7625 8306 }
7626 8307 }
7627 8308 genericBinaryFileWidget::dragLeaveEvent(arg__1);
7628 8309 }
7629 8310 void PythonQtShell_genericBinaryFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
7630 8311 {
7631 if (_wrapper) {
7632 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
7633 PyErr_Clear();
7634 if (obj && !PythonQtSlotFunction_Check(obj)) {
8312 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8313 static PyObject* name = PyString_FromString("dragMoveEvent");
8314 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8315 if (obj) {
7635 8316 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
7636 8317 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7637 8318 void* args[2] = {NULL, (void*)&arg__1};
7638 8319 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7639 8320 if (result) { Py_DECREF(result); }
7640 8321 Py_DECREF(obj);
7641 8322 return;
8323 } else {
8324 PyErr_Clear();
7642 8325 }
7643 8326 }
7644 8327 genericBinaryFileWidget::dragMoveEvent(arg__1);
7645 8328 }
7646 8329 void PythonQtShell_genericBinaryFileWidget::dropEvent(QDropEvent* arg__1)
7647 8330 {
7648 if (_wrapper) {
7649 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
7650 PyErr_Clear();
7651 if (obj && !PythonQtSlotFunction_Check(obj)) {
8331 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8332 static PyObject* name = PyString_FromString("dropEvent");
8333 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8334 if (obj) {
7652 8335 static const char* argumentList[] ={"" , "QDropEvent*"};
7653 8336 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7654 8337 void* args[2] = {NULL, (void*)&arg__1};
7655 8338 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7656 8339 if (result) { Py_DECREF(result); }
7657 8340 Py_DECREF(obj);
7658 8341 return;
8342 } else {
8343 PyErr_Clear();
7659 8344 }
7660 8345 }
7661 8346 genericBinaryFileWidget::dropEvent(arg__1);
7662 8347 }
7663 8348 void PythonQtShell_genericBinaryFileWidget::enterEvent(QEvent* arg__1)
7664 8349 {
7665 if (_wrapper) {
7666 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
7667 PyErr_Clear();
7668 if (obj && !PythonQtSlotFunction_Check(obj)) {
8350 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8351 static PyObject* name = PyString_FromString("enterEvent");
8352 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8353 if (obj) {
7669 8354 static const char* argumentList[] ={"" , "QEvent*"};
7670 8355 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7671 8356 void* args[2] = {NULL, (void*)&arg__1};
7672 8357 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7673 8358 if (result) { Py_DECREF(result); }
7674 8359 Py_DECREF(obj);
7675 8360 return;
8361 } else {
8362 PyErr_Clear();
7676 8363 }
7677 8364 }
7678 8365 genericBinaryFileWidget::enterEvent(arg__1);
7679 8366 }
7680 8367 bool PythonQtShell_genericBinaryFileWidget::event(QEvent* arg__1)
7681 8368 {
7682 if (_wrapper) {
7683 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
7684 PyErr_Clear();
7685 if (obj && !PythonQtSlotFunction_Check(obj)) {
8369 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8370 static PyObject* name = PyString_FromString("event");
8371 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8372 if (obj) {
7686 8373 static const char* argumentList[] ={"bool" , "QEvent*"};
7687 8374 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7688 8375 bool returnValue;
7689 8376 void* args[2] = {NULL, (void*)&arg__1};
7690 8377 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7691 8378 if (result) {
7692 8379 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7693 8380 if (args[0]!=&returnValue) {
7694 8381 if (args[0]==NULL) {
7695 8382 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
7696 8383 } else {
7697 8384 returnValue = *((bool*)args[0]);
7698 8385 }
7699 8386 }
7700 8387 }
7701 8388 if (result) { Py_DECREF(result); }
7702 8389 Py_DECREF(obj);
7703 8390 return returnValue;
8391 } else {
8392 PyErr_Clear();
7704 8393 }
7705 8394 }
7706 8395 return genericBinaryFileWidget::event(arg__1);
7707 8396 }
7708 8397 bool PythonQtShell_genericBinaryFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
7709 8398 {
7710 if (_wrapper) {
7711 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
7712 PyErr_Clear();
7713 if (obj && !PythonQtSlotFunction_Check(obj)) {
8399 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8400 static PyObject* name = PyString_FromString("eventFilter");
8401 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8402 if (obj) {
7714 8403 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
7715 8404 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
7716 8405 bool returnValue;
7717 8406 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
7718 8407 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7719 8408 if (result) {
7720 8409 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7721 8410 if (args[0]!=&returnValue) {
7722 8411 if (args[0]==NULL) {
7723 8412 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
7724 8413 } else {
7725 8414 returnValue = *((bool*)args[0]);
7726 8415 }
7727 8416 }
7728 8417 }
7729 8418 if (result) { Py_DECREF(result); }
7730 8419 Py_DECREF(obj);
7731 8420 return returnValue;
8421 } else {
8422 PyErr_Clear();
7732 8423 }
7733 8424 }
7734 8425 return genericBinaryFileWidget::eventFilter(arg__1, arg__2);
7735 8426 }
7736 8427 void PythonQtShell_genericBinaryFileWidget::focusInEvent(QFocusEvent* arg__1)
7737 8428 {
7738 if (_wrapper) {
7739 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
7740 PyErr_Clear();
7741 if (obj && !PythonQtSlotFunction_Check(obj)) {
8429 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8430 static PyObject* name = PyString_FromString("focusInEvent");
8431 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8432 if (obj) {
7742 8433 static const char* argumentList[] ={"" , "QFocusEvent*"};
7743 8434 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7744 8435 void* args[2] = {NULL, (void*)&arg__1};
7745 8436 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7746 8437 if (result) { Py_DECREF(result); }
7747 8438 Py_DECREF(obj);
7748 8439 return;
8440 } else {
8441 PyErr_Clear();
7749 8442 }
7750 8443 }
7751 8444 genericBinaryFileWidget::focusInEvent(arg__1);
7752 8445 }
7753 bool PythonQtShell_genericBinaryFileWidget::focusNextPrevChild(bool next)
7754 {
7755 if (_wrapper) {
7756 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
7757 PyErr_Clear();
7758 if (obj && !PythonQtSlotFunction_Check(obj)) {
8446 bool PythonQtShell_genericBinaryFileWidget::focusNextPrevChild(bool next0)
8447 {
8448 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8449 static PyObject* name = PyString_FromString("focusNextPrevChild");
8450 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8451 if (obj) {
7759 8452 static const char* argumentList[] ={"bool" , "bool"};
7760 8453 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7761 8454 bool returnValue;
7762 void* args[2] = {NULL, (void*)&next};
8455 void* args[2] = {NULL, (void*)&next0};
7763 8456 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7764 8457 if (result) {
7765 8458 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7766 8459 if (args[0]!=&returnValue) {
7767 8460 if (args[0]==NULL) {
7768 8461 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
7769 8462 } else {
7770 8463 returnValue = *((bool*)args[0]);
7771 8464 }
7772 8465 }
7773 8466 }
7774 8467 if (result) { Py_DECREF(result); }
7775 8468 Py_DECREF(obj);
7776 8469 return returnValue;
7777 }
7778 }
7779 return genericBinaryFileWidget::focusNextPrevChild(next);
8470 } else {
8471 PyErr_Clear();
8472 }
8473 }
8474 return genericBinaryFileWidget::focusNextPrevChild(next0);
7780 8475 }
7781 8476 void PythonQtShell_genericBinaryFileWidget::focusOutEvent(QFocusEvent* arg__1)
7782 8477 {
7783 if (_wrapper) {
7784 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
7785 PyErr_Clear();
7786 if (obj && !PythonQtSlotFunction_Check(obj)) {
8478 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8479 static PyObject* name = PyString_FromString("focusOutEvent");
8480 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8481 if (obj) {
7787 8482 static const char* argumentList[] ={"" , "QFocusEvent*"};
7788 8483 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7789 8484 void* args[2] = {NULL, (void*)&arg__1};
7790 8485 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7791 8486 if (result) { Py_DECREF(result); }
7792 8487 Py_DECREF(obj);
7793 8488 return;
8489 } else {
8490 PyErr_Clear();
7794 8491 }
7795 8492 }
7796 8493 genericBinaryFileWidget::focusOutEvent(arg__1);
7797 8494 }
7798 8495 bool PythonQtShell_genericBinaryFileWidget::hasHeightForWidth() const
7799 8496 {
7800 if (_wrapper) {
7801 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
7802 PyErr_Clear();
7803 if (obj && !PythonQtSlotFunction_Check(obj)) {
8497 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8498 static PyObject* name = PyString_FromString("hasHeightForWidth");
8499 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8500 if (obj) {
7804 8501 static const char* argumentList[] ={"bool"};
7805 8502 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7806 8503 bool returnValue;
7807 8504 void* args[1] = {NULL};
7808 8505 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7809 8506 if (result) {
7810 8507 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7811 8508 if (args[0]!=&returnValue) {
7812 8509 if (args[0]==NULL) {
7813 8510 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
7814 8511 } else {
7815 8512 returnValue = *((bool*)args[0]);
7816 8513 }
7817 8514 }
7818 8515 }
7819 8516 if (result) { Py_DECREF(result); }
7820 8517 Py_DECREF(obj);
7821 8518 return returnValue;
8519 } else {
8520 PyErr_Clear();
7822 8521 }
7823 8522 }
7824 8523 return genericBinaryFileWidget::hasHeightForWidth();
7825 8524 }
7826 8525 int PythonQtShell_genericBinaryFileWidget::heightForWidth(int arg__1) const
7827 8526 {
7828 if (_wrapper) {
7829 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
7830 PyErr_Clear();
7831 if (obj && !PythonQtSlotFunction_Check(obj)) {
8527 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8528 static PyObject* name = PyString_FromString("heightForWidth");
8529 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8530 if (obj) {
7832 8531 static const char* argumentList[] ={"int" , "int"};
7833 8532 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7834 8533 int returnValue;
7835 8534 void* args[2] = {NULL, (void*)&arg__1};
7836 8535 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7837 8536 if (result) {
7838 8537 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7839 8538 if (args[0]!=&returnValue) {
7840 8539 if (args[0]==NULL) {
7841 8540 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
7842 8541 } else {
7843 8542 returnValue = *((int*)args[0]);
7844 8543 }
7845 8544 }
7846 8545 }
7847 8546 if (result) { Py_DECREF(result); }
7848 8547 Py_DECREF(obj);
7849 8548 return returnValue;
8549 } else {
8550 PyErr_Clear();
7850 8551 }
7851 8552 }
7852 8553 return genericBinaryFileWidget::heightForWidth(arg__1);
7853 8554 }
7854 8555 void PythonQtShell_genericBinaryFileWidget::hideEvent(QHideEvent* arg__1)
7855 8556 {
7856 if (_wrapper) {
7857 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
7858 PyErr_Clear();
7859 if (obj && !PythonQtSlotFunction_Check(obj)) {
8557 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8558 static PyObject* name = PyString_FromString("hideEvent");
8559 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8560 if (obj) {
7860 8561 static const char* argumentList[] ={"" , "QHideEvent*"};
7861 8562 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7862 8563 void* args[2] = {NULL, (void*)&arg__1};
7863 8564 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7864 8565 if (result) { Py_DECREF(result); }
7865 8566 Py_DECREF(obj);
7866 8567 return;
8568 } else {
8569 PyErr_Clear();
7867 8570 }
7868 8571 }
7869 8572 genericBinaryFileWidget::hideEvent(arg__1);
7870 8573 }
7871 void PythonQtShell_genericBinaryFileWidget::initPainter(QPainter* painter) const
7872 {
7873 if (_wrapper) {
7874 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
7875 PyErr_Clear();
7876 if (obj && !PythonQtSlotFunction_Check(obj)) {
8574 void PythonQtShell_genericBinaryFileWidget::initPainter(QPainter* painter0) const
8575 {
8576 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8577 static PyObject* name = PyString_FromString("initPainter");
8578 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8579 if (obj) {
7877 8580 static const char* argumentList[] ={"" , "QPainter*"};
7878 8581 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7879 void* args[2] = {NULL, (void*)&painter};
7880 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7881 if (result) { Py_DECREF(result); }
7882 Py_DECREF(obj);
7883 return;
7884 }
7885 }
7886 genericBinaryFileWidget::initPainter(painter);
8582 void* args[2] = {NULL, (void*)&painter0};
8583 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8584 if (result) { Py_DECREF(result); }
8585 Py_DECREF(obj);
8586 return;
8587 } else {
8588 PyErr_Clear();
8589 }
8590 }
8591 genericBinaryFileWidget::initPainter(painter0);
7887 8592 }
7888 8593 void PythonQtShell_genericBinaryFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
7889 8594 {
7890 if (_wrapper) {
7891 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
7892 PyErr_Clear();
7893 if (obj && !PythonQtSlotFunction_Check(obj)) {
8595 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8596 static PyObject* name = PyString_FromString("inputMethodEvent");
8597 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8598 if (obj) {
7894 8599 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
7895 8600 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7896 8601 void* args[2] = {NULL, (void*)&arg__1};
7897 8602 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7898 8603 if (result) { Py_DECREF(result); }
7899 8604 Py_DECREF(obj);
7900 8605 return;
8606 } else {
8607 PyErr_Clear();
7901 8608 }
7902 8609 }
7903 8610 genericBinaryFileWidget::inputMethodEvent(arg__1);
7904 8611 }
7905 8612 QVariant PythonQtShell_genericBinaryFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
7906 8613 {
7907 if (_wrapper) {
7908 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
7909 PyErr_Clear();
7910 if (obj && !PythonQtSlotFunction_Check(obj)) {
8614 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8615 static PyObject* name = PyString_FromString("inputMethodQuery");
8616 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8617 if (obj) {
7911 8618 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
7912 8619 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7913 8620 QVariant returnValue;
7914 8621 void* args[2] = {NULL, (void*)&arg__1};
7915 8622 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7916 8623 if (result) {
7917 8624 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7918 8625 if (args[0]!=&returnValue) {
7919 8626 if (args[0]==NULL) {
7920 8627 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
7921 8628 } else {
7922 8629 returnValue = *((QVariant*)args[0]);
7923 8630 }
7924 8631 }
7925 8632 }
7926 8633 if (result) { Py_DECREF(result); }
7927 8634 Py_DECREF(obj);
7928 8635 return returnValue;
8636 } else {
8637 PyErr_Clear();
7929 8638 }
7930 8639 }
7931 8640 return genericBinaryFileWidget::inputMethodQuery(arg__1);
7932 8641 }
7933 8642 void PythonQtShell_genericBinaryFileWidget::keyPressEvent(QKeyEvent* arg__1)
7934 8643 {
7935 if (_wrapper) {
7936 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
7937 PyErr_Clear();
7938 if (obj && !PythonQtSlotFunction_Check(obj)) {
8644 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8645 static PyObject* name = PyString_FromString("keyPressEvent");
8646 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8647 if (obj) {
7939 8648 static const char* argumentList[] ={"" , "QKeyEvent*"};
7940 8649 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7941 8650 void* args[2] = {NULL, (void*)&arg__1};
7942 8651 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7943 8652 if (result) { Py_DECREF(result); }
7944 8653 Py_DECREF(obj);
7945 8654 return;
8655 } else {
8656 PyErr_Clear();
7946 8657 }
7947 8658 }
7948 8659 genericBinaryFileWidget::keyPressEvent(arg__1);
7949 8660 }
7950 8661 void PythonQtShell_genericBinaryFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
7951 8662 {
7952 if (_wrapper) {
7953 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
7954 PyErr_Clear();
7955 if (obj && !PythonQtSlotFunction_Check(obj)) {
8663 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8664 static PyObject* name = PyString_FromString("keyReleaseEvent");
8665 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8666 if (obj) {
7956 8667 static const char* argumentList[] ={"" , "QKeyEvent*"};
7957 8668 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7958 8669 void* args[2] = {NULL, (void*)&arg__1};
7959 8670 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7960 8671 if (result) { Py_DECREF(result); }
7961 8672 Py_DECREF(obj);
7962 8673 return;
8674 } else {
8675 PyErr_Clear();
7963 8676 }
7964 8677 }
7965 8678 genericBinaryFileWidget::keyReleaseEvent(arg__1);
7966 8679 }
7967 8680 void PythonQtShell_genericBinaryFileWidget::leaveEvent(QEvent* arg__1)
7968 8681 {
7969 if (_wrapper) {
7970 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
7971 PyErr_Clear();
7972 if (obj && !PythonQtSlotFunction_Check(obj)) {
8682 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8683 static PyObject* name = PyString_FromString("leaveEvent");
8684 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8685 if (obj) {
7973 8686 static const char* argumentList[] ={"" , "QEvent*"};
7974 8687 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7975 8688 void* args[2] = {NULL, (void*)&arg__1};
7976 8689 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7977 8690 if (result) { Py_DECREF(result); }
7978 8691 Py_DECREF(obj);
7979 8692 return;
8693 } else {
8694 PyErr_Clear();
7980 8695 }
7981 8696 }
7982 8697 genericBinaryFileWidget::leaveEvent(arg__1);
7983 8698 }
7984 8699 int PythonQtShell_genericBinaryFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
7985 8700 {
7986 if (_wrapper) {
7987 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
7988 PyErr_Clear();
7989 if (obj && !PythonQtSlotFunction_Check(obj)) {
8701 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8702 static PyObject* name = PyString_FromString("metric");
8703 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8704 if (obj) {
7990 8705 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
7991 8706 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7992 8707 int returnValue;
7993 8708 void* args[2] = {NULL, (void*)&arg__1};
7994 8709 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7995 8710 if (result) {
7996 8711 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7997 8712 if (args[0]!=&returnValue) {
7998 8713 if (args[0]==NULL) {
7999 8714 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
8000 8715 } else {
8001 8716 returnValue = *((int*)args[0]);
8002 8717 }
8003 8718 }
8004 8719 }
8005 8720 if (result) { Py_DECREF(result); }
8006 8721 Py_DECREF(obj);
8007 8722 return returnValue;
8723 } else {
8724 PyErr_Clear();
8008 8725 }
8009 8726 }
8010 8727 return genericBinaryFileWidget::metric(arg__1);
8011 8728 }
8012 8729 QSize PythonQtShell_genericBinaryFileWidget::minimumSizeHint() const
8013 8730 {
8014 if (_wrapper) {
8015 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
8016 PyErr_Clear();
8017 if (obj && !PythonQtSlotFunction_Check(obj)) {
8731 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8732 static PyObject* name = PyString_FromString("getMinimumSizeHint");
8733 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8734 if (obj) {
8018 8735 static const char* argumentList[] ={"QSize"};
8019 8736 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8020 8737 QSize returnValue;
8021 8738 void* args[1] = {NULL};
8022 8739 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8023 8740 if (result) {
8024 8741 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8025 8742 if (args[0]!=&returnValue) {
8026 8743 if (args[0]==NULL) {
8027 8744 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
8028 8745 } else {
8029 8746 returnValue = *((QSize*)args[0]);
8030 8747 }
8031 8748 }
8032 8749 }
8033 8750 if (result) { Py_DECREF(result); }
8034 8751 Py_DECREF(obj);
8035 8752 return returnValue;
8753 } else {
8754 PyErr_Clear();
8036 8755 }
8037 8756 }
8038 8757 return genericBinaryFileWidget::minimumSizeHint();
8039 8758 }
8040 8759 void PythonQtShell_genericBinaryFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
8041 8760 {
8042 if (_wrapper) {
8043 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
8044 PyErr_Clear();
8045 if (obj && !PythonQtSlotFunction_Check(obj)) {
8761 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8762 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
8763 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8764 if (obj) {
8046 8765 static const char* argumentList[] ={"" , "QMouseEvent*"};
8047 8766 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8048 8767 void* args[2] = {NULL, (void*)&arg__1};
8049 8768 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8050 8769 if (result) { Py_DECREF(result); }
8051 8770 Py_DECREF(obj);
8052 8771 return;
8772 } else {
8773 PyErr_Clear();
8053 8774 }
8054 8775 }
8055 8776 genericBinaryFileWidget::mouseDoubleClickEvent(arg__1);
8056 8777 }
8057 8778 void PythonQtShell_genericBinaryFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
8058 8779 {
8059 if (_wrapper) {
8060 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
8061 PyErr_Clear();
8062 if (obj && !PythonQtSlotFunction_Check(obj)) {
8780 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8781 static PyObject* name = PyString_FromString("mouseMoveEvent");
8782 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8783 if (obj) {
8063 8784 static const char* argumentList[] ={"" , "QMouseEvent*"};
8064 8785 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8065 8786 void* args[2] = {NULL, (void*)&arg__1};
8066 8787 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8067 8788 if (result) { Py_DECREF(result); }
8068 8789 Py_DECREF(obj);
8069 8790 return;
8791 } else {
8792 PyErr_Clear();
8070 8793 }
8071 8794 }
8072 8795 genericBinaryFileWidget::mouseMoveEvent(arg__1);
8073 8796 }
8074 8797 void PythonQtShell_genericBinaryFileWidget::mousePressEvent(QMouseEvent* arg__1)
8075 8798 {
8076 if (_wrapper) {
8077 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
8078 PyErr_Clear();
8079 if (obj && !PythonQtSlotFunction_Check(obj)) {
8799 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8800 static PyObject* name = PyString_FromString("mousePressEvent");
8801 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8802 if (obj) {
8080 8803 static const char* argumentList[] ={"" , "QMouseEvent*"};
8081 8804 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8082 8805 void* args[2] = {NULL, (void*)&arg__1};
8083 8806 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8084 8807 if (result) { Py_DECREF(result); }
8085 8808 Py_DECREF(obj);
8086 8809 return;
8810 } else {
8811 PyErr_Clear();
8087 8812 }
8088 8813 }
8089 8814 genericBinaryFileWidget::mousePressEvent(arg__1);
8090 8815 }
8091 8816 void PythonQtShell_genericBinaryFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
8092 8817 {
8093 if (_wrapper) {
8094 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
8095 PyErr_Clear();
8096 if (obj && !PythonQtSlotFunction_Check(obj)) {
8818 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8819 static PyObject* name = PyString_FromString("mouseReleaseEvent");
8820 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8821 if (obj) {
8097 8822 static const char* argumentList[] ={"" , "QMouseEvent*"};
8098 8823 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8099 8824 void* args[2] = {NULL, (void*)&arg__1};
8100 8825 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8101 8826 if (result) { Py_DECREF(result); }
8102 8827 Py_DECREF(obj);
8103 8828 return;
8829 } else {
8830 PyErr_Clear();
8104 8831 }
8105 8832 }
8106 8833 genericBinaryFileWidget::mouseReleaseEvent(arg__1);
8107 8834 }
8108 8835 void PythonQtShell_genericBinaryFileWidget::moveEvent(QMoveEvent* arg__1)
8109 8836 {
8110 if (_wrapper) {
8111 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
8112 PyErr_Clear();
8113 if (obj && !PythonQtSlotFunction_Check(obj)) {
8837 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8838 static PyObject* name = PyString_FromString("moveEvent");
8839 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8840 if (obj) {
8114 8841 static const char* argumentList[] ={"" , "QMoveEvent*"};
8115 8842 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8116 8843 void* args[2] = {NULL, (void*)&arg__1};
8117 8844 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8118 8845 if (result) { Py_DECREF(result); }
8119 8846 Py_DECREF(obj);
8120 8847 return;
8848 } else {
8849 PyErr_Clear();
8121 8850 }
8122 8851 }
8123 8852 genericBinaryFileWidget::moveEvent(arg__1);
8124 8853 }
8125 bool PythonQtShell_genericBinaryFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result)
8126 {
8127 if (_wrapper) {
8128 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
8129 PyErr_Clear();
8130 if (obj && !PythonQtSlotFunction_Check(obj)) {
8854 bool PythonQtShell_genericBinaryFileWidget::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
8855 {
8856 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8857 static PyObject* name = PyString_FromString("nativeEvent");
8858 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8859 if (obj) {
8131 8860 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
8132 8861 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
8133 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 8864 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8136 8865 if (result) {
8137 8866 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8138 8867 if (args[0]!=&returnValue) {
8139 8868 if (args[0]==NULL) {
8140 8869 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
8141 8870 } else {
8142 8871 returnValue = *((bool*)args[0]);
8143 8872 }
8144 8873 }
8145 8874 }
8146 8875 if (result) { Py_DECREF(result); }
8147 8876 Py_DECREF(obj);
8148 8877 return returnValue;
8149 }
8150 }
8151 return genericBinaryFileWidget::nativeEvent(eventType, message, result);
8878 } else {
8879 PyErr_Clear();
8880 }
8881 }
8882 return genericBinaryFileWidget::nativeEvent(eventType0, message1, result2);
8152 8883 }
8153 8884 QPaintEngine* PythonQtShell_genericBinaryFileWidget::paintEngine() const
8154 8885 {
8155 if (_wrapper) {
8156 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
8157 PyErr_Clear();
8158 if (obj && !PythonQtSlotFunction_Check(obj)) {
8886 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8887 static PyObject* name = PyString_FromString("paintEngine");
8888 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8889 if (obj) {
8159 8890 static const char* argumentList[] ={"QPaintEngine*"};
8160 8891 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8161 8892 QPaintEngine* returnValue;
8162 8893 void* args[1] = {NULL};
8163 8894 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8164 8895 if (result) {
8165 8896 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8166 8897 if (args[0]!=&returnValue) {
8167 8898 if (args[0]==NULL) {
8168 8899 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
8169 8900 } else {
8170 8901 returnValue = *((QPaintEngine**)args[0]);
8171 8902 }
8172 8903 }
8173 8904 }
8174 8905 if (result) { Py_DECREF(result); }
8175 8906 Py_DECREF(obj);
8176 8907 return returnValue;
8908 } else {
8909 PyErr_Clear();
8177 8910 }
8178 8911 }
8179 8912 return genericBinaryFileWidget::paintEngine();
8180 8913 }
8181 8914 void PythonQtShell_genericBinaryFileWidget::paintEvent(QPaintEvent* arg__1)
8182 8915 {
8183 if (_wrapper) {
8184 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
8185 PyErr_Clear();
8186 if (obj && !PythonQtSlotFunction_Check(obj)) {
8916 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8917 static PyObject* name = PyString_FromString("paintEvent");
8918 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8919 if (obj) {
8187 8920 static const char* argumentList[] ={"" , "QPaintEvent*"};
8188 8921 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8189 8922 void* args[2] = {NULL, (void*)&arg__1};
8190 8923 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8191 8924 if (result) { Py_DECREF(result); }
8192 8925 Py_DECREF(obj);
8193 8926 return;
8927 } else {
8928 PyErr_Clear();
8194 8929 }
8195 8930 }
8196 8931 genericBinaryFileWidget::paintEvent(arg__1);
8197 8932 }
8198 QPaintDevice* PythonQtShell_genericBinaryFileWidget::redirected(QPoint* offset) const
8199 {
8200 if (_wrapper) {
8201 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
8202 PyErr_Clear();
8203 if (obj && !PythonQtSlotFunction_Check(obj)) {
8933 QPaintDevice* PythonQtShell_genericBinaryFileWidget::redirected(QPoint* offset0) const
8934 {
8935 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8936 static PyObject* name = PyString_FromString("redirected");
8937 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8938 if (obj) {
8204 8939 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
8205 8940 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8206 8941 QPaintDevice* returnValue;
8207 void* args[2] = {NULL, (void*)&offset};
8942 void* args[2] = {NULL, (void*)&offset0};
8208 8943 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8209 8944 if (result) {
8210 8945 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8211 8946 if (args[0]!=&returnValue) {
8212 8947 if (args[0]==NULL) {
8213 8948 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
8214 8949 } else {
8215 8950 returnValue = *((QPaintDevice**)args[0]);
8216 8951 }
8217 8952 }
8218 8953 }
8219 8954 if (result) { Py_DECREF(result); }
8220 8955 Py_DECREF(obj);
8221 8956 return returnValue;
8222 }
8223 }
8224 return genericBinaryFileWidget::redirected(offset);
8957 } else {
8958 PyErr_Clear();
8959 }
8960 }
8961 return genericBinaryFileWidget::redirected(offset0);
8225 8962 }
8226 8963 void PythonQtShell_genericBinaryFileWidget::resizeEvent(QResizeEvent* arg__1)
8227 8964 {
8228 if (_wrapper) {
8229 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
8230 PyErr_Clear();
8231 if (obj && !PythonQtSlotFunction_Check(obj)) {
8965 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8966 static PyObject* name = PyString_FromString("resizeEvent");
8967 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8968 if (obj) {
8232 8969 static const char* argumentList[] ={"" , "QResizeEvent*"};
8233 8970 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8234 8971 void* args[2] = {NULL, (void*)&arg__1};
8235 8972 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8236 8973 if (result) { Py_DECREF(result); }
8237 8974 Py_DECREF(obj);
8238 8975 return;
8976 } else {
8977 PyErr_Clear();
8239 8978 }
8240 8979 }
8241 8980 genericBinaryFileWidget::resizeEvent(arg__1);
8242 8981 }
8243 8982 QPainter* PythonQtShell_genericBinaryFileWidget::sharedPainter() const
8244 8983 {
8245 if (_wrapper) {
8246 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
8247 PyErr_Clear();
8248 if (obj && !PythonQtSlotFunction_Check(obj)) {
8984 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8985 static PyObject* name = PyString_FromString("sharedPainter");
8986 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8987 if (obj) {
8249 8988 static const char* argumentList[] ={"QPainter*"};
8250 8989 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8251 8990 QPainter* returnValue;
8252 8991 void* args[1] = {NULL};
8253 8992 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8254 8993 if (result) {
8255 8994 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8256 8995 if (args[0]!=&returnValue) {
8257 8996 if (args[0]==NULL) {
8258 8997 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
8259 8998 } else {
8260 8999 returnValue = *((QPainter**)args[0]);
8261 9000 }
8262 9001 }
8263 9002 }
8264 9003 if (result) { Py_DECREF(result); }
8265 9004 Py_DECREF(obj);
8266 9005 return returnValue;
9006 } else {
9007 PyErr_Clear();
8267 9008 }
8268 9009 }
8269 9010 return genericBinaryFileWidget::sharedPainter();
8270 9011 }
8271 9012 void PythonQtShell_genericBinaryFileWidget::showEvent(QShowEvent* arg__1)
8272 9013 {
8273 if (_wrapper) {
8274 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
8275 PyErr_Clear();
8276 if (obj && !PythonQtSlotFunction_Check(obj)) {
9014 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9015 static PyObject* name = PyString_FromString("showEvent");
9016 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9017 if (obj) {
8277 9018 static const char* argumentList[] ={"" , "QShowEvent*"};
8278 9019 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8279 9020 void* args[2] = {NULL, (void*)&arg__1};
8280 9021 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8281 9022 if (result) { Py_DECREF(result); }
8282 9023 Py_DECREF(obj);
8283 9024 return;
9025 } else {
9026 PyErr_Clear();
8284 9027 }
8285 9028 }
8286 9029 genericBinaryFileWidget::showEvent(arg__1);
8287 9030 }
8288 9031 QSize PythonQtShell_genericBinaryFileWidget::sizeHint() const
8289 9032 {
8290 if (_wrapper) {
8291 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
8292 PyErr_Clear();
8293 if (obj && !PythonQtSlotFunction_Check(obj)) {
9033 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9034 static PyObject* name = PyString_FromString("getSizeHint");
9035 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9036 if (obj) {
8294 9037 static const char* argumentList[] ={"QSize"};
8295 9038 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8296 9039 QSize returnValue;
8297 9040 void* args[1] = {NULL};
8298 9041 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8299 9042 if (result) {
8300 9043 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8301 9044 if (args[0]!=&returnValue) {
8302 9045 if (args[0]==NULL) {
8303 9046 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
8304 9047 } else {
8305 9048 returnValue = *((QSize*)args[0]);
8306 9049 }
8307 9050 }
8308 9051 }
8309 9052 if (result) { Py_DECREF(result); }
8310 9053 Py_DECREF(obj);
8311 9054 return returnValue;
9055 } else {
9056 PyErr_Clear();
8312 9057 }
8313 9058 }
8314 9059 return genericBinaryFileWidget::sizeHint();
8315 9060 }
8316 9061 void PythonQtShell_genericBinaryFileWidget::tabletEvent(QTabletEvent* arg__1)
8317 9062 {
8318 if (_wrapper) {
8319 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
8320 PyErr_Clear();
8321 if (obj && !PythonQtSlotFunction_Check(obj)) {
9063 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9064 static PyObject* name = PyString_FromString("tabletEvent");
9065 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9066 if (obj) {
8322 9067 static const char* argumentList[] ={"" , "QTabletEvent*"};
8323 9068 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8324 9069 void* args[2] = {NULL, (void*)&arg__1};
8325 9070 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8326 9071 if (result) { Py_DECREF(result); }
8327 9072 Py_DECREF(obj);
8328 9073 return;
9074 } else {
9075 PyErr_Clear();
8329 9076 }
8330 9077 }
8331 9078 genericBinaryFileWidget::tabletEvent(arg__1);
8332 9079 }
8333 9080 void PythonQtShell_genericBinaryFileWidget::timerEvent(QTimerEvent* arg__1)
8334 9081 {
8335 if (_wrapper) {
8336 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
8337 PyErr_Clear();
8338 if (obj && !PythonQtSlotFunction_Check(obj)) {
9082 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9083 static PyObject* name = PyString_FromString("timerEvent");
9084 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9085 if (obj) {
8339 9086 static const char* argumentList[] ={"" , "QTimerEvent*"};
8340 9087 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8341 9088 void* args[2] = {NULL, (void*)&arg__1};
8342 9089 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8343 9090 if (result) { Py_DECREF(result); }
8344 9091 Py_DECREF(obj);
8345 9092 return;
9093 } else {
9094 PyErr_Clear();
8346 9095 }
8347 9096 }
8348 9097 genericBinaryFileWidget::timerEvent(arg__1);
8349 9098 }
8350 9099 void PythonQtShell_genericBinaryFileWidget::wheelEvent(QWheelEvent* arg__1)
8351 9100 {
8352 if (_wrapper) {
8353 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
8354 PyErr_Clear();
8355 if (obj && !PythonQtSlotFunction_Check(obj)) {
9101 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9102 static PyObject* name = PyString_FromString("wheelEvent");
9103 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9104 if (obj) {
8356 9105 static const char* argumentList[] ={"" , "QWheelEvent*"};
8357 9106 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8358 9107 void* args[2] = {NULL, (void*)&arg__1};
8359 9108 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8360 9109 if (result) { Py_DECREF(result); }
8361 9110 Py_DECREF(obj);
8362 9111 return;
9112 } else {
9113 PyErr_Clear();
8363 9114 }
8364 9115 }
8365 9116 genericBinaryFileWidget::wheelEvent(arg__1);
8366 9117 }
8367 9118 genericBinaryFileWidget* PythonQtWrapper_genericBinaryFileWidget::new_genericBinaryFileWidget(QWidget* parent)
8368 9119 {
8369 9120 return new PythonQtShell_genericBinaryFileWidget(parent); }
8370 9121
8371 9122
8372 9123
8373 9124 PythonQtShell_srecFile::~PythonQtShell_srecFile() {
8374 9125 PythonQtPrivate* priv = PythonQt::priv();
8375 9126 if (priv) { priv->shellClassDeleted(this); }
8376 9127 }
8377 9128 int PythonQtShell_srecFile::closeFile()
8378 9129 {
8379 if (_wrapper) {
8380 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
8381 PyErr_Clear();
8382 if (obj && !PythonQtSlotFunction_Check(obj)) {
9130 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9131 static PyObject* name = PyString_FromString("closeFile");
9132 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9133 if (obj) {
8383 9134 static const char* argumentList[] ={"int"};
8384 9135 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8385 9136 int returnValue;
8386 9137 void* args[1] = {NULL};
8387 9138 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8388 9139 if (result) {
8389 9140 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8390 9141 if (args[0]!=&returnValue) {
8391 9142 if (args[0]==NULL) {
8392 9143 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
8393 9144 } else {
8394 9145 returnValue = *((int*)args[0]);
8395 9146 }
8396 9147 }
8397 9148 }
8398 9149 if (result) { Py_DECREF(result); }
8399 9150 Py_DECREF(obj);
8400 9151 return returnValue;
9152 } else {
9153 PyErr_Clear();
8401 9154 }
8402 9155 }
8403 9156 return srecFile::closeFile();
8404 9157 }
8405 9158 QList<codeFragment* > PythonQtShell_srecFile::getFragments()
8406 9159 {
8407 if (_wrapper) {
8408 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
8409 PyErr_Clear();
8410 if (obj && !PythonQtSlotFunction_Check(obj)) {
9160 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9161 static PyObject* name = PyString_FromString("getFragments");
9162 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9163 if (obj) {
8411 9164 static const char* argumentList[] ={"QList<codeFragment* >"};
8412 9165 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8413 9166 QList<codeFragment* > returnValue;
8414 9167 void* args[1] = {NULL};
8415 9168 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8416 9169 if (result) {
8417 9170 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8418 9171 if (args[0]!=&returnValue) {
8419 9172 if (args[0]==NULL) {
8420 9173 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
8421 9174 } else {
8422 9175 returnValue = *((QList<codeFragment* >*)args[0]);
8423 9176 }
8424 9177 }
8425 9178 }
8426 9179 if (result) { Py_DECREF(result); }
8427 9180 Py_DECREF(obj);
8428 9181 return returnValue;
9182 } else {
9183 PyErr_Clear();
8429 9184 }
8430 9185 }
8431 9186 return srecFile::getFragments();
8432 9187 }
8433 9188 bool PythonQtShell_srecFile::isopened()
8434 9189 {
8435 if (_wrapper) {
8436 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
8437 PyErr_Clear();
8438 if (obj && !PythonQtSlotFunction_Check(obj)) {
9190 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9191 static PyObject* name = PyString_FromString("isopened");
9192 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9193 if (obj) {
8439 9194 static const char* argumentList[] ={"bool"};
8440 9195 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8441 9196 bool returnValue;
8442 9197 void* args[1] = {NULL};
8443 9198 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8444 9199 if (result) {
8445 9200 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8446 9201 if (args[0]!=&returnValue) {
8447 9202 if (args[0]==NULL) {
8448 9203 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
8449 9204 } else {
8450 9205 returnValue = *((bool*)args[0]);
8451 9206 }
8452 9207 }
8453 9208 }
8454 9209 if (result) { Py_DECREF(result); }
8455 9210 Py_DECREF(obj);
8456 9211 return returnValue;
9212 } else {
9213 PyErr_Clear();
8457 9214 }
8458 9215 }
8459 9216 return srecFile::isopened();
8460 9217 }
8461 bool PythonQtShell_srecFile::openFile(const QString& File)
8462 {
8463 if (_wrapper) {
8464 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
8465 PyErr_Clear();
8466 if (obj && !PythonQtSlotFunction_Check(obj)) {
9218 bool PythonQtShell_srecFile::openFile(const QString& File0)
9219 {
9220 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9221 static PyObject* name = PyString_FromString("openFile");
9222 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9223 if (obj) {
8467 9224 static const char* argumentList[] ={"bool" , "const QString&"};
8468 9225 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8469 9226 bool returnValue;
8470 void* args[2] = {NULL, (void*)&File};
9227 void* args[2] = {NULL, (void*)&File0};
8471 9228 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8472 9229 if (result) {
8473 9230 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8474 9231 if (args[0]!=&returnValue) {
8475 9232 if (args[0]==NULL) {
8476 9233 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
8477 9234 } else {
8478 9235 returnValue = *((bool*)args[0]);
8479 9236 }
8480 9237 }
8481 9238 }
8482 9239 if (result) { Py_DECREF(result); }
8483 9240 Py_DECREF(obj);
8484 9241 return returnValue;
8485 }
8486 }
8487 return srecFile::openFile(File);
8488 }
8489 bool PythonQtShell_srecFile::toBinary(const QString& File)
8490 {
8491 if (_wrapper) {
8492 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
8493 PyErr_Clear();
8494 if (obj && !PythonQtSlotFunction_Check(obj)) {
9242 } else {
9243 PyErr_Clear();
9244 }
9245 }
9246 return srecFile::openFile(File0);
9247 }
9248 bool PythonQtShell_srecFile::toBinary(const QString& File0)
9249 {
9250 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9251 static PyObject* name = PyString_FromString("toBinary");
9252 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9253 if (obj) {
8495 9254 static const char* argumentList[] ={"bool" , "const QString&"};
8496 9255 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8497 9256 bool returnValue;
8498 void* args[2] = {NULL, (void*)&File};
9257 void* args[2] = {NULL, (void*)&File0};
8499 9258 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8500 9259 if (result) {
8501 9260 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8502 9261 if (args[0]!=&returnValue) {
8503 9262 if (args[0]==NULL) {
8504 9263 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
8505 9264 } else {
8506 9265 returnValue = *((bool*)args[0]);
8507 9266 }
8508 9267 }
8509 9268 }
8510 9269 if (result) { Py_DECREF(result); }
8511 9270 Py_DECREF(obj);
8512 9271 return returnValue;
8513 }
8514 }
8515 return srecFile::toBinary(File);
8516 }
8517 bool PythonQtShell_srecFile::toSrec(const QString& File)
8518 {
8519 if (_wrapper) {
8520 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
8521 PyErr_Clear();
8522 if (obj && !PythonQtSlotFunction_Check(obj)) {
9272 } else {
9273 PyErr_Clear();
9274 }
9275 }
9276 return srecFile::toBinary(File0);
9277 }
9278 bool PythonQtShell_srecFile::toSrec(const QString& File0)
9279 {
9280 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9281 static PyObject* name = PyString_FromString("toSrec");
9282 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9283 if (obj) {
8523 9284 static const char* argumentList[] ={"bool" , "const QString&"};
8524 9285 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8525 9286 bool returnValue;
8526 void* args[2] = {NULL, (void*)&File};
9287 void* args[2] = {NULL, (void*)&File0};
8527 9288 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8528 9289 if (result) {
8529 9290 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8530 9291 if (args[0]!=&returnValue) {
8531 9292 if (args[0]==NULL) {
8532 9293 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
8533 9294 } else {
8534 9295 returnValue = *((bool*)args[0]);
8535 9296 }
8536 9297 }
8537 9298 }
8538 9299 if (result) { Py_DECREF(result); }
8539 9300 Py_DECREF(obj);
8540 9301 return returnValue;
8541 }
8542 }
8543 return srecFile::toSrec(File);
9302 } else {
9303 PyErr_Clear();
9304 }
9305 }
9306 return srecFile::toSrec(File0);
8544 9307 }
8545 9308 srecFile* PythonQtWrapper_srecFile::new_srecFile()
8546 9309 {
8547 9310 return new PythonQtShell_srecFile(); }
8548 9311
8549 9312 srecFile* PythonQtWrapper_srecFile::new_srecFile(const QString& File)
8550 9313 {
8551 9314 return new PythonQtShell_srecFile(File); }
8552 9315
8553 9316 srecFile* PythonQtWrapper_srecFile::new_srecFile(const QStringList& Files)
8554 9317 {
8555 9318 return new PythonQtShell_srecFile(Files); }
8556 9319
8557 9320 bool PythonQtWrapper_srecFile::static_srecFile_checkSum(const QString& line)
8558 9321 {
8559 9322 return (srecFile::checkSum(line));
8560 9323 }
8561 9324
8562 9325 int PythonQtWrapper_srecFile::closeFile(srecFile* theWrappedObject)
8563 9326 {
8564 9327 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_closeFile());
8565 9328 }
8566 9329
8567 9330 codeFragment* PythonQtWrapper_srecFile::getFragment(srecFile* theWrappedObject, int index)
8568 9331 {
8569 9332 return ( theWrappedObject->getFragment(index));
8570 9333 }
8571 9334
8572 9335 int PythonQtWrapper_srecFile::getFragmentAddress(srecFile* theWrappedObject, int index)
8573 9336 {
8574 9337 return ( theWrappedObject->getFragmentAddress(index));
8575 9338 }
8576 9339
8577 9340 bool PythonQtWrapper_srecFile::getFragmentData(srecFile* theWrappedObject, int index, char** buffer)
8578 9341 {
8579 9342 return ( theWrappedObject->getFragmentData(index, buffer));
8580 9343 }
8581 9344
8582 9345 QString PythonQtWrapper_srecFile::getFragmentHeader(srecFile* theWrappedObject, int index)
8583 9346 {
8584 9347 return ( theWrappedObject->getFragmentHeader(index));
8585 9348 }
8586 9349
8587 9350 int PythonQtWrapper_srecFile::getFragmentSize(srecFile* theWrappedObject, int index)
8588 9351 {
8589 9352 return ( theWrappedObject->getFragmentSize(index));
8590 9353 }
8591 9354
8592 9355 QList<codeFragment* > PythonQtWrapper_srecFile::getFragments(srecFile* theWrappedObject)
8593 9356 {
8594 9357 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_getFragments());
8595 9358 }
8596 9359
8597 9360 int PythonQtWrapper_srecFile::getFragmentsCount(srecFile* theWrappedObject)
8598 9361 {
8599 9362 return ( theWrappedObject->getFragmentsCount());
8600 9363 }
8601 9364
8602 9365 bool PythonQtWrapper_srecFile::isSREC(srecFile* theWrappedObject)
8603 9366 {
8604 9367 return ( theWrappedObject->isSREC());
8605 9368 }
8606 9369
8607 9370 bool PythonQtWrapper_srecFile::static_srecFile_isSREC(const QString& File)
8608 9371 {
8609 9372 return (srecFile::isSREC(File));
8610 9373 }
8611 9374
8612 9375 bool PythonQtWrapper_srecFile::isopened(srecFile* theWrappedObject)
8613 9376 {
8614 9377 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_isopened());
8615 9378 }
8616 9379
8617 9380 int PythonQtWrapper_srecFile::lineCount(srecFile* theWrappedObject)
8618 9381 {
8619 9382 return ( theWrappedObject->lineCount());
8620 9383 }
8621 9384
8622 9385 bool PythonQtWrapper_srecFile::mergingRecords(srecFile* theWrappedObject)
8623 9386 {
8624 9387 return ( theWrappedObject->mergingRecords());
8625 9388 }
8626 9389
8627 9390 bool PythonQtWrapper_srecFile::openFile(srecFile* theWrappedObject, const QString& File)
8628 9391 {
8629 9392 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_openFile(File));
8630 9393 }
8631 9394
8632 9395 bool PythonQtWrapper_srecFile::openFiles(srecFile* theWrappedObject, const QStringList& Files)
8633 9396 {
8634 9397 return ( theWrappedObject->openFiles(Files));
8635 9398 }
8636 9399
8637 9400 void PythonQtWrapper_srecFile::setMergingRecords(srecFile* theWrappedObject, bool enabled)
8638 9401 {
8639 9402 ( theWrappedObject->setMergingRecords(enabled));
8640 9403 }
8641 9404
8642 9405 bool PythonQtWrapper_srecFile::toBinary(srecFile* theWrappedObject, const QString& File)
8643 9406 {
8644 9407 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_toBinary(File));
8645 9408 }
8646 9409
8647 9410 bool PythonQtWrapper_srecFile::static_srecFile_toSrec(QList<codeFragment* > fragments, const QString& File)
8648 9411 {
8649 9412 return (srecFile::toSrec(fragments, File));
8650 9413 }
8651 9414
8652 9415 bool PythonQtWrapper_srecFile::toSrec(srecFile* theWrappedObject, const QString& File)
8653 9416 {
8654 9417 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_toSrec(File));
8655 9418 }
8656 9419
8657 9420
8658 9421
8659 9422 PythonQtShell_srecFileWidget::~PythonQtShell_srecFileWidget() {
8660 9423 PythonQtPrivate* priv = PythonQt::priv();
8661 9424 if (priv) { priv->shellClassDeleted(this); }
8662 9425 }
8663 9426 void PythonQtShell_srecFileWidget::reloadFile()
8664 9427 {
8665 if (_wrapper) {
8666 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
8667 PyErr_Clear();
8668 if (obj && !PythonQtSlotFunction_Check(obj)) {
9428 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9429 static PyObject* name = PyString_FromString("reloadFile");
9430 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9431 if (obj) {
8669 9432 static const char* argumentList[] ={""};
8670 9433 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8671 9434 void* args[1] = {NULL};
8672 9435 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8673 9436 if (result) { Py_DECREF(result); }
8674 9437 Py_DECREF(obj);
8675 9438 return;
9439 } else {
9440 PyErr_Clear();
8676 9441 }
8677 9442 }
8678 9443 srecFileWidget::reloadFile();
8679 9444 }
8680 void PythonQtShell_srecFileWidget::setFile(abstractBinFile* file)
8681 {
8682 if (_wrapper) {
8683 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
8684 PyErr_Clear();
8685 if (obj && !PythonQtSlotFunction_Check(obj)) {
9445 void PythonQtShell_srecFileWidget::setFile(abstractBinFile* file0)
9446 {
9447 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9448 static PyObject* name = PyString_FromString("setFile");
9449 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9450 if (obj) {
8686 9451 static const char* argumentList[] ={"" , "abstractBinFile*"};
8687 9452 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8688 void* args[2] = {NULL, (void*)&file};
8689 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8690 if (result) { Py_DECREF(result); }
8691 Py_DECREF(obj);
8692 return;
8693 }
8694 }
8695 srecFileWidget::setFile(file);
9453 void* args[2] = {NULL, (void*)&file0};
9454 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9455 if (result) { Py_DECREF(result); }
9456 Py_DECREF(obj);
9457 return;
9458 } else {
9459 PyErr_Clear();
9460 }
9461 }
9462 srecFileWidget::setFile(file0);
8696 9463 }
8697 9464 srecFileWidget* PythonQtWrapper_srecFileWidget::new_srecFileWidget(QWidget* parent)
8698 9465 {
8699 9466 return new PythonQtShell_srecFileWidget(parent); }
8700 9467
8701 9468 void PythonQtWrapper_srecFileWidget::reloadFile(srecFileWidget* theWrappedObject)
8702 9469 {
8703 9470 ( ((PythonQtPublicPromoter_srecFileWidget*)theWrappedObject)->promoted_reloadFile());
8704 9471 }
8705 9472
8706 9473 void PythonQtWrapper_srecFileWidget::setFile(srecFileWidget* theWrappedObject, abstractBinFile* file)
8707 9474 {
8708 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 1 #include <PythonQt.h>
2 #include <QIconEngine>
3 2 #include <QObject>
4 3 #include <QVariant>
5 4 #include <SocExplorerPlot.h>
6 5 #include <abstractbinfile.h>
7 6 #include <binaryfile.h>
8 7 #include <binaryfilewidget.h>
9 8 #include <elffile.h>
10 9 #include <elffilewidget.h>
11 10 #include <elfinfowdgt.h>
12 11 #include <elfparser.h>
13 12 #include <genericbinaryfilewidget.h>
14 13 #include <memsizewdgt.h>
15 14 #include <qaction.h>
15 #include <qbackingstore.h>
16 16 #include <qbitmap.h>
17 17 #include <qbytearray.h>
18 18 #include <qcolor.h>
19 19 #include <qcoreevent.h>
20 20 #include <qcursor.h>
21 21 #include <qevent.h>
22 22 #include <qfile.h>
23 23 #include <qfont.h>
24 24 #include <qgraphicseffect.h>
25 25 #include <qgraphicsproxywidget.h>
26 26 #include <qhexedit.h>
27 27 #include <qhexspinbox.h>
28 #include <qicon.h>
28 29 #include <qkeysequence.h>
29 30 #include <qlayout.h>
30 31 #include <qlineedit.h>
31 32 #include <qlist.h>
32 33 #include <qlocale.h>
33 34 #include <qmargins.h>
35 #include <qmetaobject.h>
34 36 #include <qobject.h>
35 37 #include <qpaintdevice.h>
36 38 #include <qpaintengine.h>
37 39 #include <qpainter.h>
38 40 #include <qpalette.h>
39 41 #include <qpen.h>
40 42 #include <qpixmap.h>
41 43 #include <qpoint.h>
42 44 #include <qrect.h>
43 45 #include <qregion.h>
44 46 #include <qscrollarea.h>
45 47 #include <qscrollbar.h>
46 48 #include <qsize.h>
47 49 #include <qsizepolicy.h>
48 50 #include <qspinbox.h>
49 51 #include <qstringlist.h>
50 52 #include <qstyle.h>
51 53 #include <qstyleoption.h>
52 54 #include <qwidget.h>
55 #include <qwindow.h>
53 56 #include <srecfile.h>
54 57 #include <srecfilewidget.h>
55 58 #include <tcp_terminal_client.h>
56 59 #include <xbytearray.h>
57 60
58 61
59 62
60 63 class PythonQtShell_ElfFile : public ElfFile
61 64 {
62 65 public:
63 PythonQtShell_ElfFile():ElfFile(),_wrapper(NULL) {};
64 PythonQtShell_ElfFile(const QString& File):ElfFile(File),_wrapper(NULL) {};
66 PythonQtShell_ElfFile():ElfFile(),_wrapper(NULL) { };
67 PythonQtShell_ElfFile(const QString& File):ElfFile(File),_wrapper(NULL) { };
65 68
66 69 ~PythonQtShell_ElfFile();
67 70
68 71 virtual int closeFile();
69 72 virtual QList<codeFragment* > getFragments();
70 73 virtual bool isopened();
71 74 virtual bool openFile(const QString& File);
72 75 virtual bool toBinary(const QString& File);
73 76 virtual bool toSrec(const QString& File);
74 77
75 78 PythonQtInstanceWrapper* _wrapper;
76 79 };
77 80
78 81 class PythonQtPublicPromoter_ElfFile : public ElfFile
79 82 { public:
80 83 inline int promoted_closeFile() { return ElfFile::closeFile(); }
81 84 inline QList<codeFragment* > promoted_getFragments() { return ElfFile::getFragments(); }
82 85 inline bool promoted_isopened() { return ElfFile::isopened(); }
83 86 inline bool promoted_openFile(const QString& File) { return ElfFile::openFile(File); }
84 87 inline bool promoted_toBinary(const QString& File) { return ElfFile::toBinary(File); }
85 88 inline bool promoted_toSrec(const QString& File) { return ElfFile::toSrec(File); }
86 89 };
87 90
88 91 class PythonQtWrapper_ElfFile : public QObject
89 92 { Q_OBJECT
90 93 public:
91 94 public slots:
92 95 ElfFile* new_ElfFile();
93 96 ElfFile* new_ElfFile(const QString& File);
94 97 void delete_ElfFile(ElfFile* obj) { delete obj; }
95 98 int closeFile(ElfFile* theWrappedObject);
96 99 QString getABI(ElfFile* theWrappedObject);
97 100 QString getArchitecture(ElfFile* theWrappedObject);
98 101 QString getClass(ElfFile* theWrappedObject);
99 102 QString getEndianness(ElfFile* theWrappedObject);
100 103 qint64 getEntryPointAddress(ElfFile* theWrappedObject);
101 104 QList<codeFragment* > getFragments(ElfFile* theWrappedObject);
102 105 QList<codeFragment* > getFragments(ElfFile* theWrappedObject, QStringList fragmentList);
103 106 int getSectionCount(ElfFile* theWrappedObject);
104 107 bool getSectionData(ElfFile* theWrappedObject, int index, char** buffer);
105 108 qint64 getSectionDatasz(ElfFile* theWrappedObject, int index);
106 109 int getSectionIndex(ElfFile* theWrappedObject, QString name);
107 110 qint64 getSectionMemsz(ElfFile* theWrappedObject, int index);
108 111 QString getSectionName(ElfFile* theWrappedObject, int index);
109 112 qint64 getSectionPaddr(ElfFile* theWrappedObject, int index);
110 113 QString getSectionType(ElfFile* theWrappedObject, int index);
111 114 int getSegmentCount(ElfFile* theWrappedObject);
112 115 qint64 getSegmentFilesz(ElfFile* theWrappedObject, int index);
113 116 QString getSegmentFlags(ElfFile* theWrappedObject, int index);
114 117 qint64 getSegmentMemsz(ElfFile* theWrappedObject, int index);
115 118 qint64 getSegmentOffset(ElfFile* theWrappedObject, int index);
116 119 qint64 getSegmentPaddr(ElfFile* theWrappedObject, int index);
117 120 QString getSegmentType(ElfFile* theWrappedObject, int index);
118 121 qint64 getSegmentVaddr(ElfFile* theWrappedObject, int index);
119 122 quint64 getSymbolAddress(ElfFile* theWrappedObject, int index);
120 123 int getSymbolCount(ElfFile* theWrappedObject);
121 124 QString getSymbolLinkType(ElfFile* theWrappedObject, int index);
122 125 QString getSymbolName(ElfFile* theWrappedObject, int index);
123 126 int getSymbolSectionIndex(ElfFile* theWrappedObject, int index);
124 127 QString getSymbolSectionName(ElfFile* theWrappedObject, int index);
125 128 quint64 getSymbolSize(ElfFile* theWrappedObject, int index);
126 129 QString getSymbolType(ElfFile* theWrappedObject, int index);
127 130 QString getType(ElfFile* theWrappedObject);
128 131 qint64 getVersion(ElfFile* theWrappedObject);
132 bool isBigEndian(ElfFile* theWrappedObject);
129 133 bool static_ElfFile_isElf(const QString& File);
134 bool isLitleEndian(ElfFile* theWrappedObject);
130 135 bool iself(ElfFile* theWrappedObject);
131 136 bool isopened(ElfFile* theWrappedObject);
132 137 bool openFile(ElfFile* theWrappedObject, const QString& File);
133 138 bool sectionIsNobits(ElfFile* theWrappedObject, int index);
134 139 bool toBinary(ElfFile* theWrappedObject, const QString& File);
135 140 bool toSrec(ElfFile* theWrappedObject, const QString& File);
136 141 };
137 142
138 143
139 144
140 145
141 146
142 147 class PythonQtShell_MemSizeWdgt : public MemSizeWdgt
143 148 {
144 149 public:
145 PythonQtShell_MemSizeWdgt(QWidget* parent = 0):MemSizeWdgt(parent),_wrapper(NULL) {};
146 PythonQtShell_MemSizeWdgt(int defaultSize, QWidget* parent = 0):MemSizeWdgt(defaultSize, parent),_wrapper(NULL) {};
150 PythonQtShell_MemSizeWdgt(QWidget* parent = 0):MemSizeWdgt(parent),_wrapper(NULL) { };
151 PythonQtShell_MemSizeWdgt(int defaultSize, QWidget* parent = 0):MemSizeWdgt(defaultSize, parent),_wrapper(NULL) { };
147 152
148 153 ~PythonQtShell_MemSizeWdgt();
149 154
150 155 virtual void actionEvent(QActionEvent* arg__1);
151 156 virtual void changeEvent(QEvent* arg__1);
152 157 virtual void childEvent(QChildEvent* arg__1);
153 158 virtual void closeEvent(QCloseEvent* arg__1);
154 159 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
155 160 virtual void customEvent(QEvent* arg__1);
156 161 virtual int devType() const;
157 162 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
158 163 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
159 164 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
160 165 virtual void dropEvent(QDropEvent* arg__1);
161 166 virtual void enterEvent(QEvent* arg__1);
162 167 virtual bool event(QEvent* arg__1);
163 168 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
164 169 virtual void focusInEvent(QFocusEvent* arg__1);
165 170 virtual bool focusNextPrevChild(bool next);
166 171 virtual void focusOutEvent(QFocusEvent* arg__1);
167 172 virtual bool hasHeightForWidth() const;
168 173 virtual int heightForWidth(int arg__1) const;
169 174 virtual void hideEvent(QHideEvent* arg__1);
170 175 virtual void initPainter(QPainter* painter) const;
171 176 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
172 177 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
173 178 virtual void keyPressEvent(QKeyEvent* arg__1);
174 179 virtual void keyReleaseEvent(QKeyEvent* arg__1);
175 180 virtual void leaveEvent(QEvent* arg__1);
176 181 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
177 182 virtual QSize minimumSizeHint() const;
178 183 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
179 184 virtual void mouseMoveEvent(QMouseEvent* arg__1);
180 185 virtual void mousePressEvent(QMouseEvent* arg__1);
181 186 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
182 187 virtual void moveEvent(QMoveEvent* arg__1);
183 188 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
184 189 virtual QPaintEngine* paintEngine() const;
185 190 virtual void paintEvent(QPaintEvent* arg__1);
186 191 virtual QPaintDevice* redirected(QPoint* offset) const;
187 192 virtual void resizeEvent(QResizeEvent* arg__1);
188 193 virtual QPainter* sharedPainter() const;
189 194 virtual void showEvent(QShowEvent* arg__1);
190 195 virtual QSize sizeHint() const;
191 196 virtual void tabletEvent(QTabletEvent* arg__1);
192 197 virtual void timerEvent(QTimerEvent* arg__1);
193 198 virtual void wheelEvent(QWheelEvent* arg__1);
194 199
195 200 PythonQtInstanceWrapper* _wrapper;
196 201 };
197 202
198 203 class PythonQtWrapper_MemSizeWdgt : public QObject
199 204 { Q_OBJECT
200 205 public:
201 206 public slots:
202 207 MemSizeWdgt* new_MemSizeWdgt(QWidget* parent = 0);
203 208 MemSizeWdgt* new_MemSizeWdgt(int defaultSize, QWidget* parent = 0);
204 209 void delete_MemSizeWdgt(MemSizeWdgt* obj) { delete obj; }
205 210 int getsize(MemSizeWdgt* theWrappedObject);
206 211 void setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max);
207 212 void show(MemSizeWdgt* theWrappedObject);
208 213 void updateSizeValue(MemSizeWdgt* theWrappedObject);
209 214 };
210 215
211 216
212 217
213 218
214 219
215 220 class PythonQtShell_QHexEdit : public QHexEdit
216 221 {
217 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 225 ~PythonQtShell_QHexEdit();
221 226
222 227 virtual void actionEvent(QActionEvent* arg__1);
223 228 virtual void changeEvent(QEvent* arg__1);
224 229 virtual void childEvent(QChildEvent* arg__1);
225 230 virtual void closeEvent(QCloseEvent* arg__1);
226 231 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
227 232 virtual void customEvent(QEvent* arg__1);
228 233 virtual int devType() const;
229 234 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
230 235 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
231 236 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
232 237 virtual void dropEvent(QDropEvent* arg__1);
233 238 virtual void enterEvent(QEvent* arg__1);
234 239 virtual bool event(QEvent* arg__1);
235 240 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
236 241 virtual void focusInEvent(QFocusEvent* arg__1);
237 242 virtual bool focusNextPrevChild(bool next);
238 243 virtual void focusOutEvent(QFocusEvent* arg__1);
239 244 virtual bool hasHeightForWidth() const;
240 245 virtual int heightForWidth(int arg__1) const;
241 246 virtual void hideEvent(QHideEvent* arg__1);
242 247 virtual void initPainter(QPainter* painter) const;
243 248 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
244 249 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
245 250 virtual void keyPressEvent(QKeyEvent* arg__1);
246 251 virtual void keyReleaseEvent(QKeyEvent* arg__1);
247 252 virtual void leaveEvent(QEvent* arg__1);
248 253 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
249 254 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
250 255 virtual void mouseMoveEvent(QMouseEvent* arg__1);
251 256 virtual void mousePressEvent(QMouseEvent* arg__1);
252 257 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
253 258 virtual void moveEvent(QMoveEvent* arg__1);
254 259 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
255 260 virtual QPaintEngine* paintEngine() const;
256 261 virtual void paintEvent(QPaintEvent* arg__1);
257 262 virtual QPaintDevice* redirected(QPoint* offset) const;
258 263 virtual void resizeEvent(QResizeEvent* arg__1);
259 264 virtual void scrollContentsBy(int dx, int dy);
260 265 virtual void setupViewport(QWidget* viewport);
261 266 virtual QPainter* sharedPainter() const;
262 267 virtual void showEvent(QShowEvent* arg__1);
263 268 virtual void tabletEvent(QTabletEvent* arg__1);
264 269 virtual void timerEvent(QTimerEvent* arg__1);
265 270 virtual bool viewportEvent(QEvent* arg__1);
266 271 virtual QSize viewportSizeHint() const;
267 272 virtual void wheelEvent(QWheelEvent* arg__1);
268 273
269 274 PythonQtInstanceWrapper* _wrapper;
270 275 };
271 276
272 277 class PythonQtWrapper_QHexEdit : public QObject
273 278 { Q_OBJECT
274 279 public:
275 280 public slots:
276 281 QHexEdit* new_QHexEdit(QWidget* parent = 0);
277 282 void delete_QHexEdit(QHexEdit* obj) { delete obj; }
278 283 QColor addressAreaColor(QHexEdit* theWrappedObject);
279 284 int addressOffset(QHexEdit* theWrappedObject);
280 285 int cursorPosition(QHexEdit* theWrappedObject);
281 286 QByteArray data(QHexEdit* theWrappedObject);
282 287 const QFont* font(QHexEdit* theWrappedObject) const;
283 288 int getSelectionBegin(QHexEdit* theWrappedObject);
284 289 int getSelectionEnd(QHexEdit* theWrappedObject);
285 290 QColor highlightingColor(QHexEdit* theWrappedObject);
286 291 int indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
287 292 void insert(QHexEdit* theWrappedObject, int i, char ch);
288 293 void insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba);
289 294 bool isReadOnly(QHexEdit* theWrappedObject);
290 295 int lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
291 296 bool overwriteMode(QHexEdit* theWrappedObject);
292 297 void remove(QHexEdit* theWrappedObject, int pos, int len = 1);
293 298 void replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after);
294 299 void resetSelection(QHexEdit* theWrappedObject);
295 300 void resetSelection(QHexEdit* theWrappedObject, int pos);
296 301 QColor selectionColor(QHexEdit* theWrappedObject);
297 302 QString selectionToReadableString(QHexEdit* theWrappedObject);
298 303 void setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color);
299 304 void setAddressOffset(QHexEdit* theWrappedObject, int offset);
300 305 void setCursorPosition(QHexEdit* theWrappedObject, int cusorPos);
301 306 void setData(QHexEdit* theWrappedObject, const QByteArray& data);
302 307 void setFont(QHexEdit* theWrappedObject, const QFont& arg__1);
303 308 void setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color);
304 309 void setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1);
305 310 void setReadOnly(QHexEdit* theWrappedObject, bool arg__1);
306 311 void setSelection(QHexEdit* theWrappedObject, int pos);
307 312 void setSelectionColor(QHexEdit* theWrappedObject, const QColor& color);
308 313 QString toReadableString(QHexEdit* theWrappedObject);
309 314 };
310 315
311 316
312 317
313 318
314 319
315 320 class PythonQtShell_QHexSpinBox : public QHexSpinBox
316 321 {
317 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 325 ~PythonQtShell_QHexSpinBox();
321 326
322 327 virtual void actionEvent(QActionEvent* arg__1);
323 328 virtual void changeEvent(QEvent* event);
324 329 virtual void childEvent(QChildEvent* arg__1);
325 330 virtual void clear();
326 331 virtual void closeEvent(QCloseEvent* event);
327 332 virtual void contextMenuEvent(QContextMenuEvent* event);
328 333 virtual void customEvent(QEvent* arg__1);
329 334 virtual int devType() const;
330 335 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
331 336 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
332 337 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
333 338 virtual void dropEvent(QDropEvent* arg__1);
334 339 virtual void enterEvent(QEvent* arg__1);
335 340 virtual bool event(QEvent* event);
336 341 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
337 342 virtual void fixup(QString& str) const;
338 343 virtual void focusInEvent(QFocusEvent* event);
339 344 virtual bool focusNextPrevChild(bool next);
340 345 virtual void focusOutEvent(QFocusEvent* event);
341 346 virtual bool hasHeightForWidth() const;
342 347 virtual int heightForWidth(int arg__1) const;
343 348 virtual void hideEvent(QHideEvent* event);
344 349 virtual void initPainter(QPainter* painter) const;
345 350 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
346 351 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
347 352 virtual void keyPressEvent(QKeyEvent* event);
348 353 virtual void keyReleaseEvent(QKeyEvent* event);
349 354 virtual void leaveEvent(QEvent* arg__1);
350 355 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
351 356 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
352 357 virtual void mouseMoveEvent(QMouseEvent* event);
353 358 virtual void mousePressEvent(QMouseEvent* event);
354 359 virtual void mouseReleaseEvent(QMouseEvent* event);
355 360 virtual void moveEvent(QMoveEvent* arg__1);
356 361 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
357 362 virtual QPaintEngine* paintEngine() const;
358 363 virtual void paintEvent(QPaintEvent* event);
359 364 virtual QPaintDevice* redirected(QPoint* offset) const;
360 365 virtual void resizeEvent(QResizeEvent* event);
361 366 virtual QPainter* sharedPainter() const;
362 367 virtual void showEvent(QShowEvent* event);
363 368 virtual void stepBy(int steps);
364 369 virtual QAbstractSpinBox::StepEnabled stepEnabled() const;
365 370 virtual void tabletEvent(QTabletEvent* arg__1);
366 371 virtual QString textFromValue(int value) const;
367 372 virtual void timerEvent(QTimerEvent* event);
368 373 virtual QValidator::State validate(QString& input, int& pos) const;
369 374 virtual int valueFromText(const QString& text) const;
370 375 virtual void wheelEvent(QWheelEvent* event);
371 376
372 377 PythonQtInstanceWrapper* _wrapper;
373 378 };
374 379
375 380 class PythonQtPublicPromoter_QHexSpinBox : public QHexSpinBox
376 381 { public:
377 382 inline QString promoted_textFromValue(int value) const { return QHexSpinBox::textFromValue(value); }
378 383 inline QValidator::State promoted_validate(QString& input, int& pos) const { return QHexSpinBox::validate(input, pos); }
379 384 inline int promoted_valueFromText(const QString& text) const { return QHexSpinBox::valueFromText(text); }
380 385 };
381 386
382 387 class PythonQtWrapper_QHexSpinBox : public QObject
383 388 { Q_OBJECT
384 389 public:
385 390 public slots:
386 391 QHexSpinBox* new_QHexSpinBox(QWidget* parent = 0);
387 392 void delete_QHexSpinBox(QHexSpinBox* obj) { delete obj; }
388 393 void show(QHexSpinBox* theWrappedObject);
389 394 QString textFromValue(QHexSpinBox* theWrappedObject, int value) const;
390 395 QValidator::State validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const;
391 396 int valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const;
392 397 };
393 398
394 399
395 400
396 401
397 402
398 403 class PythonQtShell_SocExplorerPlot : public SocExplorerPlot
399 404 {
400 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 408 ~PythonQtShell_SocExplorerPlot();
404 409
405 410 virtual void actionEvent(QActionEvent* arg__1);
406 411 virtual void changeEvent(QEvent* arg__1);
407 412 virtual void childEvent(QChildEvent* arg__1);
408 413 virtual void closeEvent(QCloseEvent* arg__1);
409 414 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
410 415 virtual void customEvent(QEvent* arg__1);
411 416 virtual int devType() const;
412 417 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
413 418 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
414 419 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
415 420 virtual void dropEvent(QDropEvent* arg__1);
416 421 virtual void enterEvent(QEvent* arg__1);
417 422 virtual bool event(QEvent* arg__1);
418 423 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
419 424 virtual void focusInEvent(QFocusEvent* arg__1);
420 425 virtual bool focusNextPrevChild(bool next);
421 426 virtual void focusOutEvent(QFocusEvent* arg__1);
422 427 virtual bool hasHeightForWidth() const;
423 428 virtual int heightForWidth(int arg__1) const;
424 429 virtual void hideEvent(QHideEvent* arg__1);
425 430 virtual void initPainter(QPainter* painter) const;
426 431 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
427 432 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
428 433 virtual void keyPressEvent(QKeyEvent* arg__1);
429 434 virtual void keyReleaseEvent(QKeyEvent* arg__1);
430 435 virtual void leaveEvent(QEvent* arg__1);
431 436 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
432 437 virtual QSize minimumSizeHint() const;
433 438 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
434 439 virtual void mouseMoveEvent(QMouseEvent* arg__1);
435 440 virtual void mousePressEvent(QMouseEvent* arg__1);
436 441 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
437 442 virtual void moveEvent(QMoveEvent* arg__1);
438 443 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
439 444 virtual QPaintEngine* paintEngine() const;
440 445 virtual void paintEvent(QPaintEvent* arg__1);
441 446 virtual QPaintDevice* redirected(QPoint* offset) const;
442 447 virtual void resizeEvent(QResizeEvent* arg__1);
443 448 virtual QPainter* sharedPainter() const;
444 449 virtual void showEvent(QShowEvent* arg__1);
445 450 virtual QSize sizeHint() const;
446 451 virtual void tabletEvent(QTabletEvent* arg__1);
447 452 virtual void timerEvent(QTimerEvent* arg__1);
448 453 virtual void wheelEvent(QWheelEvent* arg__1);
449 454
450 455 PythonQtInstanceWrapper* _wrapper;
451 456 };
452 457
453 458 class PythonQtPublicPromoter_SocExplorerPlot : public SocExplorerPlot
454 459 { public:
455 460 inline void promoted_keyPressEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyPressEvent(arg__1); }
456 461 inline void promoted_keyReleaseEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyReleaseEvent(arg__1); }
457 462 inline void promoted_mouseMoveEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseMoveEvent(arg__1); }
458 463 inline void promoted_mousePressEvent(QMouseEvent* arg__1) { SocExplorerPlot::mousePressEvent(arg__1); }
459 464 inline void promoted_mouseReleaseEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseReleaseEvent(arg__1); }
460 465 inline void promoted_wheelEvent(QWheelEvent* arg__1) { SocExplorerPlot::wheelEvent(arg__1); }
461 466 };
462 467
463 468 class PythonQtWrapper_SocExplorerPlot : public QObject
464 469 { Q_OBJECT
465 470 public:
466 471 public slots:
467 472 SocExplorerPlot* new_SocExplorerPlot(QWidget* parent = 0);
468 473 void delete_SocExplorerPlot(SocExplorerPlot* obj) { delete obj; }
469 474 int addGraph(SocExplorerPlot* theWrappedObject);
470 475 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
471 476 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y);
472 477 QPen getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex);
473 478 void keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
474 479 void keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
475 480 void mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
476 481 void mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
477 482 void mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
478 483 void rescaleAxis(SocExplorerPlot* theWrappedObject);
479 484 void setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable);
480 485 void setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
481 486 void setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle);
482 487 void setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name);
483 488 void setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen);
484 489 void setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle);
485 490 void setLegendFont(SocExplorerPlot* theWrappedObject, QFont font);
486 491 void setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font);
487 492 void setTitle(SocExplorerPlot* theWrappedObject, QString title);
488 493 void setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
489 494 void setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
490 495 void setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
491 496 void setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
492 497 void show(SocExplorerPlot* theWrappedObject);
493 498 void wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1);
494 499 };
495 500
496 501
497 502
498 503
499 504
500 505 class PythonQtShell_TCP_Terminal_Client : public TCP_Terminal_Client
501 506 {
502 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 510 ~PythonQtShell_TCP_Terminal_Client();
506 511
507 512 virtual void childEvent(QChildEvent* arg__1);
508 513 virtual void customEvent(QEvent* arg__1);
509 514 virtual bool event(QEvent* arg__1);
510 515 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
511 516 virtual void timerEvent(QTimerEvent* arg__1);
512 517
513 518 PythonQtInstanceWrapper* _wrapper;
514 519 };
515 520
516 521 class PythonQtWrapper_TCP_Terminal_Client : public QObject
517 522 { Q_OBJECT
518 523 public:
519 524 public slots:
520 525 TCP_Terminal_Client* new_TCP_Terminal_Client(QObject* parent = 0);
521 526 void delete_TCP_Terminal_Client(TCP_Terminal_Client* obj) { delete obj; }
522 527 void connectToServer(TCP_Terminal_Client* theWrappedObject);
523 528 void connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port);
524 529 bool isConnected(TCP_Terminal_Client* theWrappedObject);
525 530 void sendText(TCP_Terminal_Client* theWrappedObject, const QString& text);
526 531 void startServer(TCP_Terminal_Client* theWrappedObject);
527 532 void startServer(TCP_Terminal_Client* theWrappedObject, int port);
528 533 };
529 534
530 535
531 536
532 537
533 538
534 539 class PythonQtWrapper_XByteArray : public QObject
535 540 { Q_OBJECT
536 541 public:
537 542 public slots:
538 543 XByteArray* new_XByteArray();
539 544 void delete_XByteArray(XByteArray* obj) { delete obj; }
540 545 int addressOffset(XByteArray* theWrappedObject);
541 546 int addressWidth(XByteArray* theWrappedObject);
542 547 QChar asciiChar(XByteArray* theWrappedObject, int index);
543 548 QByteArray* data(XByteArray* theWrappedObject);
544 549 bool dataChanged(XByteArray* theWrappedObject, int i);
545 550 QByteArray dataChanged(XByteArray* theWrappedObject, int i, int len);
546 551 QByteArray* insert(XByteArray* theWrappedObject, int i, char ch);
547 552 QByteArray* insert(XByteArray* theWrappedObject, int i, const QByteArray& ba);
548 553 int realAddressNumbers(XByteArray* theWrappedObject);
549 554 QByteArray* remove(XByteArray* theWrappedObject, int pos, int len);
550 555 QByteArray* replace(XByteArray* theWrappedObject, int index, char ch);
551 556 QByteArray* replace(XByteArray* theWrappedObject, int index, const QByteArray& ba);
552 557 QByteArray* replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba);
553 558 void setAddressOffset(XByteArray* theWrappedObject, int offset);
554 559 void setAddressWidth(XByteArray* theWrappedObject, int width);
555 560 void setData(XByteArray* theWrappedObject, QByteArray data);
556 561 void setDataChanged(XByteArray* theWrappedObject, int i, bool state);
557 562 void setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state);
558 563 int size(XByteArray* theWrappedObject);
559 564 QString toRedableString(XByteArray* theWrappedObject, int start = 0, int end = -1);
560 565 };
561 566
562 567
563 568
564 569
565 570
566 571 class PythonQtShell_abstractBinFile : public abstractBinFile
567 572 {
568 573 public:
569 PythonQtShell_abstractBinFile():abstractBinFile(),_wrapper(NULL) {};
574 PythonQtShell_abstractBinFile():abstractBinFile(),_wrapper(NULL) { };
570 575
571 576 ~PythonQtShell_abstractBinFile();
572 577
573 578 virtual void childEvent(QChildEvent* arg__1);
574 579 virtual int closeFile();
575 580 virtual void customEvent(QEvent* arg__1);
576 581 virtual bool event(QEvent* arg__1);
577 582 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
578 583 virtual QList<codeFragment* > getFragments();
579 584 virtual bool isopened();
580 585 virtual bool openFile(const QString& File);
581 586 virtual void timerEvent(QTimerEvent* arg__1);
582 587 virtual bool toBinary(const QString& File);
583 588 virtual bool toSrec(const QString& File);
584 589
585 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 603 class PythonQtWrapper_abstractBinFile : public QObject
589 604 { Q_OBJECT
590 605 public:
591 606 public slots:
592 607 abstractBinFile* new_abstractBinFile();
593 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 623 class PythonQtShell_abstractBinFileWidget : public abstractBinFileWidget
601 624 {
602 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 628 ~PythonQtShell_abstractBinFileWidget();
606 629
607 630 virtual void actionEvent(QActionEvent* arg__1);
608 631 virtual void changeEvent(QEvent* arg__1);
609 632 virtual void childEvent(QChildEvent* arg__1);
610 633 virtual void closeEvent(QCloseEvent* arg__1);
611 634 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
612 635 virtual void customEvent(QEvent* arg__1);
613 636 virtual int devType() const;
614 637 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
615 638 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
616 639 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
617 640 virtual void dropEvent(QDropEvent* arg__1);
618 641 virtual void enterEvent(QEvent* arg__1);
619 642 virtual bool event(QEvent* arg__1);
620 643 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
621 644 virtual void focusInEvent(QFocusEvent* arg__1);
622 645 virtual bool focusNextPrevChild(bool next);
623 646 virtual void focusOutEvent(QFocusEvent* arg__1);
624 647 virtual bool hasHeightForWidth() const;
625 648 virtual int heightForWidth(int arg__1) const;
626 649 virtual void hideEvent(QHideEvent* arg__1);
627 650 virtual void initPainter(QPainter* painter) const;
628 651 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
629 652 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
630 653 virtual void keyPressEvent(QKeyEvent* arg__1);
631 654 virtual void keyReleaseEvent(QKeyEvent* arg__1);
632 655 virtual void leaveEvent(QEvent* arg__1);
633 656 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
634 657 virtual QSize minimumSizeHint() const;
635 658 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
636 659 virtual void mouseMoveEvent(QMouseEvent* arg__1);
637 660 virtual void mousePressEvent(QMouseEvent* arg__1);
638 661 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
639 662 virtual void moveEvent(QMoveEvent* arg__1);
640 663 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
641 664 virtual QPaintEngine* paintEngine() const;
642 665 virtual void paintEvent(QPaintEvent* arg__1);
643 666 virtual QPaintDevice* redirected(QPoint* offset) const;
644 667 virtual void reloadFile();
645 668 virtual void resizeEvent(QResizeEvent* arg__1);
646 669 virtual void setFile(abstractBinFile* file);
647 670 virtual QPainter* sharedPainter() const;
648 671 virtual void showEvent(QShowEvent* arg__1);
649 672 virtual QSize sizeHint() const;
650 673 virtual void tabletEvent(QTabletEvent* arg__1);
651 674 virtual void timerEvent(QTimerEvent* arg__1);
652 675 virtual void wheelEvent(QWheelEvent* arg__1);
653 676
654 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 686 class PythonQtWrapper_abstractBinFileWidget : public QObject
658 687 { Q_OBJECT
659 688 public:
660 689 public slots:
661 690 abstractBinFileWidget* new_abstractBinFileWidget(QWidget* parent = 0);
662 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 700 class PythonQtShell_binaryFile : public binaryFile
670 701 {
671 702 public:
672 PythonQtShell_binaryFile():binaryFile(),_wrapper(NULL) {};
673 PythonQtShell_binaryFile(const QString& File):binaryFile(File),_wrapper(NULL) {};
674 PythonQtShell_binaryFile(const QStringList& Files):binaryFile(Files),_wrapper(NULL) {};
703 PythonQtShell_binaryFile():binaryFile(),_wrapper(NULL) { };
704 PythonQtShell_binaryFile(const QString& File):binaryFile(File),_wrapper(NULL) { };
705 PythonQtShell_binaryFile(const QStringList& Files):binaryFile(Files),_wrapper(NULL) { };
675 706
676 707 ~PythonQtShell_binaryFile();
677 708
678 709 virtual int closeFile();
679 710 virtual QList<codeFragment* > getFragments();
680 711 virtual bool isopened();
681 712 virtual bool openFile(const QString& File);
682 713 virtual bool toBinary(const QString& fileName);
683 714 virtual bool toSrec(const QString& fileName);
684 715
685 716 PythonQtInstanceWrapper* _wrapper;
686 717 };
687 718
688 719 class PythonQtPublicPromoter_binaryFile : public binaryFile
689 720 { public:
690 721 inline int promoted_closeFile() { return binaryFile::closeFile(); }
691 722 inline QList<codeFragment* > promoted_getFragments() { return binaryFile::getFragments(); }
692 723 inline bool promoted_isopened() { return binaryFile::isopened(); }
693 724 inline bool promoted_openFile(const QString& File) { return binaryFile::openFile(File); }
694 725 inline bool promoted_toBinary(const QString& fileName) { return binaryFile::toBinary(fileName); }
695 726 inline bool promoted_toSrec(const QString& fileName) { return binaryFile::toSrec(fileName); }
696 727 };
697 728
698 729 class PythonQtWrapper_binaryFile : public QObject
699 730 { Q_OBJECT
700 731 public:
701 732 public slots:
702 733 binaryFile* new_binaryFile();
703 734 binaryFile* new_binaryFile(const QString& File);
704 735 binaryFile* new_binaryFile(const QStringList& Files);
705 736 void delete_binaryFile(binaryFile* obj) { delete obj; }
706 737 int closeFile(binaryFile* theWrappedObject);
707 738 codeFragment* getFragment(binaryFile* theWrappedObject, int index);
708 739 int getFragmentAddress(binaryFile* theWrappedObject, int index);
709 740 bool getFragmentData(binaryFile* theWrappedObject, int index, char** buffer);
710 741 QString getFragmentHeader(binaryFile* theWrappedObject, int index);
711 742 int getFragmentSize(binaryFile* theWrappedObject, int index);
712 743 QList<codeFragment* > getFragments(binaryFile* theWrappedObject);
713 744 int getFragmentsCount(binaryFile* theWrappedObject);
714 745 bool isopened(binaryFile* theWrappedObject);
715 746 bool openFile(binaryFile* theWrappedObject, const QString& File);
716 747 bool openFiles(binaryFile* theWrappedObject, const QStringList& Files);
717 748 bool static_binaryFile_toBinary(QList<codeFragment* > fragments, const QString& File);
718 749 bool toBinary(binaryFile* theWrappedObject, const QString& fileName);
719 750 bool toSrec(binaryFile* theWrappedObject, const QString& fileName);
720 751 };
721 752
722 753
723 754
724 755
725 756
726 757 class PythonQtShell_binaryFileWidget : public binaryFileWidget
727 758 {
728 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 762 ~PythonQtShell_binaryFileWidget();
732 763
733 764 virtual void reloadFile();
734 765 virtual void setFile(abstractBinFile* file);
735 766
736 767 PythonQtInstanceWrapper* _wrapper;
737 768 };
738 769
739 770 class PythonQtPublicPromoter_binaryFileWidget : public binaryFileWidget
740 771 { public:
741 772 inline void promoted_reloadFile() { binaryFileWidget::reloadFile(); }
742 773 inline void promoted_setFile(abstractBinFile* file) { binaryFileWidget::setFile(file); }
743 774 };
744 775
745 776 class PythonQtWrapper_binaryFileWidget : public QObject
746 777 { Q_OBJECT
747 778 public:
748 779 public slots:
749 780 binaryFileWidget* new_binaryFileWidget(QWidget* parent = 0);
750 781 void delete_binaryFileWidget(binaryFileWidget* obj) { delete obj; }
751 782 void reloadFile(binaryFileWidget* theWrappedObject);
752 783 void setFile(binaryFileWidget* theWrappedObject, abstractBinFile* file);
753 784 };
754 785
755 786
756 787
757 788
758 789
759 790 class PythonQtShell_codeFragment : public codeFragment
760 791 {
761 792 public:
762 PythonQtShell_codeFragment():codeFragment(),_wrapper(NULL) {};
763 PythonQtShell_codeFragment(char* data, quint64 size, quint64 address):codeFragment(data, size, address),_wrapper(NULL) {};
793 PythonQtShell_codeFragment():codeFragment(),_wrapper(NULL) { };
794 PythonQtShell_codeFragment(char* data, quint64 size, quint64 address):codeFragment(data, size, address),_wrapper(NULL) { };
764 795
765 796 ~PythonQtShell_codeFragment();
766 797
767 798
768 799 PythonQtInstanceWrapper* _wrapper;
769 800 };
770 801
771 802 class PythonQtWrapper_codeFragment : public QObject
772 803 { Q_OBJECT
773 804 public:
774 805 public slots:
775 806 codeFragment* new_codeFragment();
776 807 codeFragment* new_codeFragment(char* data, quint64 size, quint64 address);
777 808 void delete_codeFragment(codeFragment* obj) { delete obj; }
778 void py_set_size(codeFragment* theWrappedObject, quint64 size){ theWrappedObject->size = size; }
779 quint64 py_get_size(codeFragment* theWrappedObject){ return theWrappedObject->size; }
809 void py_set_address(codeFragment* theWrappedObject, quint64 address){ theWrappedObject->address = address; }
810 quint64 py_get_address(codeFragment* theWrappedObject){ return theWrappedObject->address; }
780 811 void py_set_data(codeFragment* theWrappedObject, char* data){ theWrappedObject->data = data; }
781 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 813 void py_set_header(codeFragment* theWrappedObject, QString header){ theWrappedObject->header = header; }
785 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 823 class PythonQtShell_elfFileWidget : public elfFileWidget
793 824 {
794 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 828 ~PythonQtShell_elfFileWidget();
798 829
799 830 virtual void reloadFile();
800 831 virtual void setFile(abstractBinFile* file);
801 832
802 833 PythonQtInstanceWrapper* _wrapper;
803 834 };
804 835
805 836 class PythonQtPublicPromoter_elfFileWidget : public elfFileWidget
806 837 { public:
807 838 inline void promoted_reloadFile() { elfFileWidget::reloadFile(); }
808 839 inline void promoted_setFile(abstractBinFile* file) { elfFileWidget::setFile(file); }
809 840 };
810 841
811 842 class PythonQtWrapper_elfFileWidget : public QObject
812 843 { Q_OBJECT
813 844 public:
814 845 public slots:
815 846 elfFileWidget* new_elfFileWidget(QWidget* parent = 0);
816 847 void delete_elfFileWidget(elfFileWidget* obj) { delete obj; }
817 848 void reloadFile(elfFileWidget* theWrappedObject);
818 849 void setFile(elfFileWidget* theWrappedObject, abstractBinFile* file);
819 850 };
820 851
821 852
822 853
823 854
824 855
825 856 class PythonQtShell_elfInfoWdgt : public elfInfoWdgt
826 857 {
827 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 861 ~PythonQtShell_elfInfoWdgt();
831 862
832 863 virtual void actionEvent(QActionEvent* arg__1);
833 864 virtual void changeEvent(QEvent* arg__1);
834 865 virtual void childEvent(QChildEvent* arg__1);
835 866 virtual void closeEvent(QCloseEvent* arg__1);
836 867 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
837 868 virtual void customEvent(QEvent* arg__1);
838 869 virtual int devType() const;
839 870 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
840 871 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
841 872 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
842 873 virtual void dropEvent(QDropEvent* arg__1);
843 874 virtual void enterEvent(QEvent* arg__1);
844 875 virtual bool event(QEvent* arg__1);
845 876 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
846 877 virtual void focusInEvent(QFocusEvent* arg__1);
847 878 virtual bool focusNextPrevChild(bool next);
848 879 virtual void focusOutEvent(QFocusEvent* arg__1);
849 880 virtual bool hasHeightForWidth() const;
850 881 virtual int heightForWidth(int arg__1) const;
851 882 virtual void hideEvent(QHideEvent* arg__1);
852 883 virtual void initPainter(QPainter* painter) const;
853 884 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
854 885 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
855 886 virtual void keyPressEvent(QKeyEvent* arg__1);
856 887 virtual void keyReleaseEvent(QKeyEvent* arg__1);
857 888 virtual void leaveEvent(QEvent* arg__1);
858 889 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
859 890 virtual QSize minimumSizeHint() const;
860 891 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
861 892 virtual void mouseMoveEvent(QMouseEvent* arg__1);
862 893 virtual void mousePressEvent(QMouseEvent* arg__1);
863 894 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
864 895 virtual void moveEvent(QMoveEvent* arg__1);
865 896 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
866 897 virtual QPaintEngine* paintEngine() const;
867 898 virtual void paintEvent(QPaintEvent* arg__1);
868 899 virtual QPaintDevice* redirected(QPoint* offset) const;
869 900 virtual void resizeEvent(QResizeEvent* arg__1);
870 901 virtual QPainter* sharedPainter() const;
871 902 virtual void showEvent(QShowEvent* arg__1);
872 903 virtual QSize sizeHint() const;
873 904 virtual void tabletEvent(QTabletEvent* arg__1);
874 905 virtual void timerEvent(QTimerEvent* arg__1);
875 906 virtual void wheelEvent(QWheelEvent* arg__1);
876 907
877 908 PythonQtInstanceWrapper* _wrapper;
878 909 };
879 910
880 911 class PythonQtWrapper_elfInfoWdgt : public QObject
881 912 { Q_OBJECT
882 913 public:
883 914 public slots:
884 915 elfInfoWdgt* new_elfInfoWdgt(QWidget* parent = 0);
885 916 void delete_elfInfoWdgt(elfInfoWdgt* obj) { delete obj; }
886 917 };
887 918
888 919
889 920
890 921
891 922
892 923 class PythonQtWrapper_elfparser : public QObject
893 924 { Q_OBJECT
894 925 public:
895 926 public slots:
896 927 elfparser* new_elfparser();
897 928 void delete_elfparser(elfparser* obj) { delete obj; }
898 929 int closeFile(elfparser* theWrappedObject);
899 930 QString getABI(elfparser* theWrappedObject);
900 931 QString getArchitecture(elfparser* theWrappedObject);
901 932 QString getClass(elfparser* theWrappedObject);
902 933 QString getEndianness(elfparser* theWrappedObject);
903 934 qint64 getEntryPointAddress(elfparser* theWrappedObject);
904 935 bool getSectionData(elfparser* theWrappedObject, int index, char** buffer);
905 936 qint64 getSectionDatasz(elfparser* theWrappedObject, int index);
906 937 qint64 getSectionMemsz(elfparser* theWrappedObject, int index);
907 938 QString getSectionName(elfparser* theWrappedObject, int index);
908 939 qint64 getSectionPaddr(elfparser* theWrappedObject, int index);
909 940 QString getSectionType(elfparser* theWrappedObject, int index);
910 941 int getSectioncount(elfparser* theWrappedObject);
911 942 qint64 getSegmentFilesz(elfparser* theWrappedObject, int index);
912 943 QString getSegmentFlags(elfparser* theWrappedObject, int index);
913 944 qint64 getSegmentMemsz(elfparser* theWrappedObject, int index);
914 945 qint64 getSegmentOffset(elfparser* theWrappedObject, int index);
915 946 qint64 getSegmentPaddr(elfparser* theWrappedObject, int index);
916 947 QString getSegmentType(elfparser* theWrappedObject, int index);
917 948 qint64 getSegmentVaddr(elfparser* theWrappedObject, int index);
918 949 int getSegmentcount(elfparser* theWrappedObject);
919 950 QString getType(elfparser* theWrappedObject);
920 951 qint64 getVersion(elfparser* theWrappedObject);
921 952 bool static_elfparser_isElf(const QString& File);
922 953 bool iself(elfparser* theWrappedObject);
923 954 bool isopened(elfparser* theWrappedObject);
924 955 int setFilename(elfparser* theWrappedObject, const QString& name);
925 956 };
926 957
927 958
928 959
929 960
930 961
931 962 class PythonQtShell_genericBinaryFileWidget : public genericBinaryFileWidget
932 963 {
933 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 967 ~PythonQtShell_genericBinaryFileWidget();
937 968
938 969 virtual void actionEvent(QActionEvent* arg__1);
939 970 virtual void changeEvent(QEvent* arg__1);
940 971 virtual void childEvent(QChildEvent* arg__1);
941 972 virtual void closeEvent(QCloseEvent* arg__1);
942 973 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
943 974 virtual void customEvent(QEvent* arg__1);
944 975 virtual int devType() const;
945 976 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
946 977 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
947 978 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
948 979 virtual void dropEvent(QDropEvent* arg__1);
949 980 virtual void enterEvent(QEvent* arg__1);
950 981 virtual bool event(QEvent* arg__1);
951 982 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
952 983 virtual void focusInEvent(QFocusEvent* arg__1);
953 984 virtual bool focusNextPrevChild(bool next);
954 985 virtual void focusOutEvent(QFocusEvent* arg__1);
955 986 virtual bool hasHeightForWidth() const;
956 987 virtual int heightForWidth(int arg__1) const;
957 988 virtual void hideEvent(QHideEvent* arg__1);
958 989 virtual void initPainter(QPainter* painter) const;
959 990 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
960 991 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
961 992 virtual void keyPressEvent(QKeyEvent* arg__1);
962 993 virtual void keyReleaseEvent(QKeyEvent* arg__1);
963 994 virtual void leaveEvent(QEvent* arg__1);
964 995 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
965 996 virtual QSize minimumSizeHint() const;
966 997 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
967 998 virtual void mouseMoveEvent(QMouseEvent* arg__1);
968 999 virtual void mousePressEvent(QMouseEvent* arg__1);
969 1000 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
970 1001 virtual void moveEvent(QMoveEvent* arg__1);
971 1002 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
972 1003 virtual QPaintEngine* paintEngine() const;
973 1004 virtual void paintEvent(QPaintEvent* arg__1);
974 1005 virtual QPaintDevice* redirected(QPoint* offset) const;
975 1006 virtual void resizeEvent(QResizeEvent* arg__1);
976 1007 virtual QPainter* sharedPainter() const;
977 1008 virtual void showEvent(QShowEvent* arg__1);
978 1009 virtual QSize sizeHint() const;
979 1010 virtual void tabletEvent(QTabletEvent* arg__1);
980 1011 virtual void timerEvent(QTimerEvent* arg__1);
981 1012 virtual void wheelEvent(QWheelEvent* arg__1);
982 1013
983 1014 PythonQtInstanceWrapper* _wrapper;
984 1015 };
985 1016
986 1017 class PythonQtWrapper_genericBinaryFileWidget : public QObject
987 1018 { Q_OBJECT
988 1019 public:
989 1020 public slots:
990 1021 genericBinaryFileWidget* new_genericBinaryFileWidget(QWidget* parent = 0);
991 1022 void delete_genericBinaryFileWidget(genericBinaryFileWidget* obj) { delete obj; }
992 1023 };
993 1024
994 1025
995 1026
996 1027
997 1028
998 1029 class PythonQtShell_srecFile : public srecFile
999 1030 {
1000 1031 public:
1001 PythonQtShell_srecFile():srecFile(),_wrapper(NULL) {};
1002 PythonQtShell_srecFile(const QString& File):srecFile(File),_wrapper(NULL) {};
1003 PythonQtShell_srecFile(const QStringList& Files):srecFile(Files),_wrapper(NULL) {};
1032 PythonQtShell_srecFile():srecFile(),_wrapper(NULL) { };
1033 PythonQtShell_srecFile(const QString& File):srecFile(File),_wrapper(NULL) { };
1034 PythonQtShell_srecFile(const QStringList& Files):srecFile(Files),_wrapper(NULL) { };
1004 1035
1005 1036 ~PythonQtShell_srecFile();
1006 1037
1007 1038 virtual int closeFile();
1008 1039 virtual QList<codeFragment* > getFragments();
1009 1040 virtual bool isopened();
1010 1041 virtual bool openFile(const QString& File);
1011 1042 virtual bool toBinary(const QString& File);
1012 1043 virtual bool toSrec(const QString& File);
1013 1044
1014 1045 PythonQtInstanceWrapper* _wrapper;
1015 1046 };
1016 1047
1017 1048 class PythonQtPublicPromoter_srecFile : public srecFile
1018 1049 { public:
1019 1050 inline int promoted_closeFile() { return srecFile::closeFile(); }
1020 1051 inline QList<codeFragment* > promoted_getFragments() { return srecFile::getFragments(); }
1021 1052 inline bool promoted_isopened() { return srecFile::isopened(); }
1022 1053 inline bool promoted_openFile(const QString& File) { return srecFile::openFile(File); }
1023 1054 inline bool promoted_toBinary(const QString& File) { return srecFile::toBinary(File); }
1024 1055 inline bool promoted_toSrec(const QString& File) { return srecFile::toSrec(File); }
1025 1056 };
1026 1057
1027 1058 class PythonQtWrapper_srecFile : public QObject
1028 1059 { Q_OBJECT
1029 1060 public:
1030 1061 public slots:
1031 1062 srecFile* new_srecFile();
1032 1063 srecFile* new_srecFile(const QString& File);
1033 1064 srecFile* new_srecFile(const QStringList& Files);
1034 1065 void delete_srecFile(srecFile* obj) { delete obj; }
1035 1066 bool static_srecFile_checkSum(const QString& line);
1036 1067 int closeFile(srecFile* theWrappedObject);
1037 1068 codeFragment* getFragment(srecFile* theWrappedObject, int index);
1038 1069 int getFragmentAddress(srecFile* theWrappedObject, int index);
1039 1070 bool getFragmentData(srecFile* theWrappedObject, int index, char** buffer);
1040 1071 QString getFragmentHeader(srecFile* theWrappedObject, int index);
1041 1072 int getFragmentSize(srecFile* theWrappedObject, int index);
1042 1073 QList<codeFragment* > getFragments(srecFile* theWrappedObject);
1043 1074 int getFragmentsCount(srecFile* theWrappedObject);
1044 1075 bool isSREC(srecFile* theWrappedObject);
1045 1076 bool static_srecFile_isSREC(const QString& File);
1046 1077 bool isopened(srecFile* theWrappedObject);
1047 1078 int lineCount(srecFile* theWrappedObject);
1048 1079 bool mergingRecords(srecFile* theWrappedObject);
1049 1080 bool openFile(srecFile* theWrappedObject, const QString& File);
1050 1081 bool openFiles(srecFile* theWrappedObject, const QStringList& Files);
1051 1082 void setMergingRecords(srecFile* theWrappedObject, bool enabled);
1052 1083 bool toBinary(srecFile* theWrappedObject, const QString& File);
1053 1084 bool static_srecFile_toSrec(QList<codeFragment* > fragments, const QString& File);
1054 1085 bool toSrec(srecFile* theWrappedObject, const QString& File);
1055 1086 };
1056 1087
1057 1088
1058 1089
1059 1090
1060 1091
1061 1092 class PythonQtShell_srecFileWidget : public srecFileWidget
1062 1093 {
1063 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 1097 ~PythonQtShell_srecFileWidget();
1067 1098
1068 1099 virtual void reloadFile();
1069 1100 virtual void setFile(abstractBinFile* file);
1070 1101
1071 1102 PythonQtInstanceWrapper* _wrapper;
1072 1103 };
1073 1104
1074 1105 class PythonQtPublicPromoter_srecFileWidget : public srecFileWidget
1075 1106 { public:
1076 1107 inline void promoted_reloadFile() { srecFileWidget::reloadFile(); }
1077 1108 inline void promoted_setFile(abstractBinFile* file) { srecFileWidget::setFile(file); }
1078 1109 };
1079 1110
1080 1111 class PythonQtWrapper_srecFileWidget : public QObject
1081 1112 { Q_OBJECT
1082 1113 public:
1083 1114 public slots:
1084 1115 srecFileWidget* new_srecFileWidget(QWidget* parent = 0);
1085 1116 void delete_srecFileWidget(srecFileWidget* obj) { delete obj; }
1086 1117 void reloadFile(srecFileWidget* theWrappedObject);
1087 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 1 #include <PythonQt.h>
2 #include <PythonQtConversion.h>
2 3 #include "PySocExplorer0.h"
3 4
4 5
6
5 7 void PythonQt_init_PySocExplorer(PyObject* module) {
6 8 PythonQt::priv()->registerClass(&ElfFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_ElfFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_ElfFile>, module, 0);
7 9 PythonQt::self()->addParentClass("ElfFile", "abstractBinFile",PythonQtUpcastingOffset<ElfFile,abstractBinFile>());
8 10 PythonQt::priv()->registerClass(&MemSizeWdgt::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_MemSizeWdgt>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_MemSizeWdgt>, module, 0);
9 11 PythonQt::priv()->registerClass(&QHexEdit::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_QHexEdit>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QHexEdit>, module, 0);
10 12 PythonQt::priv()->registerClass(&QHexSpinBox::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_QHexSpinBox>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QHexSpinBox>, module, 0);
11 13 PythonQt::priv()->registerClass(&SocExplorerPlot::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_SocExplorerPlot>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_SocExplorerPlot>, module, 0);
12 14 PythonQt::priv()->registerClass(&TCP_Terminal_Client::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_TCP_Terminal_Client>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_TCP_Terminal_Client>, module, 0);
13 15 PythonQt::priv()->registerCPPClass("XByteArray", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_XByteArray>, NULL, module, 0);
14 16 PythonQt::priv()->registerClass(&abstractBinFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_abstractBinFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_abstractBinFile>, module, 0);
15 17 PythonQt::priv()->registerClass(&abstractBinFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_abstractBinFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_abstractBinFileWidget>, module, 0);
16 18 PythonQt::priv()->registerClass(&binaryFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_binaryFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_binaryFile>, module, 0);
17 19 PythonQt::self()->addParentClass("binaryFile", "abstractBinFile",PythonQtUpcastingOffset<binaryFile,abstractBinFile>());
18 20 PythonQt::priv()->registerClass(&binaryFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_binaryFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_binaryFileWidget>, module, 0);
19 21 PythonQt::self()->addParentClass("binaryFileWidget", "abstractBinFileWidget",PythonQtUpcastingOffset<binaryFileWidget,abstractBinFileWidget>());
20 22 PythonQt::priv()->registerCPPClass("codeFragment", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_codeFragment>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_codeFragment>, module, 0);
21 23 PythonQt::priv()->registerClass(&elfFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_elfFileWidget>, module, 0);
22 24 PythonQt::self()->addParentClass("elfFileWidget", "abstractBinFileWidget",PythonQtUpcastingOffset<elfFileWidget,abstractBinFileWidget>());
23 25 PythonQt::priv()->registerClass(&elfInfoWdgt::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfInfoWdgt>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_elfInfoWdgt>, module, 0);
24 26 PythonQt::priv()->registerCPPClass("elfparser", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfparser>, NULL, module, 0);
25 27 PythonQt::priv()->registerClass(&genericBinaryFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_genericBinaryFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_genericBinaryFileWidget>, module, 0);
26 28 PythonQt::priv()->registerClass(&srecFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_srecFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_srecFile>, module, 0);
27 29 PythonQt::self()->addParentClass("srecFile", "abstractBinFile",PythonQtUpcastingOffset<srecFile,abstractBinFile>());
28 30 PythonQt::priv()->registerClass(&srecFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_srecFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_srecFileWidget>, module, 0);
29 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 2 -- This file is a part of the SocExplorer Software
3 3 -- Copyright (C) 2011, Plasma Physics Laboratory - CNRS
4 4 --
5 5 -- This program is free software; you can redistribute it and/or modify
6 6 -- it under the terms of the GNU General Public License as published by
7 7 -- the Free Software Foundation; either version 2 of the License, or
8 8 -- (at your option) any later version.
9 9 --
10 10 -- This program is distributed in the hope that it will be useful,
11 11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 13 -- GNU General Public License for more details.
14 14 --
15 15 -- You should have received a copy of the GNU General Public License
16 16 -- along with this program; if not, write to the Free Software
17 17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 18 -------------------------------------------------------------------------------*/
19 19 /*-- Author : Alexis Jeandet
20 20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
21 21 ----------------------------------------------------------------------------*/
22 22 #include <QApplication>
23 23 #include "mainwindow.h"
24 24 #include <PythonQt.h>
25 25 #include <PythonQt_QtAll.h>
26 26 #include <gui/PythonQtScriptingConsole.h>
27 27 #include <socexplorerplugin.h>
28 28 #include <QStyle>
29 29 #include <QStyleFactory>
30 30 #include <QStringList>
31 31 #include <QFile>
32 32
33 void usage();
33 34
34 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 37 QApplication a(argc, argv);
41 38 QString scriptToEval;
42 39 QStringList args= a.arguments();
43 40 for(int i=0;i<args.count()-1;i++)
44 41 {
45 42 if((args.at(i).compare("-e")==0) || (args.at(i).compare("--execute")==0))
46 43 {
47 44 scriptToEval = args.at(i+1);
48 45 if(!QFile::exists(scriptToEval))
49 46 {
50 47 scriptToEval.clear();
51 48 }
52 49 else
53 50 qDebug() << "Will execute" << scriptToEval;
54 51 break;
55 52 }
56 53 if((args.at(i).compare("-d")==0) || (args.at(i).compare("--debug-level")==0))
57 54 {
58 55 bool success;
59 56 int lvl;
60 57 lvl = args.at(i+1).toInt(&success,10);
61 58 if(success)
62 59 {
63 60 SocExplorerEngine::setLogLevel(lvl);
64 61 }
65 62 }
66 63 }
67 64
68 65 SocExplorerMainWindow w(scriptToEval);
69 66 w.show();
70 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 2 -- This file is a part of the SocExplorer Software
3 3 -- Copyright (C) 2011, Plasma Physics Laboratory - CNRS
4 4 --
5 5 -- This program is free software; you can redistribute it and/or modify
6 6 -- it under the terms of the GNU General Public License as published by
7 7 -- the Free Software Foundation; either version 2 of the License, or
8 8 -- (at your option) any later version.
9 9 --
10 10 -- This program is distributed in the hope that it will be useful,
11 11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 13 -- GNU General Public License for more details.
14 14 --
15 15 -- You should have received a copy of the GNU General Public License
16 16 -- along with this program; if not, write to the Free Software
17 17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 18 -------------------------------------------------------------------------------*/
19 19 /*-- Author : Alexis Jeandet
20 20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
21 21 ----------------------------------------------------------------------------*/
22 22 #include "mainwindow.h"
23 23 #include <QDockWidget>
24 24
25 25 SocExplorerMainWindow::SocExplorerMainWindow(QString ScriptToEval, QWidget *parent)
26 26 : QMainWindow(parent)
27 27 {
28 28 QCoreApplication::setApplicationName("SocExplorer");
29 29 QCoreApplication::setOrganizationName("LPP");
30 30 QCoreApplication::setOrganizationDomain("lpp.fr");
31 31 this->makeObjects(ScriptToEval);
32 32 this->makeLayout();
33 33 this->makeMenu();
34 34 this->makeConnections();
35 this->setWindowIcon(QIcon(tr(":/images/icon.png")));
35 this->setWindowIcon(QIcon(":/images/icon.png"));
36 36 this->setAcceptDrops(true);
37 37 this->pluginManager->setRootLoadable(true);
38 38 this->PythonConsoleInst->pyConsoleRunFile(ScriptToEval);
39 39 QFile file(":/styles/SocExplorer.css");
40 40 if(file.open(QIODevice::ReadOnly | QIODevice::Text))
41 41 {
42 42 qApp->setStyleSheet(file.readAll());
43 43 file.close();
44 44 }
45 45 }
46 46
47 47
48 48 void SocExplorerMainWindow::makeObjects(QString ScriptToEval)
49 49 {
50 50 Q_UNUSED(ScriptToEval)
51 51 this->p_pluginGUIlist = new QList<QDockWidget*>();
52 52 pluginsDockContainer = new QMainWindow;
53 53 pluginsDockContainer->setWindowFlags(Qt::Widget);
54 54 pluginsDockContainer->setDockNestingEnabled(true);
55 55 this->mainWidget = new QSplitter(Qt::Vertical);
56 56 this->appTranslator = new QTranslator;
57 57 this->Quit = new QAction(tr("&Quit"),this);
58 58 this->Quit->setShortcut(tr("CTRL+Q"));
59 59 this->ManagePlugins = new QAction(tr("&Manage Plugins"),this);
60 60 this->ManagePlugins->setShortcut(tr("CTRL+P"));
61 61 this->regsManager = new QAction(tr("&Manage registers"),this);
62 62 this->exploreRegs = new QAction(tr("&Explore registers"),this);
63 63 this->help = new QAction(tr("&Help"),this);
64 64 this->help->setShortcut(tr("CTRL+H"));
65 65 this->about = new QAction(tr("&About"),this);
66 66 socexplorerproxy::setMainWindow(this);
67 67 SocExplorerEngine::setMainWindow(this);
68 68 SocExplorerEngine::xmlModel()->scanXmlFiles();
69 69 this->regExplorer = new regsExplorer();
70 70 this->regExplorer->setAllowedAreas(Qt::AllDockWidgetAreas);
71 71 this->addPluginInterface(this->regExplorer);
72 72 this->PythonConsoleInst = new PythonConsole(socexplorerproxy::self());
73 73 this->PythonConsoleInst->addObject("SocExplorerEngine",SocExplorerEngine::self());
74 74 this->pluginManager = new dockablePluginManager();
75 75 this->toolpane = new toolBar;
76 76 this->p_about = new aboutsocexplorer();
77 77
78 78 }
79 79
80 80 void SocExplorerMainWindow::makeLayout()
81 81 {
82 82 this->mainWidget->addWidget(pluginsDockContainer);
83 83 this->mainWidget->addWidget(this->PythonConsoleInst);
84 84 this->toolpane->setAllowedAreas(Qt::RightDockWidgetArea|Qt::LeftDockWidgetArea);
85 85 this->addDockWidget(Qt::LeftDockWidgetArea,this->toolpane);
86 86 this->toolpane->addTool(this->pluginManager);
87 87 this->setCentralWidget(this->mainWidget);
88 88 }
89 89
90 90
91 91 void SocExplorerMainWindow::makeConnections()
92 92 {
93 93 connect(socexplorerproxy::self(),SIGNAL(clearMenu()),this,SLOT(clearMenu()));
94 94 connect(this,SIGNAL(translateSig()),socexplorerproxy::self(),SLOT(updateText()));
95 95 connect(socexplorerproxy::self(),SIGNAL(addPluginGUI(QDockWidget*)),this,SLOT(addPluginInterface(QDockWidget*)));
96 96 connect(socexplorerproxy::self(),SIGNAL(removePluginGUI(QDockWidget*)),this,SLOT(removePluginInterface(QDockWidget*)));
97 97 connect(this->ManagePlugins,SIGNAL(triggered()),this,SLOT(launchPluginManager()));
98 98 connect(this->Quit,SIGNAL(triggered()),qApp,SLOT(quit()));
99 99 connect(this,SIGNAL(registerObject(QObject*,QString)),this->PythonConsoleInst,SLOT(registerObject(QObject*,QString)));
100 100 connect(socexplorerproxy::self(),SIGNAL(registerObject(QObject*,QString)),this,SIGNAL(registerObject(QObject*,QString)));
101 101 connect(this->pluginManager,SIGNAL(geteplugintree()),socexplorerproxy::self(),SLOT(geteplugintree()));
102 102 connect(socexplorerproxy::self(),SIGNAL(treeChanged(QList<socexplorerplugin*>)),this->pluginManager,SIGNAL(treeChanged(QList<socexplorerplugin*>)));
103 103 connect(this->pluginManager,SIGNAL(changeSysDriverInstName(QString,QString)),socexplorerproxy::self(),SLOT(changeSysDriverInstName(QString,QString)));
104 104 connect(this->pluginManager,SIGNAL(changeSysDriverInstName(QString,QString)),this->PythonConsoleInst,SLOT(changeSysDriverInstName(QString,QString)));
105 105 connect(this->pluginManager,SIGNAL(closeSysDriver(QString)),socexplorerproxy::self(),SLOT(closeSysDriver(QString)));
106 106 connect(this->pluginManager,SIGNAL(closeSysDriver(QString)),this->PythonConsoleInst,SLOT(removeDriver(QString)));
107 107 connect(this->pluginManager,SIGNAL(pluginselected(QString)),this,SLOT(pluginselected(QString)));
108 108 connect(this->about,SIGNAL(triggered()),this,SLOT(showAboutBox()));
109 109 connect(this->exploreRegs,SIGNAL(triggered()),this->regExplorer,SLOT(show()));
110 110
111 111 this->pluginManager->connect(this->pluginManager,SIGNAL(loadSysDrviver(QString)),socexplorerproxy::self(),SLOT(loadSysDriver(QString)));
112 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 117 void SocExplorerMainWindow::launchPluginManager()
118 118 {
119 119
120 120 if(this->pluginManager->isHidden())
121 121 {
122 122 this->pluginManager->setHidden(false);
123 123 }
124 124
125 125 }
126 126
127 127
128 128 void SocExplorerMainWindow::addPluginInterface(QDockWidget *plugin)
129 129 {
130 130 plugin->setAllowedAreas(Qt::AllDockWidgetAreas);
131 131 this->pluginsDockContainer->addDockWidget(Qt::TopDockWidgetArea,plugin);
132 132 if(p_pluginGUIlist->count()!=0)
133 133 this->pluginsDockContainer->tabifyDockWidget(p_pluginGUIlist->last(),plugin);
134 134 p_pluginGUIlist->append(plugin);
135 135
136 136 }
137 137
138 138 void SocExplorerMainWindow::removePluginInterface(QDockWidget *plugin)
139 139 {
140 140 p_pluginGUIlist->removeOne(plugin);
141 141 this->pluginsDockContainer->removeDockWidget(plugin);
142 142 }
143 143
144 144
145 145 void SocExplorerMainWindow::clearMenu()
146 146 {
147 147 this->menuBar()->clear();
148 148 this->makeMenu();
149 149 }
150 150
151 151
152 152 void SocExplorerMainWindow::makeMenu()
153 153 {
154 154 this->FileMenu = menuBar()->addMenu(tr("&File"));
155 155 this->PluginsMenu = menuBar()->addMenu(tr("&Plugins"));
156 156 this->ToolsMenu = menuBar()->addMenu(tr("&Tools"));
157 157 this->ToolsMenu->addAction(this->exploreRegs);
158 158 this->FileMenu->addAction(this->Quit);
159 159 socexplorerproxy::self()->makeMenu(this->PluginsMenu);
160 160 this->PluginsMenu->addAction(this->ManagePlugins);
161 161
162 162 this->helpMenu = menuBar()->addMenu(tr("Help"));
163 163 this->helpMenu->addAction(this->help);
164 164 this->helpMenu->addAction(this->about);
165 165
166 166 }
167 167
168 168
169 169 SocExplorerMainWindow::~SocExplorerMainWindow()
170 170 {
171 171 }
172 172
173 173
174 174 void SocExplorerMainWindow::setLangage(QAction *action)
175 175 {
176 176 QString local = action->data().toString();
177 177 QString qmPath = QDir(QString("translations")).absolutePath();
178 178 appTranslator->load(qmPath+"/socexplorer_"+local+".qm");
179 179 qApp->installTranslator(appTranslator);
180 180 emit this->translateSig();
181 181 }
182 182
183 183
184 184 void SocExplorerMainWindow::createLangMenu()
185 185 {
186 186 this->langMenu = menuBar()->addMenu(tr("&Langue"));
187 187 this->langActionGrp = new QActionGroup(this);
188 188 connect(this->langActionGrp,SIGNAL(triggered(QAction*)),this,SLOT(setLangage(QAction*)));
189 189 QDir* qmDir = new QDir(QString("translations"));
190 190 QStringList LangFiles = qmDir->entryList(QStringList("socexplorer_*.qm"));
191 191 for(int i=0;i<LangFiles.size();++i)
192 192 {
193 193 QString Local = LangFiles[i];
194 194 Local.remove(0,Local.indexOf('_')+1);
195 195 Local.chop(3);
196 196 QTranslator translator;
197 197 translator.load(LangFiles[i],qmDir->absolutePath());
198 198 QString langage = translator.translate("MainWindow","English");
199 199 QAction *action = new QAction(tr("&%1 %2").arg(i+1).arg(langage),this);
200 200 action->setCheckable(true);
201 201 action->setData(Local);
202 202 langMenu->addAction(action);
203 203 langActionGrp->addAction(action);
204 204 if(langage==tr("English"))
205 205 action->setChecked(true);
206 206 }
207 207 }
208 208
209 209
210 210 void SocExplorerMainWindow::updateText()
211 211 {
212 212 emit this->translateSig();
213 213 }
214 214
215 215
216 216
217 217 void SocExplorerMainWindow::showAboutBox()
218 218 {
219 219 p_about->show();
220 220 }
221 221
222 222 void SocExplorerMainWindow::pluginselected(const QString &instanceName)
223 223 {
224 224 socexplorerplugin* drv=socexplorerproxy::self()->getSysDriver(instanceName);
225 225 if(drv)
226 226 drv->raise();
227 227 }
228 228
229 229
230 230
231 231 void SocExplorerMainWindow::closeEvent(QCloseEvent *event)
232 232 {
233 233 socexplorerproxy::self()->close();
234 234 qApp->closeAllWindows();
235 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