##// END OF EJS Templates
WIP.
jeandet -
r91:acc9efbbe625 default
parent child
Show More
@@ -0,0 +1,34
1 /*------------------------------------------------------------------------------
2 -- This file is a part of the SocExplorer Software
3 -- Copyright (C) 2012, Plasma Physics Laboratory - CNRS
4 --
5 -- This program is free software; you can redistribute it and/or modify
6 -- it under the terms of the GNU General Public License as published by
7 -- the Free Software Foundation; either version 2 of the License, or
8 -- (at your option) any later version.
9 --
10 -- This program is distributed in the hope that it will be useful,
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 -- GNU General Public License for more details.
14 --
15 -- You should have received a copy of the GNU General Public License
16 -- along with this program; if not, write to the Free Software
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 -------------------------------------------------------------------------------*/
19 /*-- Author : Alexis Jeandet
20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
21 ----------------------------------------------------------------------------*/
22 #ifndef SOCEXPLORERCONFIGKEYS
23 #define SOCEXPLORERCONFIGKEYS
24
25 #define SOCEXPLORERENGINE_SETTINGS_SCOPE "SocExplorerEngine"
26 #define SOCEXPLORERENGINE_SETTINGS_PLUGINS_LOOKUP_PATH "plugins-lookup-path"
27 #define SOCEXPLORERENGINE_SETTINGS_SOC_REGS_LOOKUP_PATH "soc-registers-lookup-path"
28
29 #define SOCEXPLORERGLOBAL_SETTINGS_SCOPE "GLOBAL"
30 #define SOCEXPLORERGLOBAL_SETTINGS_SESSIONS_SCOPE "SESSIONS"
31 #define SOCEXPLORERGLOBAL_SETTINGS_SESSIONS_NAME "NAME"
32
33 #endif // SOCEXPLORERCONFIGKEYS
34
@@ -0,0 +1,93
1 #include "socexplorergui.h"
2
3 SocExplorerGUI* SocExplorerGUI::_self=NULL;
4 QMenuBar* SocExplorerGUI::m_mainMenuBar=NULL;
5 QMenu* SocExplorerGUI::m_fileMenu=NULL;
6 QMenu* SocExplorerGUI::m_SettingsMenu=NULL;
7 QList<QAction*>* SocExplorerGUI::m_queuedSettingActions=NULL;
8 QList<QAction*>* SocExplorerGUI::m_queuedFileMenuActions=NULL;
9
10 #define INIT() \
11 if(Q_UNLIKELY(_self==NULL))\
12 {\
13 init();\
14 }
15
16 SocExplorerGUI::SocExplorerGUI(QObject *parent) : QObject(parent)
17 {
18 m_queuedFileMenuActions = new QList<QAction*>();
19 m_queuedSettingActions = new QList<QAction*>();
20 }
21
22 void SocExplorerGUI::init()
23 {
24 _self=new SocExplorerGUI();
25 }
26
27 void SocExplorerGUI::registerMenuBar(QMenuBar *menuBar, QMenu *fileMenu, QMenu *SettingsMenu)
28 {
29 INIT();
30 m_mainMenuBar = menuBar;
31 if(m_mainMenuBar)
32 {
33 if(fileMenu==NULL)
34 m_fileMenu = m_mainMenuBar->addMenu(tr("File"));
35 else
36 m_fileMenu = fileMenu;
37 if(SettingsMenu==NULL)
38 m_SettingsMenu = m_mainMenuBar->addMenu(tr("Settings"));
39 else
40 m_SettingsMenu = SettingsMenu;
41 }
42
43 QAction* action;
44 foreach (action, *m_queuedSettingActions)
45 {
46 m_SettingsMenu->addAction(action);
47 }
48 foreach (action, *m_queuedFileMenuActions)
49 {
50 m_fileMenu->addAction(action);
51 }
52 }
53
54 QMenu *SocExplorerGUI::addMenu(const QString &title)
55 {
56 INIT();
57 if(m_mainMenuBar)
58 {
59 return m_mainMenuBar->addMenu(title);
60 }
61 return NULL;
62 }
63
64 bool SocExplorerGUI::addFileAction(QAction *action)
65 {
66 INIT();
67 if(m_fileMenu)
68 {
69 m_fileMenu->addAction(action);
70 return true;
71 }
72 else
73 {
74 m_queuedFileMenuActions->append(action);
75 }
76 return false;
77 }
78
79 bool SocExplorerGUI::addSettingsAction(QAction *action)
80 {
81 INIT();
82 if(m_SettingsMenu)
83 {
84 m_SettingsMenu->addAction(action);
85 return true;
86 }
87 else
88 {
89 m_queuedSettingActions->append(action);
90 }
91 return false;
92 }
93
@@ -0,0 +1,32
1 #ifndef SOCEXPLORERGUI_H
2 #define SOCEXPLORERGUI_H
3
4 #include <QObject>
5 #include <QWidget>
6 #include <QMenu>
7 #include <QMenuBar>
8 #include <QAction>
9
10 class SocExplorerGUI : public QObject
11 {
12 Q_OBJECT
13 static SocExplorerGUI* _self;
14 static QMenuBar* m_mainMenuBar;
15 static QMenu* m_fileMenu;
16 static QMenu* m_SettingsMenu;
17 static QList<QAction*>* m_queuedSettingActions;
18 static QList<QAction*>* m_queuedFileMenuActions;
19 SocExplorerGUI(QObject *parent = 0);
20 static void init();
21 public:
22 static SocExplorerGUI* self(){ if(!_self){_self= new SocExplorerGUI;}return _self;}
23 static void registerMenuBar(QMenuBar* menuBar, QMenu* fileMenu=NULL, QMenu* SettingsMenu=NULL);
24 static QMenu* addMenu(const QString & title);
25 static bool addFileAction(QAction * action);
26 static bool addSettingsAction(QAction * action);
27 signals:
28
29 public slots:
30 };
31
32 #endif // SOCEXPLORERGUI_H
@@ -0,0 +1,205
1 /*------------------------------------------------------------------------------
2 -- This file is a part of the SocExplorer Software
3 -- Copyright (C) 2012, Plasma Physics Laboratory - CNRS
4 --
5 -- This program is free software; you can redistribute it and/or modify
6 -- it under the terms of the GNU General Public License as published by
7 -- the Free Software Foundation; either version 2 of the License, or
8 -- (at your option) any later version.
9 --
10 -- This program is distributed in the hope that it will be useful,
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 -- GNU General Public License for more details.
14 --
15 -- You should have received a copy of the GNU General Public License
16 -- along with this program; if not, write to the Free Software
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 -------------------------------------------------------------------------------*/
19 /*-- Author : Alexis Jeandet
20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
21 ----------------------------------------------------------------------------*/
22 #include "socexplorersettings.h"
23
24 SocExplorerSettings* SocExplorerSettings::_self=NULL;
25 QSettings* SocExplorerSettings::m_settings=NULL;
26 QSettings* SocExplorerSettings::m_sessionSettings=NULL;
27 SocExplorerSettingsDialog* SocExplorerSettings::m_configDialog = NULL;
28 #include <socexplorergui.h>
29 #include <QFile>
30 #include <QFileInfo>
31 #include <QDir>
32 #include <QDebug>
33
34 #define INIT() \
35 if(Q_UNLIKELY(_self==NULL))\
36 {\
37 init();\
38 }
39
40
41 SocExplorerSettings::SocExplorerSettings(QObject *parent) : QObject(parent)
42 {
43 m_settings = new QSettings();
44 m_configDialog = new SocExplorerSettingsDialog();
45 QAction* trigerGUI = new QAction(tr("Settings"),this);
46 connect(trigerGUI,SIGNAL(triggered()),this,SLOT(popConfigDialog()));
47 SocExplorerGUI::addSettingsAction(trigerGUI);
48 }
49
50 SocExplorerSettings::~SocExplorerSettings()
51 {
52 if(m_settings)
53 {
54 m_settings->sync();
55 delete m_settings;
56 }
57 if(m_sessionSettings)
58 {
59 m_sessionSettings->sync();
60 delete m_sessionSettings;
61 }
62 }
63
64 void SocExplorerSettings::init()
65 {
66 if(!_self)
67 {
68 _self= new SocExplorerSettings();
69 }
70 }
71
72 void SocExplorerSettings::setValue(QObject *object, const QString &key, const QVariant &value, SettingScope Sscope)
73 {
74 INIT();
75 setValue(object->metaObject()->className(),key,value,Sscope);
76 }
77
78 QVariant SocExplorerSettings::value(QObject *object, const QString &key, const QVariant &defaultValue, SettingScope Sscope)
79 {
80 INIT();
81 return value(object->metaObject()->className(),key,defaultValue,Sscope);
82 }
83
84 void SocExplorerSettings::setValue(const QString scope, const QString &key, const QVariant &value, SettingScope Sscope)
85 {
86 INIT();
87 switch (Sscope)
88 {
89 case SystemWide:
90 if(m_settings)
91 m_settings->setValue(scope+"/"+key,value);
92 break;
93 case Session:
94 if(m_sessionSettings)
95 m_sessionSettings->setValue(scope+"/"+key,value);
96 break;
97 default:
98 break;
99 }
100 }
101
102 QVariant SocExplorerSettings::value(const QString scope, const QString &key, const QVariant &defaultValue, SettingScope Sscope)
103 {
104 INIT();
105 switch (Sscope)
106 {
107 case SystemWide:
108 if(m_settings)
109 return m_settings->value(scope+"/"+key,defaultValue);
110 break;
111 case Session:
112 if(m_sessionSettings)
113 return m_sessionSettings->value(scope+"/"+key,defaultValue);
114 break;
115 default:
116 break;
117 }
118 return defaultValue;
119 }
120
121 QList<QList<QVariant> > SocExplorerSettings::arrays(const QString &prefix, QStringList keys, SocExplorerSettings::SettingScope Sscope)
122 {
123 INIT();
124 QList<QList<QVariant> > defaultValue;
125 switch (Sscope)
126 {
127 case SystemWide:
128 if(m_settings)
129 return arrays(prefix,keys,m_settings);
130 break;
131 case Session:
132 if(m_sessionSettings)
133 return arrays(prefix,keys,m_sessionSettings);
134 break;
135 default:
136 break;
137 }
138 return defaultValue;
139 }
140
141 void SocExplorerSettings::sync()
142 {
143 INIT();
144 if(m_settings)
145 {
146 m_settings->sync();
147 }
148 if(m_sessionSettings)
149 {
150 m_sessionSettings->sync();
151 }
152 }
153
154 bool SocExplorerSettings::registerConfigEntry(SocExplorerSettingsItem *configEntry, QIcon icon, QString text)
155 {
156 INIT();
157 return m_configDialog->registerConfigEntry(configEntry,icon,text);
158 }
159
160 bool SocExplorerSettings::loadSession(const QString &session)
161 {
162 INIT();
163 QFileInfo sessionInfo(m_settings->fileName());
164 QString fullpath=sessionInfo.absoluteDir().absolutePath() +"/"+session+".conf";
165 if(m_sessionSettings)
166 {
167 delete m_sessionSettings;
168 m_sessionSettings = NULL;
169 }
170 m_sessionSettings = new QSettings(fullpath,QSettings::NativeFormat,self());
171 qDebug()<< m_sessionSettings->fileName();
172 if(m_sessionSettings->status()==QSettings::NoError)
173 {
174 return true;
175 }
176 delete m_sessionSettings;
177 m_sessionSettings = NULL;
178 return false;
179 }
180
181 void SocExplorerSettings::popConfigDialog()
182 {
183 m_configDialog->popConfigDialog(NULL);
184 }
185
186 QList<QList<QVariant> > SocExplorerSettings::arrays(const QString &prefix, QStringList keys, QSettings *settings)
187 {
188 QList<QList<QVariant> > result;
189 if(settings)
190 {
191 int size = settings->beginReadArray(prefix);
192 for (int i = 0; i < size; ++i)
193 {
194 result.append(QList<QVariant>());
195 settings->setArrayIndex(i);
196 for(int l=0;l<keys.count();l++)
197 {
198 result[i].append(settings->value(keys.at(i)));
199 }
200 }
201 settings->endArray();
202 }
203 return result;
204 }
205
@@ -0,0 +1,66
1 /*------------------------------------------------------------------------------
2 -- This file is a part of the SocExplorer Software
3 -- Copyright (C) 2012, Plasma Physics Laboratory - CNRS
4 --
5 -- This program is free software; you can redistribute it and/or modify
6 -- it under the terms of the GNU General Public License as published by
7 -- the Free Software Foundation; either version 2 of the License, or
8 -- (at your option) any later version.
9 --
10 -- This program is distributed in the hope that it will be useful,
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 -- GNU General Public License for more details.
14 --
15 -- You should have received a copy of the GNU General Public License
16 -- along with this program; if not, write to the Free Software
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 -------------------------------------------------------------------------------*/
19 /*-- Author : Alexis Jeandet
20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
21 ----------------------------------------------------------------------------*/
22 #ifndef SOCEXPLORERSETTINGS_H
23 #define SOCEXPLORERSETTINGS_H
24
25 #include <QObject>
26 #include <QWidget>
27 #include <QSettings>
28 #include <socexplorersettingsdialog.h>
29
30 class SocExplorerSettings : public QObject
31 {
32 Q_OBJECT
33 private:
34 static SocExplorerSettings* _self;
35 static QSettings* m_settings;
36 static QSettings* m_sessionSettings;
37 static SocExplorerSettingsDialog* m_configDialog;
38 SocExplorerSettings(QObject *parent = 0);
39 ~SocExplorerSettings();
40 public:
41 enum SettingScope {
42 SystemWide = 0,
43 Session
44 };
45 static void init();
46 static SocExplorerSettings* self(){ if(!_self){_self= new SocExplorerSettings;}return _self;}
47 static void setValue(QObject* object,const QString & key, const QVariant & value,SettingScope Sscope =SystemWide);
48 static QVariant value(QObject* object, const QString & key, const QVariant & defaultValue = QVariant(),SettingScope Sscope=SystemWide);
49 static void setValue(const QString scope,const QString & key, const QVariant & value,SettingScope Sscope= SystemWide);
50 static QVariant value(const QString scope, const QString & key, const QVariant & defaultValue = QVariant(),SettingScope Sscope =SystemWide);
51 static QList<QList<QVariant> > arrays(const QString & prefix, QStringList keys,SettingScope Sscope =SystemWide);
52 static void sync();
53 static bool registerConfigEntry(SocExplorerSettingsItem* configEntry,QIcon icon, QString text);
54 //! Loads the given session, or sreate it if doesn't exists.
55 //! \param session Session name.
56 //! \return true if success or false if fails to create session config file.
57 static bool loadSession(const QString& session);
58 signals:
59
60 public slots:
61 void popConfigDialog();
62 private:
63 static QList<QList<QVariant> > arrays(const QString & prefix, QStringList keys,QSettings* settings);
64 };
65
66 #endif // SOCEXPLORERSETTINGS_H
@@ -0,0 +1,69
1 #include "socexplorersettingsdialog.h"
2 #include "ui_socexplorersettingsdialog.h"
3
4 SocExplorerSettingsDialog::SocExplorerSettingsDialog(QWidget *parent) :
5 QDialog(parent),
6 ui(new Ui::SocExplorerSettingsDialog)
7 {
8 ui->setupUi(this);
9 connect(ui->contentsWidget, SIGNAL(currentItemChanged(QListWidgetItem*,QListWidgetItem*)),this, SLOT(changePage(QListWidgetItem*,QListWidgetItem*)));
10 ui->contentsWidget->setViewMode(QListView::IconMode);
11 ui->contentsWidget->setIconSize(QSize(96, 84));
12 ui->contentsWidget->setMovement(QListView::Static);
13 ui->contentsWidget->setSpacing(12);
14 }
15
16 SocExplorerSettingsDialog::~SocExplorerSettingsDialog()
17 {
18 delete ui;
19 }
20
21 void SocExplorerSettingsDialog::changePage(QListWidgetItem *current, QListWidgetItem *previous)
22 {
23 if (!current)
24 current = previous;
25 ui->pagesWidget->setCurrentIndex(ui->contentsWidget->row(current));
26 }
27
28 bool SocExplorerSettingsDialog::registerConfigEntry(SocExplorerSettingsItem *configEntry, QIcon icon, QString text)
29 {
30 if(configEntry!=NULL)
31 {
32 ui->pagesWidget->addWidget(configEntry);
33 QListWidgetItem *configButton = new QListWidgetItem(ui->contentsWidget);
34 configButton->setIcon(icon);
35 configButton->setText(text);
36 configButton->setTextAlignment(Qt::AlignHCenter);
37 configButton->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
38 connect(this,SIGNAL(accepted()),configEntry,SLOT(accept()));
39 return true;
40 }
41 return false;
42 }
43
44 void SocExplorerSettingsDialog::popConfigDialog(SocExplorerSettingsItem *selectedConfigEntry)
45 {
46 if(selectedConfigEntry!=NULL)
47 {
48 for(int i=0;i<ui->pagesWidget->count();i++)
49 {
50 if(ui->pagesWidget->widget(i)==selectedConfigEntry)
51 {
52 ui->pagesWidget->setCurrentIndex(i);
53 }
54 }
55 }
56 this->show();
57 }
58
59 void SocExplorerSettingsDialog::changeEvent(QEvent *e)
60 {
61 QDialog::changeEvent(e);
62 switch (e->type()) {
63 case QEvent::LanguageChange:
64 ui->retranslateUi(this);
65 break;
66 default:
67 break;
68 }
69 }
@@ -0,0 +1,41
1 #ifndef SOCEXPLORERSETTINGSDIALOG_H
2 #define SOCEXPLORERSETTINGSDIALOG_H
3
4 #include <QDialog>
5
6 namespace Ui {
7 class SocExplorerSettingsDialog;
8 }
9 #include <QListWidgetItem>
10
11 class SocExplorerSettingsItem : public QWidget
12 {
13 Q_OBJECT
14 public:
15 SocExplorerSettingsItem(QWidget *parent = 0):QWidget(parent) {}
16 ~SocExplorerSettingsItem() {}
17 public slots:
18 virtual void accept()=0;
19 };
20
21 class SocExplorerSettingsDialog : public QDialog
22 {
23 Q_OBJECT
24
25 public:
26 explicit SocExplorerSettingsDialog(QWidget *parent = 0);
27 ~SocExplorerSettingsDialog();
28
29 public slots:
30 void changePage(QListWidgetItem *current, QListWidgetItem *previous);
31 bool registerConfigEntry(SocExplorerSettingsItem* configEntry, QIcon icon, QString text);
32 void popConfigDialog(SocExplorerSettingsItem* selectedConfigEntry=0);
33
34 protected:
35 void changeEvent(QEvent *e);
36
37 private:
38 Ui::SocExplorerSettingsDialog *ui;
39 };
40
41 #endif // SOCEXPLORERSETTINGSDIALOG_H
@@ -0,0 +1,102
1 <?xml version="1.0" encoding="UTF-8"?>
2 <ui version="4.0">
3 <class>SocExplorerSettingsDialog</class>
4 <widget class="QDialog" name="SocExplorerSettingsDialog">
5 <property name="geometry">
6 <rect>
7 <x>0</x>
8 <y>0</y>
9 <width>555</width>
10 <height>329</height>
11 </rect>
12 </property>
13 <property name="windowTitle">
14 <string>Dialog</string>
15 </property>
16 <layout class="QGridLayout" name="gridLayout">
17 <item row="0" column="1">
18 <widget class="QListWidget" name="contentsWidget">
19 <property name="sizePolicy">
20 <sizepolicy hsizetype="Maximum" vsizetype="Expanding">
21 <horstretch>0</horstretch>
22 <verstretch>0</verstretch>
23 </sizepolicy>
24 </property>
25 <property name="minimumSize">
26 <size>
27 <width>100</width>
28 <height>0</height>
29 </size>
30 </property>
31 <property name="maximumSize">
32 <size>
33 <width>16777215</width>
34 <height>16777215</height>
35 </size>
36 </property>
37 </widget>
38 </item>
39 <item row="0" column="2">
40 <widget class="QStackedWidget" name="pagesWidget">
41 <property name="sizePolicy">
42 <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
43 <horstretch>0</horstretch>
44 <verstretch>0</verstretch>
45 </sizepolicy>
46 </property>
47 <property name="minimumSize">
48 <size>
49 <width>100</width>
50 <height>0</height>
51 </size>
52 </property>
53 </widget>
54 </item>
55 <item row="2" column="1" colspan="2">
56 <widget class="QDialogButtonBox" name="buttonBox">
57 <property name="orientation">
58 <enum>Qt::Horizontal</enum>
59 </property>
60 <property name="standardButtons">
61 <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
62 </property>
63 </widget>
64 </item>
65 </layout>
66 </widget>
67 <resources/>
68 <connections>
69 <connection>
70 <sender>buttonBox</sender>
71 <signal>accepted()</signal>
72 <receiver>SocExplorerSettingsDialog</receiver>
73 <slot>accept()</slot>
74 <hints>
75 <hint type="sourcelabel">
76 <x>277</x>
77 <y>304</y>
78 </hint>
79 <hint type="destinationlabel">
80 <x>277</x>
81 <y>164</y>
82 </hint>
83 </hints>
84 </connection>
85 <connection>
86 <sender>buttonBox</sender>
87 <signal>rejected()</signal>
88 <receiver>SocExplorerSettingsDialog</receiver>
89 <slot>reject()</slot>
90 <hints>
91 <hint type="sourcelabel">
92 <x>277</x>
93 <y>304</y>
94 </hint>
95 <hint type="destinationlabel">
96 <x>277</x>
97 <y>164</y>
98 </hint>
99 </hints>
100 </connection>
101 </connections>
102 </ui>
@@ -0,0 +1,37
1 #include "socexplorercoresettingsgui.h"
2 #include "ui_socexplorercoresettingsgui.h"
3 #include <socexplorersettings.h>
4 #include <socexplorerengine.h>
5 #include <socexplorerconfigkeys.h>
6
7 SocExplorerCoreSettingsGUI::SocExplorerCoreSettingsGUI(QWidget *parent) :
8 SocExplorerSettingsItem(parent),
9 ui(new Ui::SocExplorerCoreSettingsGUI)
10 {
11 ui->setupUi(this);
12 this->ui->PluginsLookupPath->setText(SocExplorerSettings::value(SOCEXPLORERENGINE_SETTINGS_SCOPE,SOCEXPLORERENGINE_SETTINGS_PLUGINS_LOOKUP_PATH,"").toString());
13 this->ui->SOCregsLookupPath->setText(SocExplorerSettings::value(SOCEXPLORERENGINE_SETTINGS_SCOPE,SOCEXPLORERENGINE_SETTINGS_SOC_REGS_LOOKUP_PATH,"").toString());
14 }
15
16 SocExplorerCoreSettingsGUI::~SocExplorerCoreSettingsGUI()
17 {
18 delete ui;
19 }
20
21 void SocExplorerCoreSettingsGUI::changeEvent(QEvent *e)
22 {
23 QWidget::changeEvent(e);
24 switch (e->type()) {
25 case QEvent::LanguageChange:
26 ui->retranslateUi(this);
27 break;
28 default:
29 break;
30 }
31 }
32
33 void SocExplorerCoreSettingsGUI::accept()
34 {
35 SocExplorerSettings::setValue(SOCEXPLORERENGINE_SETTINGS_SCOPE,SOCEXPLORERENGINE_SETTINGS_PLUGINS_LOOKUP_PATH,this->ui->PluginsLookupPath->text());
36 SocExplorerSettings::setValue(SOCEXPLORERENGINE_SETTINGS_SCOPE,SOCEXPLORERENGINE_SETTINGS_SOC_REGS_LOOKUP_PATH,this->ui->SOCregsLookupPath->text());
37 }
@@ -0,0 +1,27
1 #ifndef SOCEXPLORERCORESETTINGSGUI_H
2 #define SOCEXPLORERCORESETTINGSGUI_H
3
4 #include <QWidget>
5 #include <socexplorersettingsdialog.h>
6
7 namespace Ui {
8 class SocExplorerCoreSettingsGUI;
9 }
10
11 class SocExplorerCoreSettingsGUI : public SocExplorerSettingsItem
12 {
13 Q_OBJECT
14
15 public:
16 explicit SocExplorerCoreSettingsGUI(QWidget *parent = 0);
17 ~SocExplorerCoreSettingsGUI();
18
19 protected:
20 void changeEvent(QEvent *e);
21 public slots:
22 void accept();
23 private:
24 Ui::SocExplorerCoreSettingsGUI *ui;
25 };
26
27 #endif // SOCEXPLORERCORESETTINGSGUI_H
@@ -0,0 +1,80
1 <?xml version="1.0" encoding="UTF-8"?>
2 <ui version="4.0">
3 <class>SocExplorerCoreSettingsGUI</class>
4 <widget class="QWidget" name="SocExplorerCoreSettingsGUI">
5 <property name="geometry">
6 <rect>
7 <x>0</x>
8 <y>0</y>
9 <width>573</width>
10 <height>274</height>
11 </rect>
12 </property>
13 <property name="windowTitle">
14 <string>Form</string>
15 </property>
16 <layout class="QVBoxLayout" name="verticalLayout">
17 <item>
18 <widget class="QGroupBox" name="groupBox">
19 <property name="title">
20 <string>Plugins</string>
21 </property>
22 <layout class="QFormLayout" name="formLayout">
23 <item row="0" column="0">
24 <widget class="QLabel" name="label">
25 <property name="text">
26 <string>Lookup path</string>
27 </property>
28 </widget>
29 </item>
30 <item row="0" column="1">
31 <widget class="QLineEdit" name="PluginsLookupPath">
32 <property name="toolTip">
33 <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;Semicolon &lt;/span&gt;separated list of path.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
34 </property>
35 </widget>
36 </item>
37 </layout>
38 </widget>
39 </item>
40 <item>
41 <widget class="QGroupBox" name="groupBox_2">
42 <property name="title">
43 <string>SOC registers description</string>
44 </property>
45 <layout class="QFormLayout" name="formLayout_2">
46 <item row="0" column="0">
47 <widget class="QLabel" name="label_2">
48 <property name="text">
49 <string>Lookup path</string>
50 </property>
51 </widget>
52 </item>
53 <item row="0" column="1">
54 <widget class="QLineEdit" name="SOCregsLookupPath">
55 <property name="toolTip">
56 <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-weight:600;&quot;&gt;Semicolon &lt;/span&gt;separated list of path.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
57 </property>
58 </widget>
59 </item>
60 </layout>
61 </widget>
62 </item>
63 <item>
64 <spacer name="verticalSpacer">
65 <property name="orientation">
66 <enum>Qt::Vertical</enum>
67 </property>
68 <property name="sizeHint" stdset="0">
69 <size>
70 <width>20</width>
71 <height>40</height>
72 </size>
73 </property>
74 </spacer>
75 </item>
76 </layout>
77 </widget>
78 <resources/>
79 <connections/>
80 </ui>
@@ -1,4 +1,4
1 1cb664ab4bb3c531d706b1948a378ed9810c0dda src/SocExplorerEngine/PeripheralWidget
1 1cb664ab4bb3c531d706b1948a378ed9810c0dda src/SocExplorerEngine/PeripheralWidget
2 1f143e4ae72a0bb4832b546eb76eb50e94049b80 src/common/genericBinaryFiles
2 1f143e4ae72a0bb4832b546eb76eb50e94049b80 src/common/genericBinaryFiles
3 2dce25b198558be573f56c1cf337aa95ddd666d6 src/common/lppserial
3 2b353bf8243cbfb3db44e196f33bd164c11c9949 src/common/lppserial
4 923afde9cc96bb419cf898560d080ec96991aeca src/common/qhexedit
4 923afde9cc96bb419cf898560d080ec96991aeca src/common/qhexedit
@@ -1,174 +1,186
1 SOCEXPLORER_ROOT = \"$${PWD}/../..\"
1 SOCEXPLORER_ROOT = \"$${PWD}/../..\"
2
2
3 include($${PWD}/../../build_cfg/socexplorer.pri)
3 include($${PWD}/../../build_cfg/socexplorer.pri)
4
4
5 TARGET = socexplorerengine$${DEBUG_EXT}
5 TARGET = socexplorerengine$${DEBUG_EXT}
6 TEMPLATE = lib
6 TEMPLATE = lib
7
7
8 #more verbose plugin loader to debug plugin loading issues such as dependencies issues
8 #more verbose plugin loader to debug plugin loading issues such as dependencies issues
9 SOCEXPLORER_PLUGIN_LOADER="custom"
9 SOCEXPLORER_PLUGIN_LOADER="custom"
10
10
11 SOCEXPLORER_CHAGESETNUM=$$system(hg id)
11 SOCEXPLORER_CHAGESETNUM=$$system(hg id)
12 isEmpty(SOCEXPLORER_CHAGESETNUM){
12 isEmpty(SOCEXPLORER_CHAGESETNUM){
13 SOCEXPLORER_CHAGESETNUM=e9c30654210d+
13 SOCEXPLORER_CHAGESETNUM=e9c30654210d+
14 }
14 }
15 SOCEXPLORER_CHAGESETNUMSTR = '\\"$${SOCEXPLORER_CHAGESETNUM}\\"'
15 SOCEXPLORER_CHAGESETNUMSTR = '\\"$${SOCEXPLORER_CHAGESETNUM}\\"'
16 SOCEXPLORER_BRANCH=$$system(hg branch)
16 SOCEXPLORER_BRANCH=$$system(hg branch)
17 isEmpty(SOCEXPLORER_BRANCH){
17 isEmpty(SOCEXPLORER_BRANCH){
18 SOCEXPLORER_BRANCH=default
18 SOCEXPLORER_BRANCH=default
19 }
19 }
20 SOCEXPLORER_BRANCHSTR = '\\"$${SOCEXPLORER_BRANCH}\\"'
20 SOCEXPLORER_BRANCHSTR = '\\"$${SOCEXPLORER_BRANCH}\\"'
21
21
22 DEFINES += SOCEXPLORER_VERSION="\"\\\"0.6.2"\\\"\"
22 DEFINES += SOCEXPLORER_VERSION="\"\\\"0.6.2"\\\"\"
23 DEFINES += SOCEXPLORER_CHAGESET=\"$${SOCEXPLORER_CHAGESETNUMSTR}\"
23 DEFINES += SOCEXPLORER_CHAGESET=\"$${SOCEXPLORER_CHAGESETNUMSTR}\"
24 DEFINES += SOCEXPLORER_BRANCH=\"$${SOCEXPLORER_BRANCHSTR}\"
24 DEFINES += SOCEXPLORER_BRANCH=\"$${SOCEXPLORER_BRANCHSTR}\"
25
25
26
26
27 message("Building SOCEXPLORER changeset $${SOCEXPLORER_CHAGESETNUM}")
27 message("Building SOCEXPLORER changeset $${SOCEXPLORER_CHAGESETNUM}")
28
28
29 DEFINES += SOCEXPLORER_EXPORTS
29 DEFINES += SOCEXPLORER_EXPORTS
30
30
31 include ( plugins/socexplorerplugin.prf )
31 include ( plugins/socexplorerplugin.prf )
32 include ( PeripheralWidget/PeripheralWidget.pri)
32 include ( PeripheralWidget/PeripheralWidget.pri)
33
33
34 win32:CONFIG += dll
34 win32:CONFIG += dll
35 win32:CONFIG -= static
35 win32:CONFIG -= static
36 win32:LIBS+=-L$${SOCEXPLORER_ROOT}/bin/win32 -lsocexplorercommon$${DEBUG_EXT}
36 win32:LIBS+=-L$${SOCEXPLORER_ROOT}/bin/win32 -lsocexplorercommon$${DEBUG_EXT}
37
37
38 contains(SOCEXPLORER_PLUGIN_LOADER,"custom")
38 contains(SOCEXPLORER_PLUGIN_LOADER,"custom")
39 {
39 {
40 unix:LIBS+= -ldl
40 unix:LIBS+= -ldl
41 unix:DEFINES += SOCEXPLORER_CUSTOM_PLUGIN_LOADER
41 unix:DEFINES += SOCEXPLORER_CUSTOM_PLUGIN_LOADER
42 unix:HEADERS += \
42 unix:HEADERS += \
43 pluginloader/unix/unixpluginloader.h
43 pluginloader/unix/unixpluginloader.h
44 unix:SOURCES += \
44 unix:SOURCES += \
45 pluginloader/unix/unixpluginloader.cpp
45 pluginloader/unix/unixpluginloader.cpp
46 }
46 }
47
47
48 target.path = $$[QT_INSTALL_LIBS]
48 target.path = $$[QT_INSTALL_LIBS]
49 isEmpty(target.path) {
49 isEmpty(target.path) {
50 error(can\'t get QT_INSTALL_LIBS)
50 error(can\'t get QT_INSTALL_LIBS)
51 }
51 }
52
52
53 header.path = $$[QT_INSTALL_HEADERS]/SocExplorer
53 header.path = $$[QT_INSTALL_HEADERS]/SocExplorer
54 header.files = engine/socexplorerengine.h \
54 header.files = engine/socexplorerengine.h \
55 pluginloader/pluginscache.h \
55 pluginloader/pluginscache.h \
56 plugins/socexplorerplugin.h \
56 plugins/socexplorerplugin.h \
57 proxy/socexplorerproxy.h \
57 proxy/socexplorerproxy.h \
58 engine/socexplorerxmlfile.h \
58 engine/socexplorerxmlfile.h \
59 SOC/socexplorerenumdevice.h \
59 SOC/socexplorerenumdevice.h \
60 XmlEngine/XMLmodel.h \
60 XmlEngine/XMLmodel.h \
61 XmlEngine/XMLdata.h \
61 XmlEngine/XMLdata.h \
62 XmlEngine/xmldriver.h \
62 XmlEngine/xmldriver.h \
63 SOC/socmodel.h \
63 SOC/socmodel.h \
64 SOC/registerdata.h \
64 SOC/registerdata.h \
65 SOC/socclk.h \
65 SOC/socclk.h \
66 PeripheralWidget/src/peripheralwidget.h \
66 PeripheralWidget/src/peripheralwidget.h \
67 PeripheralWidget/src/registerwidget.h \
67 PeripheralWidget/src/registerwidget.h \
68 PeripheralWidget/src/socregsviewer.h \
68 PeripheralWidget/src/socregsviewer.h \
69 PeripheralWidget/src/socregsviewernew.h \
69 PeripheralWidget/src/socregsviewernew.h \
70 memtester/memtester.h
70 memtester/memtester.h \
71 engine/socexplorersettings.h \
72 engine/socexplorersettingsdialog.h \
73 engine/socexplorergui.h\
74 engine/socexplorerconfigkeys.h
71
75
72
76
73
77
74 isEmpty(header.path) {
78 isEmpty(header.path) {
75 error(can\'t get QT_INSTALL_HEADERS)
79 error(can\'t get QT_INSTALL_HEADERS)
76 }
80 }
77
81
78 pluginif.files = pluginsInterface/*.h \
82 pluginif.files = pluginsInterface/*.h \
79 pluginsInterface/*.cpp
83 pluginsInterface/*.cpp
80
84
81 pluginif.path = $$[QT_INSTALL_HEADERS]/SocExplorer/pluginsInterface
85 pluginif.path = $$[QT_INSTALL_HEADERS]/SocExplorer/pluginsInterface
82
86
83
87
84 INSTALLS += target header pluginif
88 INSTALLS += target header pluginif
85
89
86 INCLUDEPATH += engine \
90 INCLUDEPATH += engine \
87 pluginloader \
91 pluginloader \
88 pluginsInterface \
92 pluginsInterface \
89 proxy \
93 proxy \
90 plugins \
94 plugins \
91 pluginManagerWdgt \
95 pluginManagerWdgt \
92 ../common \
96 ../common \
93 ../common/genericBinaryFiles \
97 ../common/genericBinaryFiles \
94 ../ \
98 ../ \
95 RegisterMVS \
99 RegisterMVS \
96 XmlEngine \
100 XmlEngine \
97 SOC \
101 SOC \
98 PeripheralWidget/src \
102 PeripheralWidget/src \
99 memtester
103 memtester
100
104
101
105
102 HEADERS += \
106 HEADERS += \
103 pluginloader/pluginscache.h \
107 pluginloader/pluginscache.h \
104 pluginloader/pluginloader.h \
108 pluginloader/pluginloader.h \
105 pluginManagerWdgt/plugintree.h \
109 pluginManagerWdgt/plugintree.h \
106 pluginManagerWdgt/pluginmanagerWDGT.h \
110 pluginManagerWdgt/pluginmanagerWDGT.h \
107 pluginManagerWdgt/pluginlist.h \
111 pluginManagerWdgt/pluginlist.h \
108 pluginManagerWdgt/plugininfoswdgt.h \
112 pluginManagerWdgt/plugininfoswdgt.h \
109 XmlEngine/XMLmodel.h \
113 XmlEngine/XMLmodel.h \
110 XmlEngine/XMLdata.h \
114 XmlEngine/XMLdata.h \
111 SOC/socmodel.h \
115 SOC/socmodel.h \
112 SOC/registerdata.h \
116 SOC/registerdata.h \
113 XmlEngine/xmldriver.h \
117 XmlEngine/xmldriver.h \
114 PeripheralWidget/src/peripheralwidget.h \
118 PeripheralWidget/src/peripheralwidget.h \
115 PeripheralWidget/src/registerwidget.h \
119 PeripheralWidget/src/registerwidget.h \
116 PeripheralWidget/src/socregsviewer.h \
120 PeripheralWidget/src/socregsviewer.h \
117 SOC/socclk.h \
121 SOC/socclk.h \
118 engine/socexplorerengine.h \
122 engine/socexplorerengine.h \
119 engine/socexplorerxmlfile.h \
123 engine/socexplorerxmlfile.h \
120 plugins/socexplorerplugin.h \
124 plugins/socexplorerplugin.h \
121 pluginsInterface/socexplorerplugininterface.h \
125 pluginsInterface/socexplorerplugininterface.h \
122 pluginsInterface/socexplorerplugininterface_global.h \
126 pluginsInterface/socexplorerplugininterface_global.h \
123 proxy/socexplorerproxy.h \
127 proxy/socexplorerproxy.h \
124 SOC/socexplorerenumdevice.h \
128 SOC/socexplorerenumdevice.h \
125 PySocExplorerEngine.h \
129 PySocExplorerEngine.h \
126 memtester/memtester.h\
130 memtester/memtester.h\
127 PeripheralWidget/src/socregsviewernew.h \
131 PeripheralWidget/src/socregsviewernew.h \
128 PeripheralWidget/src/collapsableperipheralwidget.h
132 PeripheralWidget/src/collapsableperipheralwidget.h \
133 engine/socexplorersettings.h \
134 engine/socexplorersettingsdialog.h \
135 engine/socexplorergui.h \
136 engine/socexplorerconfigkeys.h
129
137
130
138
131
139
132
140
133
141
134
142
135 SOURCES += \
143 SOURCES += \
136 pluginloader/pluginscache.cpp \
144 pluginloader/pluginscache.cpp \
137 pluginloader/pluginloader.cpp \
145 pluginloader/pluginloader.cpp \
138 pluginManagerWdgt/plugintree.cpp \
146 pluginManagerWdgt/plugintree.cpp \
139 pluginManagerWdgt/pluginmanagerWDGT.cpp \
147 pluginManagerWdgt/pluginmanagerWDGT.cpp \
140 pluginManagerWdgt/pluginlist.cpp \
148 pluginManagerWdgt/pluginlist.cpp \
141 pluginManagerWdgt/plugininfoswdgt.cpp \
149 pluginManagerWdgt/plugininfoswdgt.cpp \
142 XmlEngine/XMLmodel.cpp \
150 XmlEngine/XMLmodel.cpp \
143 XmlEngine/XMLdata.cpp \
151 XmlEngine/XMLdata.cpp \
144 SOC/socmodel.cpp \
152 SOC/socmodel.cpp \
145 SOC/registerdata.cpp \
153 SOC/registerdata.cpp \
146 XmlEngine/xmldriver.cpp \
154 XmlEngine/xmldriver.cpp \
147 PeripheralWidget/src/peripheralwidget.cpp \
155 PeripheralWidget/src/peripheralwidget.cpp \
148 PeripheralWidget/src/registerwidget.cpp \
156 PeripheralWidget/src/registerwidget.cpp \
149 PeripheralWidget/src/socregsviewer.cpp \
157 PeripheralWidget/src/socregsviewer.cpp \
150 SOC/socclk.cpp \
158 SOC/socclk.cpp \
151 engine/socexplorerengine.cpp \
159 engine/socexplorerengine.cpp \
152 engine/socexplorerxmlfile.cpp \
160 engine/socexplorerxmlfile.cpp \
153 proxy/socexplorerproxy.cpp \
161 proxy/socexplorerproxy.cpp \
154 SOC/socexplorerenumdevice.cpp \
162 SOC/socexplorerenumdevice.cpp \
155 plugins/socexplorerplugin.cpp \
163 plugins/socexplorerplugin.cpp \
156 memtester/memtester.cpp \
164 memtester/memtester.cpp \
157 PeripheralWidget/src/socregsviewernew.cpp \
165 PeripheralWidget/src/socregsviewernew.cpp \
158 PeripheralWidget/src/collapsableperipheralwidget.cpp
166 PeripheralWidget/src/collapsableperipheralwidget.cpp \
167 engine/socexplorersettings.cpp \
168 engine/socexplorersettingsdialog.cpp \
169 engine/socexplorergui.cpp
159
170
160
171
161 OTHER_FILES += \
172 OTHER_FILES += \
162 plugins/socexplorerplugin.cpp \
173 plugins/socexplorerplugin.cpp \
163 pluginsInterface/socexplorerplugininterface.cpp \
174 pluginsInterface/socexplorerplugininterface.cpp \
164 plugins/socexplorerplugin.prf \
175 plugins/socexplorerplugin.prf \
165 pythongenerator.sh \
176 pythongenerator.sh \
166 pythonQtgeneratorCfg.txt
177 pythonQtgeneratorCfg.txt
167
178
168 FORMS += \
179 FORMS += \
169 PeripheralWidget/src/socregsviewernew.ui \
180 PeripheralWidget/src/socregsviewernew.ui \
170 PeripheralWidget/src/collapsableperipheralwidget.ui
181 PeripheralWidget/src/collapsableperipheralwidget.ui \
182 engine/socexplorersettingsdialog.ui
171
183
172
184
173 RESOURCES += \
185 RESOURCES += \
174 PeripheralWidget/ressources/peripheralwidget.qrc
186 PeripheralWidget/ressources/peripheralwidget.qrc
@@ -1,300 +1,315
1 /*------------------------------------------------------------------------------
1 /*------------------------------------------------------------------------------
2 -- This file is a part of the SocExplorer Software
2 -- This file is a part of the SocExplorer Software
3 -- Copyright (C) 2012, Plasma Physics Laboratory - CNRS
3 -- Copyright (C) 2012, Plasma Physics Laboratory - CNRS
4 --
4 --
5 -- This program is free software; you can redistribute it and/or modify
5 -- This program is free software; you can redistribute it and/or modify
6 -- it under the terms of the GNU General Public License as published by
6 -- it under the terms of the GNU General Public License as published by
7 -- the Free Software Foundation; either version 2 of the License, or
7 -- the Free Software Foundation; either version 2 of the License, or
8 -- (at your option) any later version.
8 -- (at your option) any later version.
9 --
9 --
10 -- This program is distributed in the hope that it will be useful,
10 -- This program is distributed in the hope that it will be useful,
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 -- GNU General Public License for more details.
13 -- GNU General Public License for more details.
14 --
14 --
15 -- You should have received a copy of the GNU General Public License
15 -- You should have received a copy of the GNU General Public License
16 -- along with this program; if not, write to the Free Software
16 -- along with this program; if not, write to the Free Software
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 -------------------------------------------------------------------------------*/
18 -------------------------------------------------------------------------------*/
19 /*-- Author : Alexis Jeandet
19 /*-- Author : Alexis Jeandet
20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
21 ----------------------------------------------------------------------------*/
21 ----------------------------------------------------------------------------*/
22 #include "socexplorerengine.h"
22 #include "socexplorerengine.h"
23 #include <proxy/socexplorerproxy.h>
23 #include <proxy/socexplorerproxy.h>
24 #include <socexplorersettings.h>
25 #include <socexplorercoresettingsgui.h>
26 #include <socexplorerconfigkeys.h>
24
27
25 SocExplorerEngine* SocExplorerEngine::_self = NULL;
28 SocExplorerEngine* SocExplorerEngine::_self = NULL;
26 socExplorerXmlModel* SocExplorerEngine::p_xmlmodel=NULL;
29 socExplorerXmlModel* SocExplorerEngine::p_xmlmodel=NULL;
27 QMainWindow* SocExplorerEngine::mainWindow=NULL;
30 QMainWindow* SocExplorerEngine::mainWindow=NULL;
28 QList<SOCModel*>* SocExplorerEngine::SOCs=NULL;
31 QList<SOCModel*>* SocExplorerEngine::SOCs=NULL;
32 QSettings* SocExplorerEngine::m_settings=NULL;
29 int SocExplorerEngine::loglvl=1;
33 int SocExplorerEngine::loglvl=1;
30
34
35
31 SocExplorerEngine::SocExplorerEngine(QObject *parent) :
36 SocExplorerEngine::SocExplorerEngine(QObject *parent) :
32 QObject(parent)
37 QObject(parent)
33 {
38 {
34 if(SOCs==NULL)
39 if(SOCs==NULL)
35 {
40 {
36 SOCs = new QList<SOCModel*>;
41 SOCs = new QList<SOCModel*>;
37 }
42 }
38
43 m_settings = new QSettings();
44 SocExplorerCoreSettingsGUI* cfggui=new SocExplorerCoreSettingsGUI();
45 SocExplorerSettings::registerConfigEntry(cfggui,QIcon(":/images/config.svg"),"SocExplorer Core");
39 }
46 }
40
47
41
48
42 void SocExplorerEngine::init()
49 void SocExplorerEngine::init()
43 {
50 {
44 QDir dir;
51 QDir dir;
45 if(!_self)
52 if(!_self)
46 {
53 {
47 _self= new SocExplorerEngine;
54 _self= new SocExplorerEngine;
48 }
55 }
49 if(!dir.exists(configFolder()))
56 if(!dir.exists(configFolder()))
50 dir.mkdir(configFolder());
57 dir.mkdir(configFolder());
51 p_xmlmodel = new socExplorerXmlModel(_self);
58 p_xmlmodel = new socExplorerXmlModel(_self);
52 p_xmlmodel->updateSOClist();
59 p_xmlmodel->updateSOClist();
53 }
60 }
54
61
55 QString SocExplorerEngine::configFolder()
62 QString SocExplorerEngine::configFolder()
56 {
63 {
57 return QString(SOCEXPLORER_CONFIG_PATH);
64 return QString(SOCEXPLORER_CONFIG_PATH);
58 }
65 }
59
66
60 QStringList SocExplorerEngine::pluginFolders()
67 QStringList SocExplorerEngine::pluginFolders()
61 {
68 {
62 if(!_self)
69 if(!_self)
63 init();
70 init();
64 QStringList folders;
71 QStringList folders;
65 QDir pluginFolders(QString(SOCEXPLORER_CONFIG_PATH)+"/plugin.conf.d");
72 QDir pluginFolders(QString(SOCEXPLORER_CONFIG_PATH)+"/plugin.conf.d");
66 if(pluginFolders.exists())
73 if(pluginFolders.exists())
67 {
74 {
68 pluginFolders.setFilter(QDir::Files | QDir::NoSymLinks);
75 pluginFolders.setFilter(QDir::Files | QDir::NoSymLinks);
69 QFileInfoList list = pluginFolders.entryInfoList();
76 QFileInfoList list = pluginFolders.entryInfoList();
70 for (int i = 0; i < list.size(); ++i)
77 for (int i = 0; i < list.size(); ++i)
71 {
78 {
72 QFileInfo fileInfo = list.at(i);
79 QFileInfo fileInfo = list.at(i);
73 if(fileInfo.suffix()=="conf")
80 if(fileInfo.suffix()=="conf")
74 {
81 {
75 QFile confFile(fileInfo.absoluteFilePath());
82 QFile confFile(fileInfo.absoluteFilePath());
76 if(confFile.open(QIODevice::ReadOnly))
83 if(confFile.open(QIODevice::ReadOnly))
77 {
84 {
78 while (!confFile.atEnd())
85 while (!confFile.atEnd())
79 {
86 {
80 QString line = confFile.readLine();
87 QString line = confFile.readLine();
81 QDir plugDir(line.remove("\n"));
88 QDir plugDir(line.remove("\n"));
82 if(plugDir.exists() && !folders.contains(plugDir.absolutePath()))
89 if(plugDir.exists() && !folders.contains(plugDir.absolutePath()))
83 {
90 {
84 folders.append(plugDir.absolutePath());
91 folders.append(plugDir.absolutePath());
85 }
92 }
86 }
93 }
87 }
94 }
88 }
95 }
89 }
96 }
90 }
97 }
98 QStringList localCfg = SocExplorerSettings::value(SOCEXPLORERENGINE_SETTINGS_SCOPE,SOCEXPLORERENGINE_SETTINGS_PLUGINS_LOOKUP_PATH).toString().split(";");
99 QString dir;
100 foreach (dir, localCfg)
101 {
102 QDir plugDir(dir);
103 if(plugDir.exists())
104 folders.append(dir);
105 }
91 return folders;
106 return folders;
92 }
107 }
93
108
94 SOCModel *SocExplorerEngine::plugin2Soc(socexplorerplugin *plugin)
109 SOCModel *SocExplorerEngine::plugin2Soc(socexplorerplugin *plugin)
95 {
110 {
96 if(!_self)
111 if(!_self)
97 init();
112 init();
98 if(plugin)
113 if(plugin)
99 {
114 {
100 while (plugin->parent!=NULL) {
115 while (plugin->parent!=NULL) {
101 plugin = plugin->parent;
116 plugin = plugin->parent;
102 }
117 }
103 for(int i=0;i<SOCs->count();i++)
118 for(int i=0;i<SOCs->count();i++)
104 {
119 {
105 if(SOCs->at(i)->isRootDev(plugin))
120 if(SOCs->at(i)->isRootDev(plugin))
106 return SOCs->at(i);
121 return SOCs->at(i);
107 }
122 }
108 //no soc found so create a new one
123 //no soc found so create a new one
109 SOCModel* soc=new SOCModel(plugin);
124 SOCModel* soc=new SOCModel(plugin);
110 SOCs->append(soc);
125 SOCs->append(soc);
111 return soc;
126 return soc;
112 }
127 }
113 return NULL;
128 return NULL;
114 }
129 }
115
130
116
131
117 int SocExplorerEngine::addEnumDevice(socexplorerplugin* rootPlugin,int VID, int PID, qint32 baseAddress, const QString &name)
132 int SocExplorerEngine::addEnumDevice(socexplorerplugin* rootPlugin,int VID, int PID, qint32 baseAddress, const QString &name)
118 {
133 {
119 if(!_self)
134 if(!_self)
120 init();
135 init();
121 SOCModel* soc = plugin2Soc(rootPlugin);
136 SOCModel* soc = plugin2Soc(rootPlugin);
122 if(soc && !soc->enumDeviceExists(baseAddress))
137 if(soc && !soc->enumDeviceExists(baseAddress))
123 {
138 {
124 emit _self->enumDeviceAdded(soc->addEnumDevice(VID,PID,baseAddress,name));
139 emit _self->enumDeviceAdded(soc->addEnumDevice(VID,PID,baseAddress,name));
125 return 1;
140 return 1;
126 }
141 }
127 return 0;
142 return 0;
128 }
143 }
129
144
130 QList<SOCModel *> *SocExplorerEngine::getSOCs()
145 QList<SOCModel *> *SocExplorerEngine::getSOCs()
131 {
146 {
132 if(!_self)
147 if(!_self)
133 init();
148 init();
134 return SOCs;
149 return SOCs;
135 }
150 }
136
151
137 qint32 SocExplorerEngine::getEnumDeviceBaseAddress(const QString& rootPlugin,int VID, int PID, int count)
152 qint32 SocExplorerEngine::getEnumDeviceBaseAddress(const QString& rootPlugin,int VID, int PID, int count)
138 {
153 {
139 socexplorerplugin* plugin = socexplorerproxy::findPlugin(rootPlugin);
154 socexplorerplugin* plugin = socexplorerproxy::findPlugin(rootPlugin);
140 if(plugin==NULL)return -1;
155 if(plugin==NULL)return -1;
141 SOCModel* soc = plugin2Soc(plugin);
156 SOCModel* soc = plugin2Soc(plugin);
142 if(soc==NULL)
157 if(soc==NULL)
143 return -1;
158 return -1;
144 return soc->getEnumDeviceBaseAddress(VID,PID,count);
159 return soc->getEnumDeviceBaseAddress(VID,PID,count);
145 }
160 }
146
161
147 qint32 SocExplorerEngine::getEnumDeviceBaseAddress(socexplorerplugin *plugin, int VID, int PID, int count)
162 qint32 SocExplorerEngine::getEnumDeviceBaseAddress(socexplorerplugin *plugin, int VID, int PID, int count)
148 {
163 {
149 if(plugin==NULL)return -1;
164 if(plugin==NULL)return -1;
150 SOCModel* soc = plugin2Soc(plugin);
165 SOCModel* soc = plugin2Soc(plugin);
151 if(soc==NULL)
166 if(soc==NULL)
152 return -1;
167 return -1;
153 return soc->getEnumDeviceBaseAddress(VID,PID,count);
168 return soc->getEnumDeviceBaseAddress(VID,PID,count);
154 }
169 }
155
170
156 qint32 SocExplorerEngine::getEnumDeviceCount(socexplorerplugin *plugin, int VID, int PID)
171 qint32 SocExplorerEngine::getEnumDeviceCount(socexplorerplugin *plugin, int VID, int PID)
157 {
172 {
158 if(plugin==NULL)return 0;
173 if(plugin==NULL)return 0;
159 SOCModel* soc = plugin2Soc(plugin);
174 SOCModel* soc = plugin2Soc(plugin);
160 if(soc==NULL)
175 if(soc==NULL)
161 return 0;
176 return 0;
162 return soc->getEnumDeviceCount(VID,PID);
177 return soc->getEnumDeviceCount(VID,PID);
163 }
178 }
164
179
165 qint32 SocExplorerEngine::getEnumDeviceCount(const QString &rootPlugin, int VID, int PID)
180 qint32 SocExplorerEngine::getEnumDeviceCount(const QString &rootPlugin, int VID, int PID)
166 {
181 {
167 socexplorerplugin* plugin = socexplorerproxy::findPlugin(rootPlugin);
182 socexplorerplugin* plugin = socexplorerproxy::findPlugin(rootPlugin);
168 if(plugin==NULL)return 0;
183 if(plugin==NULL)return 0;
169 SOCModel* soc = plugin2Soc(plugin);
184 SOCModel* soc = plugin2Soc(plugin);
170 if(soc==NULL)
185 if(soc==NULL)
171 return 0;
186 return 0;
172 return soc->getEnumDeviceCount(VID,PID);
187 return soc->getEnumDeviceCount(VID,PID);
173 }
188 }
174
189
175 int SocExplorerEngine::addEnumDevice(const QString &rootPlugin, int VID, int PID, qint32 baseAddress, const QString &name)
190 int SocExplorerEngine::addEnumDevice(const QString &rootPlugin, int VID, int PID, qint32 baseAddress, const QString &name)
176 {
191 {
177 socexplorerplugin* plugin = socexplorerproxy::findPlugin(rootPlugin);
192 socexplorerplugin* plugin = socexplorerproxy::findPlugin(rootPlugin);
178 if(plugin==NULL)return -1;
193 if(plugin==NULL)return -1;
179 SOCModel* soc = plugin2Soc(plugin);
194 SOCModel* soc = plugin2Soc(plugin);
180 if(soc==NULL)
195 if(soc==NULL)
181 return -1;
196 return -1;
182 soc->addEnumDevice(VID,PID,baseAddress,name);
197 soc->addEnumDevice(VID,PID,baseAddress,name);
183 return 1;
198 return 1;
184 }
199 }
185
200
186 unsigned int SocExplorerEngine::memMeasureSize(socexplorerplugin *plugin, unsigned int address, unsigned int maxSize)
201 unsigned int SocExplorerEngine::memMeasureSize(socexplorerplugin *plugin, unsigned int address, unsigned int maxSize)
187 {
202 {
188 return MemTester::measureMemSize(plugin,address,maxSize);
203 return MemTester::measureMemSize(plugin,address,maxSize);
189 }
204 }
190
205
191 unsigned int SocExplorerEngine::memMeasureSize(const QString &plugin, unsigned int address, unsigned int maxSize)
206 unsigned int SocExplorerEngine::memMeasureSize(const QString &plugin, unsigned int address, unsigned int maxSize)
192 {
207 {
193 return MemTester::measureMemSize(plugin,address,maxSize);
208 return MemTester::measureMemSize(plugin,address,maxSize);
194 }
209 }
195
210
196
211
197 QString SocExplorerEngine::getDevName(int VID, int PID)
212 QString SocExplorerEngine::getDevName(int VID, int PID)
198 {
213 {
199 QList<QDomNodeList> list=p_xmlmodel->getAllNodes("peripheral");
214 QList<QDomNodeList> list=p_xmlmodel->getAllNodes("peripheral");
200 for(int i=0;i<list.count();i++)
215 for(int i=0;i<list.count();i++)
201 {
216 {
202 QDomNodeList nodes=list.at(i);
217 QDomNodeList nodes=list.at(i);
203 for(int l=0;l<nodes.count();l++)
218 for(int l=0;l<nodes.count();l++)
204 {
219 {
205 QDomElement node=nodes.at(l).toElement();
220 QDomElement node=nodes.at(l).toElement();
206 int nodeVID=node.attribute("vid","0").toInt();
221 int nodeVID=node.attribute("vid","0").toInt();
207 int nodePID=node.attribute("pid","0").toInt();
222 int nodePID=node.attribute("pid","0").toInt();
208 if((nodeVID==VID)&&(nodePID==PID))
223 if((nodeVID==VID)&&(nodePID==PID))
209 {
224 {
210 return node.attribute("name","Unknow device");
225 return node.attribute("name","Unknow device");
211 }
226 }
212 }
227 }
213 }
228 }
214 return QString("Unknow device");
229 return QString("Unknow device");
215 }
230 }
216
231
217 QString SocExplorerEngine::SocExplorerVersion(){return QString(SOCEXPLORER_VERSION);}
232 QString SocExplorerEngine::SocExplorerVersion(){return QString(SOCEXPLORER_VERSION);}
218
233
219 QString SocExplorerEngine::SocExplorerChangeset(){return QString(SOCEXPLORER_CHAGESET).split(" ").at(0);}
234 QString SocExplorerEngine::SocExplorerChangeset(){return QString(SOCEXPLORER_CHAGESET).split(" ").at(0);}
220
235
221 QString SocExplorerEngine::SocExplorerBranch(){return QString(SOCEXPLORER_BRANCH);}
236 QString SocExplorerEngine::SocExplorerBranch(){return QString(SOCEXPLORER_BRANCH);}
222
237
223 socExplorerXmlModel *SocExplorerEngine::xmlModel()
238 socExplorerXmlModel *SocExplorerEngine::xmlModel()
224 {
239 {
225 if(!_self)
240 if(!_self)
226 init();
241 init();
227 return p_xmlmodel;
242 return p_xmlmodel;
228 }
243 }
229
244
230 void SocExplorerEngine::setMainWindow(QMainWindow *Mainwindow)
245 void SocExplorerEngine::setMainWindow(QMainWindow *Mainwindow)
231 {
246 {
232 if(!_self)
247 if(!_self)
233 init();
248 init();
234 mainWindow=Mainwindow;
249 mainWindow=Mainwindow;
235 }
250 }
236
251
237 QProgressBar *SocExplorerEngine::getProgressBar(const QString& format, int max)
252 QProgressBar *SocExplorerEngine::getProgressBar(const QString& format, int max)
238 {
253 {
239 if(!_self)
254 if(!_self)
240 init();
255 init();
241 QProgressBar* progressBar;
256 QProgressBar* progressBar;
242 if(mainWindow!=NULL)
257 if(mainWindow!=NULL)
243 {
258 {
244 progressBar = new QProgressBar(mainWindow);
259 progressBar = new QProgressBar(mainWindow);
245 mainWindow->statusBar()->addWidget(progressBar);
260 mainWindow->statusBar()->addWidget(progressBar);
246 }
261 }
247 else
262 else
248 {
263 {
249 progressBar = new QProgressBar();
264 progressBar = new QProgressBar();
250 }
265 }
251 progressBar->setMaximum(max);
266 progressBar->setMaximum(max);
252 progressBar->setFormat(format);
267 progressBar->setFormat(format);
253 return progressBar;
268 return progressBar;
254 }
269 }
255
270
256 void SocExplorerEngine::deleteProgressBar(QProgressBar *progressBar)
271 void SocExplorerEngine::deleteProgressBar(QProgressBar *progressBar)
257 {
272 {
258 if(mainWindow!=NULL)
273 if(mainWindow!=NULL)
259 {
274 {
260 mainWindow->statusBar()->removeWidget(progressBar);
275 mainWindow->statusBar()->removeWidget(progressBar);
261 }
276 }
262 delete progressBar;
277 delete progressBar;
263 }
278 }
264
279
265 void SocExplorerEngine::addSOC(socexplorerplugin *rootPlugin)
280 void SocExplorerEngine::addSOC(socexplorerplugin *rootPlugin)
266 {
281 {
267 plugin2Soc(rootPlugin);
282 plugin2Soc(rootPlugin);
268 }
283 }
269
284
270 void SocExplorerEngine::removeSOC(socexplorerplugin *rootPlugin)
285 void SocExplorerEngine::removeSOC(socexplorerplugin *rootPlugin)
271 {
286 {
272 SOCModel* soc=plugin2Soc(rootPlugin);
287 SOCModel* soc=plugin2Soc(rootPlugin);
273 SOCs->removeAll(soc);
288 SOCs->removeAll(soc);
274 delete soc;
289 delete soc;
275 }
290 }
276
291
277 void SocExplorerEngine::message(socexplorerplugin *sender, const QString &message, int debugLevel)
292 void SocExplorerEngine::message(socexplorerplugin *sender, const QString &message, int debugLevel)
278 {
293 {
279 // TODO add multi output message manager IE also log in files
294 // TODO add multi output message manager IE also log in files
280 if(!_self)
295 if(!_self)
281 init();
296 init();
282 if(loglvl>=debugLevel)
297 if(loglvl>=debugLevel)
283 qDebug()<< QTime::currentTime().toString()+" " + sender->instanceName()+":"+message;
298 qDebug()<< QTime::currentTime().toString()+" " + sender->instanceName()+":"+message;
284 }
299 }
285
300
286 void SocExplorerEngine::setLogLevel(int level)
301 void SocExplorerEngine::setLogLevel(int level)
287 {
302 {
288 if(!_self)
303 if(!_self)
289 init();
304 init();
290 printf("Set log level to %d\n",level);
305 printf("Set log level to %d\n",level);
291 loglvl = level;
306 loglvl = level;
292 }
307 }
293
308
294 bool SocExplorerEngine::isSocLitleEndian(socexplorerplugin *plugin)
309 bool SocExplorerEngine::isSocLitleEndian(socexplorerplugin *plugin)
295 {
310 {
296 return plugin2Soc(plugin)->isLitleEndian();
311 return plugin2Soc(plugin)->isLitleEndian();
297 }
312 }
298
313
299
314
300
315
@@ -1,141 +1,143
1 /*------------------------------------------------------------------------------
1 /*------------------------------------------------------------------------------
2 -- This file is a part of the SocExplorer Software
2 -- This file is a part of the SocExplorer Software
3 -- Copyright (C) 2012, Plasma Physics Laboratory - CNRS
3 -- Copyright (C) 2012, Plasma Physics Laboratory - CNRS
4 --
4 --
5 -- This program is free software; you can redistribute it and/or modify
5 -- This program is free software; you can redistribute it and/or modify
6 -- it under the terms of the GNU General Public License as published by
6 -- it under the terms of the GNU General Public License as published by
7 -- the Free Software Foundation; either version 2 of the License, or
7 -- the Free Software Foundation; either version 2 of the License, or
8 -- (at your option) any later version.
8 -- (at your option) any later version.
9 --
9 --
10 -- This program is distributed in the hope that it will be useful,
10 -- This program is distributed in the hope that it will be useful,
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 -- GNU General Public License for more details.
13 -- GNU General Public License for more details.
14 --
14 --
15 -- You should have received a copy of the GNU General Public License
15 -- You should have received a copy of the GNU General Public License
16 -- along with this program; if not, write to the Free Software
16 -- along with this program; if not, write to the Free Software
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 -------------------------------------------------------------------------------*/
18 -------------------------------------------------------------------------------*/
19 /*-- Author : Alexis Jeandet
19 /*-- Author : Alexis Jeandet
20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
21 ----------------------------------------------------------------------------*/
21 ----------------------------------------------------------------------------*/
22 #ifndef SOCEXPLORERENGINE_H
22 #ifndef SOCEXPLORERENGINE_H
23 #define SOCEXPLORERENGINE_H
23 #define SOCEXPLORERENGINE_H
24
24
25 #include <stdint.h>
25 #include <stdint.h>
26 #include <QObject>
26 #include <QObject>
27 #include <QtWidgets>
27 #include <QtWidgets>
28 #include <QStringList>
28 #include <QStringList>
29 #include <QDomDocument>
29 #include <QDomDocument>
30 #include <QDomElement>
30 #include <QDomElement>
31 #include <QDomNodeList>
31 #include <QDomNodeList>
32 #include <QFile>
32 #include <QFile>
33 #include <QTextStream>
33 #include <QTextStream>
34 #include <QDir>
34 #include <QDir>
35 #include <QApplication>
35 #include <QApplication>
36 #include <QtCore/qglobal.h>
36 #include <QtCore/qglobal.h>
37 #include <QFileDialog>
37 #include <QFileDialog>
38 #include <socexplorerxmlfile.h>
38 #include <socexplorerxmlfile.h>
39 #include <socexplorerenumdevice.h>
39 #include <socexplorerenumdevice.h>
40 #include <XMLmodel.h>
40 #include <XMLmodel.h>
41 #include <peripheralwidget.h>
41 #include <peripheralwidget.h>
42 #include <registerwidget.h>
42 #include <registerwidget.h>
43 #include <socmodel.h>
43 #include <socmodel.h>
44 #include <memtester.h>
44 #include <memtester.h>
45 #include <QSettings>
45
46
46 #if defined(SOCEXPLORER_SDK_BUILD)
47 #if defined(SOCEXPLORER_SDK_BUILD)
47 # define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
48 # define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
48 #else
49 #else
49 # define SOCEXPLORER_SDK_EXPORT Q_DECL_IMPORT
50 # define SOCEXPLORER_SDK_EXPORT Q_DECL_IMPORT
50 #endif
51 #endif
51
52
52
53
53 class SOCEXPLORER_SDK_EXPORT SocExplorerAutoProgressBar
54 class SOCEXPLORER_SDK_EXPORT SocExplorerAutoProgressBar
54 {
55 {
55 public:
56 public:
56 SocExplorerAutoProgressBar(QProgressBar* progressBar=NULL)
57 SocExplorerAutoProgressBar(QProgressBar* progressBar=NULL)
57 {
58 {
58 this->p_progressbar=progressBar;
59 this->p_progressbar=progressBar;
59 }
60 }
60 ~SocExplorerAutoProgressBar()
61 ~SocExplorerAutoProgressBar()
61 {
62 {
62 if(p_progressbar)
63 if(p_progressbar)
63 {
64 {
64 delete p_progressbar;
65 delete p_progressbar;
65 }
66 }
66 }
67 }
67 void setProgressBar(QProgressBar* progressBar)
68 void setProgressBar(QProgressBar* progressBar)
68 {
69 {
69 this->p_progressbar=progressBar;
70 this->p_progressbar=progressBar;
70 }
71 }
71 void setValue(int value)
72 void setValue(int value)
72 {
73 {
73 p_progressbar->setValue(value);
74 p_progressbar->setValue(value);
74 }
75 }
75 private:
76 private:
76 QProgressBar* p_progressbar;
77 QProgressBar* p_progressbar;
77 };
78 };
78
79
79 //! SocExplorerEngine is a pure static class which aims to provide services for both SocExplorer software and plugins.
80 //! SocExplorerEngine is a pure static class which aims to provide services for both SocExplorer software and plugins.
80
81
81 class SOCEXPLORER_SDK_EXPORT SocExplorerEngine : public QObject
82 class SOCEXPLORER_SDK_EXPORT SocExplorerEngine : public QObject
82 {
83 {
83 Q_OBJECT
84 Q_OBJECT
84 private:
85 private:
85 static SocExplorerEngine* _self;
86 static SocExplorerEngine* _self;
87 static QSettings* m_settings;
86 SocExplorerEngine(QObject *parent = 0);
88 SocExplorerEngine(QObject *parent = 0);
87 static void init();
89 static void init();
88
90
89 public:
91 public:
90 static SocExplorerEngine* self(){ if(!_self){_self= new SocExplorerEngine;}return _self;}
92 static SocExplorerEngine* self(){ if(!_self){_self= new SocExplorerEngine;}return _self;}
91 //! Return the configuration folder path, OS dependant.
93 //! Return the configuration folder path, OS dependant.
92 SOCEXPLORER_SDK_EXPORT static QString configFolder();
94 SOCEXPLORER_SDK_EXPORT static QString configFolder();
93 //! Return the default plugin folder path, OS dependant.
95 //! Return the default plugin folder path, OS dependant.
94 static QStringList pluginFolders();
96 static QStringList pluginFolders();
95 static QString configPath(){return QString(SOCEXPLORER_CONFIG_PATH);}
97 static QString configPath(){return QString(SOCEXPLORER_CONFIG_PATH);}
96 static QString sharePath(){return QString(SOCEXPLORER_SHARE_PATH);}
98 static QString sharePath(){return QString(SOCEXPLORER_SHARE_PATH);}
97 static int addEnumDevice(socexplorerplugin* rootPlugin,int VID,int PID,qint32 baseAddress,const QString& name);
99 static int addEnumDevice(socexplorerplugin* rootPlugin,int VID,int PID,qint32 baseAddress,const QString& name);
98 static QList<SOCModel*>* getSOCs();
100 static QList<SOCModel*>* getSOCs();
99 static QString getDevName(int VID, int PID);
101 static QString getDevName(int VID, int PID);
100 static QString SocExplorerVersion();
102 static QString SocExplorerVersion();
101 static QString SocExplorerChangeset();
103 static QString SocExplorerChangeset();
102 static QString SocExplorerBranch();
104 static QString SocExplorerBranch();
103 static socExplorerXmlModel* xmlModel();
105 static socExplorerXmlModel* xmlModel();
104 static void setMainWindow(QMainWindow* Mainwindow);
106 static void setMainWindow(QMainWindow* Mainwindow);
105 static QProgressBar* getProgressBar(const QString &format, int max);
107 static QProgressBar* getProgressBar(const QString &format, int max);
106 static void deleteProgressBar(QProgressBar* progressBar);
108 static void deleteProgressBar(QProgressBar* progressBar);
107 static void addSOC(socexplorerplugin* rootPlugin);
109 static void addSOC(socexplorerplugin* rootPlugin);
108 static void removeSOC(socexplorerplugin* rootPlugin);
110 static void removeSOC(socexplorerplugin* rootPlugin);
109 static void message(socexplorerplugin* sender,const QString& message,int debugLevel=0);
111 static void message(socexplorerplugin* sender,const QString& message,int debugLevel=0);
110 static void setLogLevel(int level);
112 static void setLogLevel(int level);
111 static bool isSocLitleEndian(socexplorerplugin* plugin);
113 static bool isSocLitleEndian(socexplorerplugin* plugin);
112 signals:
114 signals:
113 void enumDeviceAdded(socExplorerEnumDevice* device);
115 void enumDeviceAdded(socExplorerEnumDevice* device);
114 public slots:
116 public slots:
115 QString getSocExplorerVersion(){return SocExplorerEngine::SocExplorerVersion();}
117 QString getSocExplorerVersion(){return SocExplorerEngine::SocExplorerVersion();}
116 QString getSocExplorerChangeset(){return SocExplorerEngine::SocExplorerChangeset();}
118 QString getSocExplorerChangeset(){return SocExplorerEngine::SocExplorerChangeset();}
117 QString getSocExplorerBranch(){return SocExplorerEngine::SocExplorerBranch();}
119 QString getSocExplorerBranch(){return SocExplorerEngine::SocExplorerBranch();}
118 qint32 getEnumDeviceBaseAddress(const QString& rootPlugin,int VID,int PID,int count=0);
120 qint32 getEnumDeviceBaseAddress(const QString& rootPlugin,int VID,int PID,int count=0);
119 qint32 getEnumDeviceBaseAddress(socexplorerplugin* plugin,int VID,int PID,int count=0);
121 qint32 getEnumDeviceBaseAddress(socexplorerplugin* plugin,int VID,int PID,int count=0);
120 qint32 getEnumDeviceCount(socexplorerplugin* plugin,int VID,int PID);
122 qint32 getEnumDeviceCount(socexplorerplugin* plugin,int VID,int PID);
121 qint32 getEnumDeviceCount(const QString& rootPlugin,int VID,int PID);
123 qint32 getEnumDeviceCount(const QString& rootPlugin,int VID,int PID);
122 int addEnumDevice(const QString& rootPlugin,int VID,int PID,qint32 baseAddress,const QString& name);
124 int addEnumDevice(const QString& rootPlugin,int VID,int PID,qint32 baseAddress,const QString& name);
123 unsigned int memMeasureSize(socexplorerplugin* plugin, unsigned int address,unsigned int maxSize=0xFFFFFFFF);
125 unsigned int memMeasureSize(socexplorerplugin* plugin, unsigned int address,unsigned int maxSize=0xFFFFFFFF);
124 unsigned int memMeasureSize(const QString& plugin, unsigned int address,unsigned int maxSize=0xFFFFFFFF);
126 unsigned int memMeasureSize(const QString& plugin, unsigned int address,unsigned int maxSize=0xFFFFFFFF);
125
127
126 private:
128 private:
127 static SOCModel* plugin2Soc(socexplorerplugin* plugin);
129 static SOCModel* plugin2Soc(socexplorerplugin* plugin);
128 static socExplorerXmlModel* p_xmlmodel;
130 static socExplorerXmlModel* p_xmlmodel;
129 static QMainWindow* mainWindow;
131 static QMainWindow* mainWindow;
130 static QList<SOCModel*>* SOCs;
132 static QList<SOCModel*>* SOCs;
131 static int loglvl;
133 static int loglvl;
132 };
134 };
133
135
134 #endif // SOCEXPLORERENGINE_H
136 #endif // SOCEXPLORERENGINE_H
135
137
136
138
137
139
138
140
139
141
140
142
141
143
@@ -1,9498 +1,9503
1 #include "PySocExplorer0.h"
1 #include "PySocExplorer0.h"
2 #include <PythonQtConversion.h>
2 #include <PythonQtConversion.h>
3 #include <PythonQtMethodInfo.h>
3 #include <PythonQtMethodInfo.h>
4 #include <PythonQtSignalReceiver.h>
4 #include <PythonQtSignalReceiver.h>
5 #include <QVariant>
5 #include <QVariant>
6 #include <abstractbinfile.h>
6 #include <abstractbinfile.h>
7 #include <elfparser.h>
7 #include <elfparser.h>
8 #include <qaction.h>
8 #include <qaction.h>
9 #include <qbackingstore.h>
9 #include <qbackingstore.h>
10 #include <qbitmap.h>
10 #include <qbitmap.h>
11 #include <qbytearray.h>
11 #include <qbytearray.h>
12 #include <qcolor.h>
12 #include <qcolor.h>
13 #include <qcoreevent.h>
13 #include <qcoreevent.h>
14 #include <qcursor.h>
14 #include <qcursor.h>
15 #include <qevent.h>
15 #include <qevent.h>
16 #include <qfile.h>
16 #include <qfile.h>
17 #include <qfont.h>
17 #include <qfont.h>
18 #include <qgraphicseffect.h>
18 #include <qgraphicseffect.h>
19 #include <qgraphicsproxywidget.h>
19 #include <qgraphicsproxywidget.h>
20 #include <qicon.h>
20 #include <qicon.h>
21 #include <qkeysequence.h>
21 #include <qkeysequence.h>
22 #include <qlayout.h>
22 #include <qlayout.h>
23 #include <qlineedit.h>
23 #include <qlineedit.h>
24 #include <qlist.h>
24 #include <qlist.h>
25 #include <qlocale.h>
25 #include <qlocale.h>
26 #include <qmargins.h>
26 #include <qmargins.h>
27 #include <qmetaobject.h>
27 #include <qmetaobject.h>
28 #include <qobject.h>
28 #include <qobject.h>
29 #include <qpaintdevice.h>
29 #include <qpaintdevice.h>
30 #include <qpaintengine.h>
30 #include <qpaintengine.h>
31 #include <qpainter.h>
31 #include <qpainter.h>
32 #include <qpalette.h>
32 #include <qpalette.h>
33 #include <qpen.h>
33 #include <qpen.h>
34 #include <qpixmap.h>
34 #include <qpixmap.h>
35 #include <qpoint.h>
35 #include <qpoint.h>
36 #include <qrect.h>
36 #include <qrect.h>
37 #include <qregion.h>
37 #include <qregion.h>
38 #include <qscrollarea.h>
38 #include <qscrollarea.h>
39 #include <qscrollbar.h>
39 #include <qscrollbar.h>
40 #include <qsize.h>
40 #include <qsize.h>
41 #include <qsizepolicy.h>
41 #include <qsizepolicy.h>
42 #include <qspinbox.h>
42 #include <qspinbox.h>
43 #include <qstringlist.h>
43 #include <qstringlist.h>
44 #include <qstyle.h>
44 #include <qstyle.h>
45 #include <qstyleoption.h>
45 #include <qstyleoption.h>
46 #include <qwidget.h>
46 #include <qwidget.h>
47 #include <qwindow.h>
47 #include <qwindow.h>
48
48
49 PythonQtShell_ElfFile::~PythonQtShell_ElfFile() {
49 PythonQtShell_ElfFile::~PythonQtShell_ElfFile() {
50 PythonQtPrivate* priv = PythonQt::priv();
50 PythonQtPrivate* priv = PythonQt::priv();
51 if (priv) { priv->shellClassDeleted(this); }
51 if (priv) { priv->shellClassDeleted(this); }
52 }
52 }
53 int PythonQtShell_ElfFile::closeFile()
53 int PythonQtShell_ElfFile::closeFile()
54 {
54 {
55 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
55 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
56 static PyObject* name = PyString_FromString("closeFile");
56 static PyObject* name = PyString_FromString("closeFile");
57 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
57 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
58 if (obj) {
58 if (obj) {
59 static const char* argumentList[] ={"int"};
59 static const char* argumentList[] ={"int"};
60 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
60 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
61 int returnValue;
61 int returnValue;
62 void* args[1] = {NULL};
62 void* args[1] = {NULL};
63 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
63 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
64 if (result) {
64 if (result) {
65 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
65 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
66 if (args[0]!=&returnValue) {
66 if (args[0]!=&returnValue) {
67 if (args[0]==NULL) {
67 if (args[0]==NULL) {
68 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
68 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
69 } else {
69 } else {
70 returnValue = *((int*)args[0]);
70 returnValue = *((int*)args[0]);
71 }
71 }
72 }
72 }
73 }
73 }
74 if (result) { Py_DECREF(result); }
74 if (result) { Py_DECREF(result); }
75 Py_DECREF(obj);
75 Py_DECREF(obj);
76 return returnValue;
76 return returnValue;
77 } else {
77 } else {
78 PyErr_Clear();
78 PyErr_Clear();
79 }
79 }
80 }
80 }
81 return ElfFile::closeFile();
81 return ElfFile::closeFile();
82 }
82 }
83 QList<codeFragment* > PythonQtShell_ElfFile::getFragments()
83 QList<codeFragment* > PythonQtShell_ElfFile::getFragments()
84 {
84 {
85 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
85 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
86 static PyObject* name = PyString_FromString("getFragments");
86 static PyObject* name = PyString_FromString("getFragments");
87 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
87 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
88 if (obj) {
88 if (obj) {
89 static const char* argumentList[] ={"QList<codeFragment* >"};
89 static const char* argumentList[] ={"QList<codeFragment* >"};
90 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
90 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
91 QList<codeFragment* > returnValue;
91 QList<codeFragment* > returnValue;
92 void* args[1] = {NULL};
92 void* args[1] = {NULL};
93 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
93 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
94 if (result) {
94 if (result) {
95 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
95 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
96 if (args[0]!=&returnValue) {
96 if (args[0]!=&returnValue) {
97 if (args[0]==NULL) {
97 if (args[0]==NULL) {
98 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
98 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
99 } else {
99 } else {
100 returnValue = *((QList<codeFragment* >*)args[0]);
100 returnValue = *((QList<codeFragment* >*)args[0]);
101 }
101 }
102 }
102 }
103 }
103 }
104 if (result) { Py_DECREF(result); }
104 if (result) { Py_DECREF(result); }
105 Py_DECREF(obj);
105 Py_DECREF(obj);
106 return returnValue;
106 return returnValue;
107 } else {
107 } else {
108 PyErr_Clear();
108 PyErr_Clear();
109 }
109 }
110 }
110 }
111 return ElfFile::getFragments();
111 return ElfFile::getFragments();
112 }
112 }
113 bool PythonQtShell_ElfFile::isopened()
113 bool PythonQtShell_ElfFile::isopened()
114 {
114 {
115 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
115 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
116 static PyObject* name = PyString_FromString("isopened");
116 static PyObject* name = PyString_FromString("isopened");
117 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
117 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
118 if (obj) {
118 if (obj) {
119 static const char* argumentList[] ={"bool"};
119 static const char* argumentList[] ={"bool"};
120 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
120 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
121 bool returnValue;
121 bool returnValue;
122 void* args[1] = {NULL};
122 void* args[1] = {NULL};
123 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
123 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
124 if (result) {
124 if (result) {
125 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
125 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
126 if (args[0]!=&returnValue) {
126 if (args[0]!=&returnValue) {
127 if (args[0]==NULL) {
127 if (args[0]==NULL) {
128 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
128 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
129 } else {
129 } else {
130 returnValue = *((bool*)args[0]);
130 returnValue = *((bool*)args[0]);
131 }
131 }
132 }
132 }
133 }
133 }
134 if (result) { Py_DECREF(result); }
134 if (result) { Py_DECREF(result); }
135 Py_DECREF(obj);
135 Py_DECREF(obj);
136 return returnValue;
136 return returnValue;
137 } else {
137 } else {
138 PyErr_Clear();
138 PyErr_Clear();
139 }
139 }
140 }
140 }
141 return ElfFile::isopened();
141 return ElfFile::isopened();
142 }
142 }
143 bool PythonQtShell_ElfFile::openFile(const QString& File0)
143 bool PythonQtShell_ElfFile::openFile(const QString& File0)
144 {
144 {
145 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
145 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
146 static PyObject* name = PyString_FromString("openFile");
146 static PyObject* name = PyString_FromString("openFile");
147 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
147 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
148 if (obj) {
148 if (obj) {
149 static const char* argumentList[] ={"bool" , "const QString&"};
149 static const char* argumentList[] ={"bool" , "const QString&"};
150 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
150 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
151 bool returnValue;
151 bool returnValue;
152 void* args[2] = {NULL, (void*)&File0};
152 void* args[2] = {NULL, (void*)&File0};
153 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
153 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
154 if (result) {
154 if (result) {
155 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
155 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
156 if (args[0]!=&returnValue) {
156 if (args[0]!=&returnValue) {
157 if (args[0]==NULL) {
157 if (args[0]==NULL) {
158 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
158 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
159 } else {
159 } else {
160 returnValue = *((bool*)args[0]);
160 returnValue = *((bool*)args[0]);
161 }
161 }
162 }
162 }
163 }
163 }
164 if (result) { Py_DECREF(result); }
164 if (result) { Py_DECREF(result); }
165 Py_DECREF(obj);
165 Py_DECREF(obj);
166 return returnValue;
166 return returnValue;
167 } else {
167 } else {
168 PyErr_Clear();
168 PyErr_Clear();
169 }
169 }
170 }
170 }
171 return ElfFile::openFile(File0);
171 return ElfFile::openFile(File0);
172 }
172 }
173 bool PythonQtShell_ElfFile::toBinary(const QString& File0)
173 bool PythonQtShell_ElfFile::toBinary(const QString& File0)
174 {
174 {
175 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
175 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
176 static PyObject* name = PyString_FromString("toBinary");
176 static PyObject* name = PyString_FromString("toBinary");
177 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
177 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
178 if (obj) {
178 if (obj) {
179 static const char* argumentList[] ={"bool" , "const QString&"};
179 static const char* argumentList[] ={"bool" , "const QString&"};
180 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
180 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
181 bool returnValue;
181 bool returnValue;
182 void* args[2] = {NULL, (void*)&File0};
182 void* args[2] = {NULL, (void*)&File0};
183 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
183 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
184 if (result) {
184 if (result) {
185 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
185 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
186 if (args[0]!=&returnValue) {
186 if (args[0]!=&returnValue) {
187 if (args[0]==NULL) {
187 if (args[0]==NULL) {
188 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
188 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
189 } else {
189 } else {
190 returnValue = *((bool*)args[0]);
190 returnValue = *((bool*)args[0]);
191 }
191 }
192 }
192 }
193 }
193 }
194 if (result) { Py_DECREF(result); }
194 if (result) { Py_DECREF(result); }
195 Py_DECREF(obj);
195 Py_DECREF(obj);
196 return returnValue;
196 return returnValue;
197 } else {
197 } else {
198 PyErr_Clear();
198 PyErr_Clear();
199 }
199 }
200 }
200 }
201 return ElfFile::toBinary(File0);
201 return ElfFile::toBinary(File0);
202 }
202 }
203 bool PythonQtShell_ElfFile::toSrec(const QString& File0)
203 bool PythonQtShell_ElfFile::toSrec(const QString& File0)
204 {
204 {
205 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
205 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
206 static PyObject* name = PyString_FromString("toSrec");
206 static PyObject* name = PyString_FromString("toSrec");
207 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
207 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
208 if (obj) {
208 if (obj) {
209 static const char* argumentList[] ={"bool" , "const QString&"};
209 static const char* argumentList[] ={"bool" , "const QString&"};
210 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
210 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
211 bool returnValue;
211 bool returnValue;
212 void* args[2] = {NULL, (void*)&File0};
212 void* args[2] = {NULL, (void*)&File0};
213 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
213 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
214 if (result) {
214 if (result) {
215 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
215 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
216 if (args[0]!=&returnValue) {
216 if (args[0]!=&returnValue) {
217 if (args[0]==NULL) {
217 if (args[0]==NULL) {
218 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
218 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
219 } else {
219 } else {
220 returnValue = *((bool*)args[0]);
220 returnValue = *((bool*)args[0]);
221 }
221 }
222 }
222 }
223 }
223 }
224 if (result) { Py_DECREF(result); }
224 if (result) { Py_DECREF(result); }
225 Py_DECREF(obj);
225 Py_DECREF(obj);
226 return returnValue;
226 return returnValue;
227 } else {
227 } else {
228 PyErr_Clear();
228 PyErr_Clear();
229 }
229 }
230 }
230 }
231 return ElfFile::toSrec(File0);
231 return ElfFile::toSrec(File0);
232 }
232 }
233 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile()
233 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile()
234 {
234 {
235 return new PythonQtShell_ElfFile(); }
235 return new PythonQtShell_ElfFile(); }
236
236
237 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile(const QString& File)
237 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile(const QString& File)
238 {
238 {
239 return new PythonQtShell_ElfFile(File); }
239 return new PythonQtShell_ElfFile(File); }
240
240
241 int PythonQtWrapper_ElfFile::closeFile(ElfFile* theWrappedObject)
241 int PythonQtWrapper_ElfFile::closeFile(ElfFile* theWrappedObject)
242 {
242 {
243 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_closeFile());
243 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_closeFile());
244 }
244 }
245
245
246 QString PythonQtWrapper_ElfFile::getABI(ElfFile* theWrappedObject)
246 QString PythonQtWrapper_ElfFile::getABI(ElfFile* theWrappedObject)
247 {
247 {
248 return ( theWrappedObject->getABI());
248 return ( theWrappedObject->getABI());
249 }
249 }
250
250
251 QString PythonQtWrapper_ElfFile::getArchitecture(ElfFile* theWrappedObject)
251 QString PythonQtWrapper_ElfFile::getArchitecture(ElfFile* theWrappedObject)
252 {
252 {
253 return ( theWrappedObject->getArchitecture());
253 return ( theWrappedObject->getArchitecture());
254 }
254 }
255
255
256 QString PythonQtWrapper_ElfFile::getClass(ElfFile* theWrappedObject)
256 QString PythonQtWrapper_ElfFile::getClass(ElfFile* theWrappedObject)
257 {
257 {
258 return ( theWrappedObject->getClass());
258 return ( theWrappedObject->getClass());
259 }
259 }
260
260
261 QString PythonQtWrapper_ElfFile::getEndianness(ElfFile* theWrappedObject)
261 QString PythonQtWrapper_ElfFile::getEndianness(ElfFile* theWrappedObject)
262 {
262 {
263 return ( theWrappedObject->getEndianness());
263 return ( theWrappedObject->getEndianness());
264 }
264 }
265
265
266 qint64 PythonQtWrapper_ElfFile::getEntryPointAddress(ElfFile* theWrappedObject)
266 qint64 PythonQtWrapper_ElfFile::getEntryPointAddress(ElfFile* theWrappedObject)
267 {
267 {
268 return ( theWrappedObject->getEntryPointAddress());
268 return ( theWrappedObject->getEntryPointAddress());
269 }
269 }
270
270
271 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject)
271 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject)
272 {
272 {
273 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_getFragments());
273 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_getFragments());
274 }
274 }
275
275
276 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject, QStringList fragmentList)
276 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject, QStringList fragmentList)
277 {
277 {
278 return ( theWrappedObject->getFragments(fragmentList));
278 return ( theWrappedObject->getFragments(fragmentList));
279 }
279 }
280
280
281 int PythonQtWrapper_ElfFile::getSectionCount(ElfFile* theWrappedObject)
281 int PythonQtWrapper_ElfFile::getSectionCount(ElfFile* theWrappedObject)
282 {
282 {
283 return ( theWrappedObject->getSectionCount());
283 return ( theWrappedObject->getSectionCount());
284 }
284 }
285
285
286 bool PythonQtWrapper_ElfFile::getSectionData(ElfFile* theWrappedObject, int index, char** buffer)
286 bool PythonQtWrapper_ElfFile::getSectionData(ElfFile* theWrappedObject, int index, char** buffer)
287 {
287 {
288 return ( theWrappedObject->getSectionData(index, buffer));
288 return ( theWrappedObject->getSectionData(index, buffer));
289 }
289 }
290
290
291 qint64 PythonQtWrapper_ElfFile::getSectionDatasz(ElfFile* theWrappedObject, int index)
291 qint64 PythonQtWrapper_ElfFile::getSectionDatasz(ElfFile* theWrappedObject, int index)
292 {
292 {
293 return ( theWrappedObject->getSectionDatasz(index));
293 return ( theWrappedObject->getSectionDatasz(index));
294 }
294 }
295
295
296 int PythonQtWrapper_ElfFile::getSectionIndex(ElfFile* theWrappedObject, QString name)
296 int PythonQtWrapper_ElfFile::getSectionIndex(ElfFile* theWrappedObject, QString name)
297 {
297 {
298 return ( theWrappedObject->getSectionIndex(name));
298 return ( theWrappedObject->getSectionIndex(name));
299 }
299 }
300
300
301 qint64 PythonQtWrapper_ElfFile::getSectionMemsz(ElfFile* theWrappedObject, int index)
301 qint64 PythonQtWrapper_ElfFile::getSectionMemsz(ElfFile* theWrappedObject, int index)
302 {
302 {
303 return ( theWrappedObject->getSectionMemsz(index));
303 return ( theWrappedObject->getSectionMemsz(index));
304 }
304 }
305
305
306 QString PythonQtWrapper_ElfFile::getSectionName(ElfFile* theWrappedObject, int index)
306 QString PythonQtWrapper_ElfFile::getSectionName(ElfFile* theWrappedObject, int index)
307 {
307 {
308 return ( theWrappedObject->getSectionName(index));
308 return ( theWrappedObject->getSectionName(index));
309 }
309 }
310
310
311 qint64 PythonQtWrapper_ElfFile::getSectionPaddr(ElfFile* theWrappedObject, int index)
311 qint64 PythonQtWrapper_ElfFile::getSectionPaddr(ElfFile* theWrappedObject, int index)
312 {
312 {
313 return ( theWrappedObject->getSectionPaddr(index));
313 return ( theWrappedObject->getSectionPaddr(index));
314 }
314 }
315
315
316 QString PythonQtWrapper_ElfFile::getSectionType(ElfFile* theWrappedObject, int index)
316 QString PythonQtWrapper_ElfFile::getSectionType(ElfFile* theWrappedObject, int index)
317 {
317 {
318 return ( theWrappedObject->getSectionType(index));
318 return ( theWrappedObject->getSectionType(index));
319 }
319 }
320
320
321 int PythonQtWrapper_ElfFile::getSegmentCount(ElfFile* theWrappedObject)
321 int PythonQtWrapper_ElfFile::getSegmentCount(ElfFile* theWrappedObject)
322 {
322 {
323 return ( theWrappedObject->getSegmentCount());
323 return ( theWrappedObject->getSegmentCount());
324 }
324 }
325
325
326 qint64 PythonQtWrapper_ElfFile::getSegmentFilesz(ElfFile* theWrappedObject, int index)
326 qint64 PythonQtWrapper_ElfFile::getSegmentFilesz(ElfFile* theWrappedObject, int index)
327 {
327 {
328 return ( theWrappedObject->getSegmentFilesz(index));
328 return ( theWrappedObject->getSegmentFilesz(index));
329 }
329 }
330
330
331 QString PythonQtWrapper_ElfFile::getSegmentFlags(ElfFile* theWrappedObject, int index)
331 QString PythonQtWrapper_ElfFile::getSegmentFlags(ElfFile* theWrappedObject, int index)
332 {
332 {
333 return ( theWrappedObject->getSegmentFlags(index));
333 return ( theWrappedObject->getSegmentFlags(index));
334 }
334 }
335
335
336 qint64 PythonQtWrapper_ElfFile::getSegmentMemsz(ElfFile* theWrappedObject, int index)
336 qint64 PythonQtWrapper_ElfFile::getSegmentMemsz(ElfFile* theWrappedObject, int index)
337 {
337 {
338 return ( theWrappedObject->getSegmentMemsz(index));
338 return ( theWrappedObject->getSegmentMemsz(index));
339 }
339 }
340
340
341 qint64 PythonQtWrapper_ElfFile::getSegmentOffset(ElfFile* theWrappedObject, int index)
341 qint64 PythonQtWrapper_ElfFile::getSegmentOffset(ElfFile* theWrappedObject, int index)
342 {
342 {
343 return ( theWrappedObject->getSegmentOffset(index));
343 return ( theWrappedObject->getSegmentOffset(index));
344 }
344 }
345
345
346 qint64 PythonQtWrapper_ElfFile::getSegmentPaddr(ElfFile* theWrappedObject, int index)
346 qint64 PythonQtWrapper_ElfFile::getSegmentPaddr(ElfFile* theWrappedObject, int index)
347 {
347 {
348 return ( theWrappedObject->getSegmentPaddr(index));
348 return ( theWrappedObject->getSegmentPaddr(index));
349 }
349 }
350
350
351 QString PythonQtWrapper_ElfFile::getSegmentType(ElfFile* theWrappedObject, int index)
351 QString PythonQtWrapper_ElfFile::getSegmentType(ElfFile* theWrappedObject, int index)
352 {
352 {
353 return ( theWrappedObject->getSegmentType(index));
353 return ( theWrappedObject->getSegmentType(index));
354 }
354 }
355
355
356 qint64 PythonQtWrapper_ElfFile::getSegmentVaddr(ElfFile* theWrappedObject, int index)
356 qint64 PythonQtWrapper_ElfFile::getSegmentVaddr(ElfFile* theWrappedObject, int index)
357 {
357 {
358 return ( theWrappedObject->getSegmentVaddr(index));
358 return ( theWrappedObject->getSegmentVaddr(index));
359 }
359 }
360
360
361 quint64 PythonQtWrapper_ElfFile::getSymbolAddress(ElfFile* theWrappedObject, int index)
361 quint64 PythonQtWrapper_ElfFile::getSymbolAddress(ElfFile* theWrappedObject, int index)
362 {
362 {
363 return ( theWrappedObject->getSymbolAddress(index));
363 return ( theWrappedObject->getSymbolAddress(index));
364 }
364 }
365
365
366 int PythonQtWrapper_ElfFile::getSymbolCount(ElfFile* theWrappedObject)
366 int PythonQtWrapper_ElfFile::getSymbolCount(ElfFile* theWrappedObject)
367 {
367 {
368 return ( theWrappedObject->getSymbolCount());
368 return ( theWrappedObject->getSymbolCount());
369 }
369 }
370
370
371 int PythonQtWrapper_ElfFile::getSymbolIndex(ElfFile* theWrappedObject, const QString& name)
372 {
373 return ( theWrappedObject->getSymbolIndex(name));
374 }
375
371 QString PythonQtWrapper_ElfFile::getSymbolLinkType(ElfFile* theWrappedObject, int index)
376 QString PythonQtWrapper_ElfFile::getSymbolLinkType(ElfFile* theWrappedObject, int index)
372 {
377 {
373 return ( theWrappedObject->getSymbolLinkType(index));
378 return ( theWrappedObject->getSymbolLinkType(index));
374 }
379 }
375
380
376 QString PythonQtWrapper_ElfFile::getSymbolName(ElfFile* theWrappedObject, int index)
381 QString PythonQtWrapper_ElfFile::getSymbolName(ElfFile* theWrappedObject, int index)
377 {
382 {
378 return ( theWrappedObject->getSymbolName(index));
383 return ( theWrappedObject->getSymbolName(index));
379 }
384 }
380
385
381 int PythonQtWrapper_ElfFile::getSymbolSectionIndex(ElfFile* theWrappedObject, int index)
386 int PythonQtWrapper_ElfFile::getSymbolSectionIndex(ElfFile* theWrappedObject, int index)
382 {
387 {
383 return ( theWrappedObject->getSymbolSectionIndex(index));
388 return ( theWrappedObject->getSymbolSectionIndex(index));
384 }
389 }
385
390
386 QString PythonQtWrapper_ElfFile::getSymbolSectionName(ElfFile* theWrappedObject, int index)
391 QString PythonQtWrapper_ElfFile::getSymbolSectionName(ElfFile* theWrappedObject, int index)
387 {
392 {
388 return ( theWrappedObject->getSymbolSectionName(index));
393 return ( theWrappedObject->getSymbolSectionName(index));
389 }
394 }
390
395
391 quint64 PythonQtWrapper_ElfFile::getSymbolSize(ElfFile* theWrappedObject, int index)
396 quint64 PythonQtWrapper_ElfFile::getSymbolSize(ElfFile* theWrappedObject, int index)
392 {
397 {
393 return ( theWrappedObject->getSymbolSize(index));
398 return ( theWrappedObject->getSymbolSize(index));
394 }
399 }
395
400
396 QString PythonQtWrapper_ElfFile::getSymbolType(ElfFile* theWrappedObject, int index)
401 QString PythonQtWrapper_ElfFile::getSymbolType(ElfFile* theWrappedObject, int index)
397 {
402 {
398 return ( theWrappedObject->getSymbolType(index));
403 return ( theWrappedObject->getSymbolType(index));
399 }
404 }
400
405
401 QString PythonQtWrapper_ElfFile::getType(ElfFile* theWrappedObject)
406 QString PythonQtWrapper_ElfFile::getType(ElfFile* theWrappedObject)
402 {
407 {
403 return ( theWrappedObject->getType());
408 return ( theWrappedObject->getType());
404 }
409 }
405
410
406 qint64 PythonQtWrapper_ElfFile::getVersion(ElfFile* theWrappedObject)
411 qint64 PythonQtWrapper_ElfFile::getVersion(ElfFile* theWrappedObject)
407 {
412 {
408 return ( theWrappedObject->getVersion());
413 return ( theWrappedObject->getVersion());
409 }
414 }
410
415
411 bool PythonQtWrapper_ElfFile::isBigEndian(ElfFile* theWrappedObject)
416 bool PythonQtWrapper_ElfFile::isBigEndian(ElfFile* theWrappedObject)
412 {
417 {
413 return ( theWrappedObject->isBigEndian());
418 return ( theWrappedObject->isBigEndian());
414 }
419 }
415
420
416 bool PythonQtWrapper_ElfFile::static_ElfFile_isElf(const QString& File)
421 bool PythonQtWrapper_ElfFile::static_ElfFile_isElf(const QString& File)
417 {
422 {
418 return (ElfFile::isElf(File));
423 return (ElfFile::isElf(File));
419 }
424 }
420
425
421 bool PythonQtWrapper_ElfFile::isLitleEndian(ElfFile* theWrappedObject)
426 bool PythonQtWrapper_ElfFile::isLitleEndian(ElfFile* theWrappedObject)
422 {
427 {
423 return ( theWrappedObject->isLitleEndian());
428 return ( theWrappedObject->isLitleEndian());
424 }
429 }
425
430
426 bool PythonQtWrapper_ElfFile::iself(ElfFile* theWrappedObject)
431 bool PythonQtWrapper_ElfFile::iself(ElfFile* theWrappedObject)
427 {
432 {
428 return ( theWrappedObject->iself());
433 return ( theWrappedObject->iself());
429 }
434 }
430
435
431 bool PythonQtWrapper_ElfFile::isopened(ElfFile* theWrappedObject)
436 bool PythonQtWrapper_ElfFile::isopened(ElfFile* theWrappedObject)
432 {
437 {
433 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_isopened());
438 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_isopened());
434 }
439 }
435
440
436 bool PythonQtWrapper_ElfFile::openFile(ElfFile* theWrappedObject, const QString& File)
441 bool PythonQtWrapper_ElfFile::openFile(ElfFile* theWrappedObject, const QString& File)
437 {
442 {
438 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_openFile(File));
443 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_openFile(File));
439 }
444 }
440
445
441 bool PythonQtWrapper_ElfFile::sectionIsNobits(ElfFile* theWrappedObject, int index)
446 bool PythonQtWrapper_ElfFile::sectionIsNobits(ElfFile* theWrappedObject, int index)
442 {
447 {
443 return ( theWrappedObject->sectionIsNobits(index));
448 return ( theWrappedObject->sectionIsNobits(index));
444 }
449 }
445
450
446 bool PythonQtWrapper_ElfFile::toBinary(ElfFile* theWrappedObject, const QString& File)
451 bool PythonQtWrapper_ElfFile::toBinary(ElfFile* theWrappedObject, const QString& File)
447 {
452 {
448 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_toBinary(File));
453 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_toBinary(File));
449 }
454 }
450
455
451 bool PythonQtWrapper_ElfFile::toSrec(ElfFile* theWrappedObject, const QString& File)
456 bool PythonQtWrapper_ElfFile::toSrec(ElfFile* theWrappedObject, const QString& File)
452 {
457 {
453 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_toSrec(File));
458 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_toSrec(File));
454 }
459 }
455
460
456
461
457
462
458 PythonQtShell_MemSizeWdgt::~PythonQtShell_MemSizeWdgt() {
463 PythonQtShell_MemSizeWdgt::~PythonQtShell_MemSizeWdgt() {
459 PythonQtPrivate* priv = PythonQt::priv();
464 PythonQtPrivate* priv = PythonQt::priv();
460 if (priv) { priv->shellClassDeleted(this); }
465 if (priv) { priv->shellClassDeleted(this); }
461 }
466 }
462 void PythonQtShell_MemSizeWdgt::actionEvent(QActionEvent* arg__1)
467 void PythonQtShell_MemSizeWdgt::actionEvent(QActionEvent* arg__1)
463 {
468 {
464 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
469 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
465 static PyObject* name = PyString_FromString("actionEvent");
470 static PyObject* name = PyString_FromString("actionEvent");
466 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
471 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
467 if (obj) {
472 if (obj) {
468 static const char* argumentList[] ={"" , "QActionEvent*"};
473 static const char* argumentList[] ={"" , "QActionEvent*"};
469 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
474 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
470 void* args[2] = {NULL, (void*)&arg__1};
475 void* args[2] = {NULL, (void*)&arg__1};
471 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
476 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
472 if (result) { Py_DECREF(result); }
477 if (result) { Py_DECREF(result); }
473 Py_DECREF(obj);
478 Py_DECREF(obj);
474 return;
479 return;
475 } else {
480 } else {
476 PyErr_Clear();
481 PyErr_Clear();
477 }
482 }
478 }
483 }
479 MemSizeWdgt::actionEvent(arg__1);
484 MemSizeWdgt::actionEvent(arg__1);
480 }
485 }
481 void PythonQtShell_MemSizeWdgt::changeEvent(QEvent* arg__1)
486 void PythonQtShell_MemSizeWdgt::changeEvent(QEvent* arg__1)
482 {
487 {
483 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
488 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
484 static PyObject* name = PyString_FromString("changeEvent");
489 static PyObject* name = PyString_FromString("changeEvent");
485 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
490 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
486 if (obj) {
491 if (obj) {
487 static const char* argumentList[] ={"" , "QEvent*"};
492 static const char* argumentList[] ={"" , "QEvent*"};
488 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
493 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
489 void* args[2] = {NULL, (void*)&arg__1};
494 void* args[2] = {NULL, (void*)&arg__1};
490 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
495 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
491 if (result) { Py_DECREF(result); }
496 if (result) { Py_DECREF(result); }
492 Py_DECREF(obj);
497 Py_DECREF(obj);
493 return;
498 return;
494 } else {
499 } else {
495 PyErr_Clear();
500 PyErr_Clear();
496 }
501 }
497 }
502 }
498 MemSizeWdgt::changeEvent(arg__1);
503 MemSizeWdgt::changeEvent(arg__1);
499 }
504 }
500 void PythonQtShell_MemSizeWdgt::childEvent(QChildEvent* arg__1)
505 void PythonQtShell_MemSizeWdgt::childEvent(QChildEvent* arg__1)
501 {
506 {
502 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
507 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
503 static PyObject* name = PyString_FromString("childEvent");
508 static PyObject* name = PyString_FromString("childEvent");
504 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
509 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
505 if (obj) {
510 if (obj) {
506 static const char* argumentList[] ={"" , "QChildEvent*"};
511 static const char* argumentList[] ={"" , "QChildEvent*"};
507 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
512 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
508 void* args[2] = {NULL, (void*)&arg__1};
513 void* args[2] = {NULL, (void*)&arg__1};
509 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
514 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
510 if (result) { Py_DECREF(result); }
515 if (result) { Py_DECREF(result); }
511 Py_DECREF(obj);
516 Py_DECREF(obj);
512 return;
517 return;
513 } else {
518 } else {
514 PyErr_Clear();
519 PyErr_Clear();
515 }
520 }
516 }
521 }
517 MemSizeWdgt::childEvent(arg__1);
522 MemSizeWdgt::childEvent(arg__1);
518 }
523 }
519 void PythonQtShell_MemSizeWdgt::closeEvent(QCloseEvent* arg__1)
524 void PythonQtShell_MemSizeWdgt::closeEvent(QCloseEvent* arg__1)
520 {
525 {
521 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
526 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
522 static PyObject* name = PyString_FromString("closeEvent");
527 static PyObject* name = PyString_FromString("closeEvent");
523 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
528 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
524 if (obj) {
529 if (obj) {
525 static const char* argumentList[] ={"" , "QCloseEvent*"};
530 static const char* argumentList[] ={"" , "QCloseEvent*"};
526 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
531 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
527 void* args[2] = {NULL, (void*)&arg__1};
532 void* args[2] = {NULL, (void*)&arg__1};
528 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
533 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
529 if (result) { Py_DECREF(result); }
534 if (result) { Py_DECREF(result); }
530 Py_DECREF(obj);
535 Py_DECREF(obj);
531 return;
536 return;
532 } else {
537 } else {
533 PyErr_Clear();
538 PyErr_Clear();
534 }
539 }
535 }
540 }
536 MemSizeWdgt::closeEvent(arg__1);
541 MemSizeWdgt::closeEvent(arg__1);
537 }
542 }
538 void PythonQtShell_MemSizeWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
543 void PythonQtShell_MemSizeWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
539 {
544 {
540 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
545 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
541 static PyObject* name = PyString_FromString("contextMenuEvent");
546 static PyObject* name = PyString_FromString("contextMenuEvent");
542 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
547 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
543 if (obj) {
548 if (obj) {
544 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
549 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
545 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
550 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
546 void* args[2] = {NULL, (void*)&arg__1};
551 void* args[2] = {NULL, (void*)&arg__1};
547 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
552 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
548 if (result) { Py_DECREF(result); }
553 if (result) { Py_DECREF(result); }
549 Py_DECREF(obj);
554 Py_DECREF(obj);
550 return;
555 return;
551 } else {
556 } else {
552 PyErr_Clear();
557 PyErr_Clear();
553 }
558 }
554 }
559 }
555 MemSizeWdgt::contextMenuEvent(arg__1);
560 MemSizeWdgt::contextMenuEvent(arg__1);
556 }
561 }
557 void PythonQtShell_MemSizeWdgt::customEvent(QEvent* arg__1)
562 void PythonQtShell_MemSizeWdgt::customEvent(QEvent* arg__1)
558 {
563 {
559 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
564 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
560 static PyObject* name = PyString_FromString("customEvent");
565 static PyObject* name = PyString_FromString("customEvent");
561 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
566 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
562 if (obj) {
567 if (obj) {
563 static const char* argumentList[] ={"" , "QEvent*"};
568 static const char* argumentList[] ={"" , "QEvent*"};
564 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
569 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
565 void* args[2] = {NULL, (void*)&arg__1};
570 void* args[2] = {NULL, (void*)&arg__1};
566 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
571 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
567 if (result) { Py_DECREF(result); }
572 if (result) { Py_DECREF(result); }
568 Py_DECREF(obj);
573 Py_DECREF(obj);
569 return;
574 return;
570 } else {
575 } else {
571 PyErr_Clear();
576 PyErr_Clear();
572 }
577 }
573 }
578 }
574 MemSizeWdgt::customEvent(arg__1);
579 MemSizeWdgt::customEvent(arg__1);
575 }
580 }
576 int PythonQtShell_MemSizeWdgt::devType() const
581 int PythonQtShell_MemSizeWdgt::devType() const
577 {
582 {
578 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
583 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
579 static PyObject* name = PyString_FromString("devType");
584 static PyObject* name = PyString_FromString("devType");
580 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
585 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
581 if (obj) {
586 if (obj) {
582 static const char* argumentList[] ={"int"};
587 static const char* argumentList[] ={"int"};
583 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
588 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
584 int returnValue;
589 int returnValue;
585 void* args[1] = {NULL};
590 void* args[1] = {NULL};
586 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
591 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
587 if (result) {
592 if (result) {
588 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
593 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
589 if (args[0]!=&returnValue) {
594 if (args[0]!=&returnValue) {
590 if (args[0]==NULL) {
595 if (args[0]==NULL) {
591 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
596 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
592 } else {
597 } else {
593 returnValue = *((int*)args[0]);
598 returnValue = *((int*)args[0]);
594 }
599 }
595 }
600 }
596 }
601 }
597 if (result) { Py_DECREF(result); }
602 if (result) { Py_DECREF(result); }
598 Py_DECREF(obj);
603 Py_DECREF(obj);
599 return returnValue;
604 return returnValue;
600 } else {
605 } else {
601 PyErr_Clear();
606 PyErr_Clear();
602 }
607 }
603 }
608 }
604 return MemSizeWdgt::devType();
609 return MemSizeWdgt::devType();
605 }
610 }
606 void PythonQtShell_MemSizeWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
611 void PythonQtShell_MemSizeWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
607 {
612 {
608 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
613 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
609 static PyObject* name = PyString_FromString("dragEnterEvent");
614 static PyObject* name = PyString_FromString("dragEnterEvent");
610 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
615 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
611 if (obj) {
616 if (obj) {
612 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
617 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
613 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
618 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
614 void* args[2] = {NULL, (void*)&arg__1};
619 void* args[2] = {NULL, (void*)&arg__1};
615 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
620 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
616 if (result) { Py_DECREF(result); }
621 if (result) { Py_DECREF(result); }
617 Py_DECREF(obj);
622 Py_DECREF(obj);
618 return;
623 return;
619 } else {
624 } else {
620 PyErr_Clear();
625 PyErr_Clear();
621 }
626 }
622 }
627 }
623 MemSizeWdgt::dragEnterEvent(arg__1);
628 MemSizeWdgt::dragEnterEvent(arg__1);
624 }
629 }
625 void PythonQtShell_MemSizeWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
630 void PythonQtShell_MemSizeWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
626 {
631 {
627 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
632 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
628 static PyObject* name = PyString_FromString("dragLeaveEvent");
633 static PyObject* name = PyString_FromString("dragLeaveEvent");
629 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
634 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
630 if (obj) {
635 if (obj) {
631 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
636 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
632 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
637 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
633 void* args[2] = {NULL, (void*)&arg__1};
638 void* args[2] = {NULL, (void*)&arg__1};
634 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
639 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
635 if (result) { Py_DECREF(result); }
640 if (result) { Py_DECREF(result); }
636 Py_DECREF(obj);
641 Py_DECREF(obj);
637 return;
642 return;
638 } else {
643 } else {
639 PyErr_Clear();
644 PyErr_Clear();
640 }
645 }
641 }
646 }
642 MemSizeWdgt::dragLeaveEvent(arg__1);
647 MemSizeWdgt::dragLeaveEvent(arg__1);
643 }
648 }
644 void PythonQtShell_MemSizeWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
649 void PythonQtShell_MemSizeWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
645 {
650 {
646 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
651 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
647 static PyObject* name = PyString_FromString("dragMoveEvent");
652 static PyObject* name = PyString_FromString("dragMoveEvent");
648 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
653 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
649 if (obj) {
654 if (obj) {
650 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
655 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
651 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
656 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
652 void* args[2] = {NULL, (void*)&arg__1};
657 void* args[2] = {NULL, (void*)&arg__1};
653 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
658 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
654 if (result) { Py_DECREF(result); }
659 if (result) { Py_DECREF(result); }
655 Py_DECREF(obj);
660 Py_DECREF(obj);
656 return;
661 return;
657 } else {
662 } else {
658 PyErr_Clear();
663 PyErr_Clear();
659 }
664 }
660 }
665 }
661 MemSizeWdgt::dragMoveEvent(arg__1);
666 MemSizeWdgt::dragMoveEvent(arg__1);
662 }
667 }
663 void PythonQtShell_MemSizeWdgt::dropEvent(QDropEvent* arg__1)
668 void PythonQtShell_MemSizeWdgt::dropEvent(QDropEvent* arg__1)
664 {
669 {
665 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
670 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
666 static PyObject* name = PyString_FromString("dropEvent");
671 static PyObject* name = PyString_FromString("dropEvent");
667 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
672 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
668 if (obj) {
673 if (obj) {
669 static const char* argumentList[] ={"" , "QDropEvent*"};
674 static const char* argumentList[] ={"" , "QDropEvent*"};
670 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
675 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
671 void* args[2] = {NULL, (void*)&arg__1};
676 void* args[2] = {NULL, (void*)&arg__1};
672 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
677 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
673 if (result) { Py_DECREF(result); }
678 if (result) { Py_DECREF(result); }
674 Py_DECREF(obj);
679 Py_DECREF(obj);
675 return;
680 return;
676 } else {
681 } else {
677 PyErr_Clear();
682 PyErr_Clear();
678 }
683 }
679 }
684 }
680 MemSizeWdgt::dropEvent(arg__1);
685 MemSizeWdgt::dropEvent(arg__1);
681 }
686 }
682 void PythonQtShell_MemSizeWdgt::enterEvent(QEvent* arg__1)
687 void PythonQtShell_MemSizeWdgt::enterEvent(QEvent* arg__1)
683 {
688 {
684 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
689 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
685 static PyObject* name = PyString_FromString("enterEvent");
690 static PyObject* name = PyString_FromString("enterEvent");
686 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
691 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
687 if (obj) {
692 if (obj) {
688 static const char* argumentList[] ={"" , "QEvent*"};
693 static const char* argumentList[] ={"" , "QEvent*"};
689 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
694 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
690 void* args[2] = {NULL, (void*)&arg__1};
695 void* args[2] = {NULL, (void*)&arg__1};
691 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
696 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
692 if (result) { Py_DECREF(result); }
697 if (result) { Py_DECREF(result); }
693 Py_DECREF(obj);
698 Py_DECREF(obj);
694 return;
699 return;
695 } else {
700 } else {
696 PyErr_Clear();
701 PyErr_Clear();
697 }
702 }
698 }
703 }
699 MemSizeWdgt::enterEvent(arg__1);
704 MemSizeWdgt::enterEvent(arg__1);
700 }
705 }
701 bool PythonQtShell_MemSizeWdgt::event(QEvent* arg__1)
706 bool PythonQtShell_MemSizeWdgt::event(QEvent* arg__1)
702 {
707 {
703 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
708 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
704 static PyObject* name = PyString_FromString("event");
709 static PyObject* name = PyString_FromString("event");
705 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
710 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
706 if (obj) {
711 if (obj) {
707 static const char* argumentList[] ={"bool" , "QEvent*"};
712 static const char* argumentList[] ={"bool" , "QEvent*"};
708 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
713 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
709 bool returnValue;
714 bool returnValue;
710 void* args[2] = {NULL, (void*)&arg__1};
715 void* args[2] = {NULL, (void*)&arg__1};
711 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
716 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
712 if (result) {
717 if (result) {
713 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
718 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
714 if (args[0]!=&returnValue) {
719 if (args[0]!=&returnValue) {
715 if (args[0]==NULL) {
720 if (args[0]==NULL) {
716 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
721 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
717 } else {
722 } else {
718 returnValue = *((bool*)args[0]);
723 returnValue = *((bool*)args[0]);
719 }
724 }
720 }
725 }
721 }
726 }
722 if (result) { Py_DECREF(result); }
727 if (result) { Py_DECREF(result); }
723 Py_DECREF(obj);
728 Py_DECREF(obj);
724 return returnValue;
729 return returnValue;
725 } else {
730 } else {
726 PyErr_Clear();
731 PyErr_Clear();
727 }
732 }
728 }
733 }
729 return MemSizeWdgt::event(arg__1);
734 return MemSizeWdgt::event(arg__1);
730 }
735 }
731 bool PythonQtShell_MemSizeWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
736 bool PythonQtShell_MemSizeWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
732 {
737 {
733 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
738 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
734 static PyObject* name = PyString_FromString("eventFilter");
739 static PyObject* name = PyString_FromString("eventFilter");
735 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
740 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
736 if (obj) {
741 if (obj) {
737 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
742 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
738 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
743 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
739 bool returnValue;
744 bool returnValue;
740 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
745 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
741 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
746 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
742 if (result) {
747 if (result) {
743 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
748 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
744 if (args[0]!=&returnValue) {
749 if (args[0]!=&returnValue) {
745 if (args[0]==NULL) {
750 if (args[0]==NULL) {
746 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
751 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
747 } else {
752 } else {
748 returnValue = *((bool*)args[0]);
753 returnValue = *((bool*)args[0]);
749 }
754 }
750 }
755 }
751 }
756 }
752 if (result) { Py_DECREF(result); }
757 if (result) { Py_DECREF(result); }
753 Py_DECREF(obj);
758 Py_DECREF(obj);
754 return returnValue;
759 return returnValue;
755 } else {
760 } else {
756 PyErr_Clear();
761 PyErr_Clear();
757 }
762 }
758 }
763 }
759 return MemSizeWdgt::eventFilter(arg__1, arg__2);
764 return MemSizeWdgt::eventFilter(arg__1, arg__2);
760 }
765 }
761 void PythonQtShell_MemSizeWdgt::focusInEvent(QFocusEvent* arg__1)
766 void PythonQtShell_MemSizeWdgt::focusInEvent(QFocusEvent* arg__1)
762 {
767 {
763 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
768 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
764 static PyObject* name = PyString_FromString("focusInEvent");
769 static PyObject* name = PyString_FromString("focusInEvent");
765 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
770 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
766 if (obj) {
771 if (obj) {
767 static const char* argumentList[] ={"" , "QFocusEvent*"};
772 static const char* argumentList[] ={"" , "QFocusEvent*"};
768 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
773 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
769 void* args[2] = {NULL, (void*)&arg__1};
774 void* args[2] = {NULL, (void*)&arg__1};
770 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
775 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
771 if (result) { Py_DECREF(result); }
776 if (result) { Py_DECREF(result); }
772 Py_DECREF(obj);
777 Py_DECREF(obj);
773 return;
778 return;
774 } else {
779 } else {
775 PyErr_Clear();
780 PyErr_Clear();
776 }
781 }
777 }
782 }
778 MemSizeWdgt::focusInEvent(arg__1);
783 MemSizeWdgt::focusInEvent(arg__1);
779 }
784 }
780 bool PythonQtShell_MemSizeWdgt::focusNextPrevChild(bool next0)
785 bool PythonQtShell_MemSizeWdgt::focusNextPrevChild(bool next0)
781 {
786 {
782 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
787 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
783 static PyObject* name = PyString_FromString("focusNextPrevChild");
788 static PyObject* name = PyString_FromString("focusNextPrevChild");
784 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
789 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
785 if (obj) {
790 if (obj) {
786 static const char* argumentList[] ={"bool" , "bool"};
791 static const char* argumentList[] ={"bool" , "bool"};
787 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
792 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
788 bool returnValue;
793 bool returnValue;
789 void* args[2] = {NULL, (void*)&next0};
794 void* args[2] = {NULL, (void*)&next0};
790 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
795 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
791 if (result) {
796 if (result) {
792 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
797 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
793 if (args[0]!=&returnValue) {
798 if (args[0]!=&returnValue) {
794 if (args[0]==NULL) {
799 if (args[0]==NULL) {
795 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
800 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
796 } else {
801 } else {
797 returnValue = *((bool*)args[0]);
802 returnValue = *((bool*)args[0]);
798 }
803 }
799 }
804 }
800 }
805 }
801 if (result) { Py_DECREF(result); }
806 if (result) { Py_DECREF(result); }
802 Py_DECREF(obj);
807 Py_DECREF(obj);
803 return returnValue;
808 return returnValue;
804 } else {
809 } else {
805 PyErr_Clear();
810 PyErr_Clear();
806 }
811 }
807 }
812 }
808 return MemSizeWdgt::focusNextPrevChild(next0);
813 return MemSizeWdgt::focusNextPrevChild(next0);
809 }
814 }
810 void PythonQtShell_MemSizeWdgt::focusOutEvent(QFocusEvent* arg__1)
815 void PythonQtShell_MemSizeWdgt::focusOutEvent(QFocusEvent* arg__1)
811 {
816 {
812 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
817 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
813 static PyObject* name = PyString_FromString("focusOutEvent");
818 static PyObject* name = PyString_FromString("focusOutEvent");
814 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
819 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
815 if (obj) {
820 if (obj) {
816 static const char* argumentList[] ={"" , "QFocusEvent*"};
821 static const char* argumentList[] ={"" , "QFocusEvent*"};
817 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
822 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
818 void* args[2] = {NULL, (void*)&arg__1};
823 void* args[2] = {NULL, (void*)&arg__1};
819 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
824 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
820 if (result) { Py_DECREF(result); }
825 if (result) { Py_DECREF(result); }
821 Py_DECREF(obj);
826 Py_DECREF(obj);
822 return;
827 return;
823 } else {
828 } else {
824 PyErr_Clear();
829 PyErr_Clear();
825 }
830 }
826 }
831 }
827 MemSizeWdgt::focusOutEvent(arg__1);
832 MemSizeWdgt::focusOutEvent(arg__1);
828 }
833 }
829 bool PythonQtShell_MemSizeWdgt::hasHeightForWidth() const
834 bool PythonQtShell_MemSizeWdgt::hasHeightForWidth() const
830 {
835 {
831 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
836 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
832 static PyObject* name = PyString_FromString("hasHeightForWidth");
837 static PyObject* name = PyString_FromString("hasHeightForWidth");
833 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
838 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
834 if (obj) {
839 if (obj) {
835 static const char* argumentList[] ={"bool"};
840 static const char* argumentList[] ={"bool"};
836 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
841 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
837 bool returnValue;
842 bool returnValue;
838 void* args[1] = {NULL};
843 void* args[1] = {NULL};
839 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
844 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
840 if (result) {
845 if (result) {
841 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
846 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
842 if (args[0]!=&returnValue) {
847 if (args[0]!=&returnValue) {
843 if (args[0]==NULL) {
848 if (args[0]==NULL) {
844 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
849 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
845 } else {
850 } else {
846 returnValue = *((bool*)args[0]);
851 returnValue = *((bool*)args[0]);
847 }
852 }
848 }
853 }
849 }
854 }
850 if (result) { Py_DECREF(result); }
855 if (result) { Py_DECREF(result); }
851 Py_DECREF(obj);
856 Py_DECREF(obj);
852 return returnValue;
857 return returnValue;
853 } else {
858 } else {
854 PyErr_Clear();
859 PyErr_Clear();
855 }
860 }
856 }
861 }
857 return MemSizeWdgt::hasHeightForWidth();
862 return MemSizeWdgt::hasHeightForWidth();
858 }
863 }
859 int PythonQtShell_MemSizeWdgt::heightForWidth(int arg__1) const
864 int PythonQtShell_MemSizeWdgt::heightForWidth(int arg__1) const
860 {
865 {
861 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
866 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
862 static PyObject* name = PyString_FromString("heightForWidth");
867 static PyObject* name = PyString_FromString("heightForWidth");
863 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
868 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
864 if (obj) {
869 if (obj) {
865 static const char* argumentList[] ={"int" , "int"};
870 static const char* argumentList[] ={"int" , "int"};
866 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
871 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
867 int returnValue;
872 int returnValue;
868 void* args[2] = {NULL, (void*)&arg__1};
873 void* args[2] = {NULL, (void*)&arg__1};
869 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
874 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
870 if (result) {
875 if (result) {
871 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
876 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
872 if (args[0]!=&returnValue) {
877 if (args[0]!=&returnValue) {
873 if (args[0]==NULL) {
878 if (args[0]==NULL) {
874 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
879 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
875 } else {
880 } else {
876 returnValue = *((int*)args[0]);
881 returnValue = *((int*)args[0]);
877 }
882 }
878 }
883 }
879 }
884 }
880 if (result) { Py_DECREF(result); }
885 if (result) { Py_DECREF(result); }
881 Py_DECREF(obj);
886 Py_DECREF(obj);
882 return returnValue;
887 return returnValue;
883 } else {
888 } else {
884 PyErr_Clear();
889 PyErr_Clear();
885 }
890 }
886 }
891 }
887 return MemSizeWdgt::heightForWidth(arg__1);
892 return MemSizeWdgt::heightForWidth(arg__1);
888 }
893 }
889 void PythonQtShell_MemSizeWdgt::hideEvent(QHideEvent* arg__1)
894 void PythonQtShell_MemSizeWdgt::hideEvent(QHideEvent* arg__1)
890 {
895 {
891 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
896 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
892 static PyObject* name = PyString_FromString("hideEvent");
897 static PyObject* name = PyString_FromString("hideEvent");
893 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
898 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
894 if (obj) {
899 if (obj) {
895 static const char* argumentList[] ={"" , "QHideEvent*"};
900 static const char* argumentList[] ={"" , "QHideEvent*"};
896 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
901 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
897 void* args[2] = {NULL, (void*)&arg__1};
902 void* args[2] = {NULL, (void*)&arg__1};
898 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
903 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
899 if (result) { Py_DECREF(result); }
904 if (result) { Py_DECREF(result); }
900 Py_DECREF(obj);
905 Py_DECREF(obj);
901 return;
906 return;
902 } else {
907 } else {
903 PyErr_Clear();
908 PyErr_Clear();
904 }
909 }
905 }
910 }
906 MemSizeWdgt::hideEvent(arg__1);
911 MemSizeWdgt::hideEvent(arg__1);
907 }
912 }
908 void PythonQtShell_MemSizeWdgt::initPainter(QPainter* painter0) const
913 void PythonQtShell_MemSizeWdgt::initPainter(QPainter* painter0) const
909 {
914 {
910 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
915 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
911 static PyObject* name = PyString_FromString("initPainter");
916 static PyObject* name = PyString_FromString("initPainter");
912 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
917 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
913 if (obj) {
918 if (obj) {
914 static const char* argumentList[] ={"" , "QPainter*"};
919 static const char* argumentList[] ={"" , "QPainter*"};
915 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
920 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
916 void* args[2] = {NULL, (void*)&painter0};
921 void* args[2] = {NULL, (void*)&painter0};
917 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
922 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
918 if (result) { Py_DECREF(result); }
923 if (result) { Py_DECREF(result); }
919 Py_DECREF(obj);
924 Py_DECREF(obj);
920 return;
925 return;
921 } else {
926 } else {
922 PyErr_Clear();
927 PyErr_Clear();
923 }
928 }
924 }
929 }
925 MemSizeWdgt::initPainter(painter0);
930 MemSizeWdgt::initPainter(painter0);
926 }
931 }
927 void PythonQtShell_MemSizeWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
932 void PythonQtShell_MemSizeWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
928 {
933 {
929 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
934 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
930 static PyObject* name = PyString_FromString("inputMethodEvent");
935 static PyObject* name = PyString_FromString("inputMethodEvent");
931 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
936 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
932 if (obj) {
937 if (obj) {
933 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
938 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
934 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
939 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
935 void* args[2] = {NULL, (void*)&arg__1};
940 void* args[2] = {NULL, (void*)&arg__1};
936 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
941 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
937 if (result) { Py_DECREF(result); }
942 if (result) { Py_DECREF(result); }
938 Py_DECREF(obj);
943 Py_DECREF(obj);
939 return;
944 return;
940 } else {
945 } else {
941 PyErr_Clear();
946 PyErr_Clear();
942 }
947 }
943 }
948 }
944 MemSizeWdgt::inputMethodEvent(arg__1);
949 MemSizeWdgt::inputMethodEvent(arg__1);
945 }
950 }
946 QVariant PythonQtShell_MemSizeWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
951 QVariant PythonQtShell_MemSizeWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
947 {
952 {
948 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
953 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
949 static PyObject* name = PyString_FromString("inputMethodQuery");
954 static PyObject* name = PyString_FromString("inputMethodQuery");
950 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
955 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
951 if (obj) {
956 if (obj) {
952 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
957 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
953 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
958 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
954 QVariant returnValue;
959 QVariant returnValue;
955 void* args[2] = {NULL, (void*)&arg__1};
960 void* args[2] = {NULL, (void*)&arg__1};
956 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
961 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
957 if (result) {
962 if (result) {
958 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
963 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
959 if (args[0]!=&returnValue) {
964 if (args[0]!=&returnValue) {
960 if (args[0]==NULL) {
965 if (args[0]==NULL) {
961 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
966 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
962 } else {
967 } else {
963 returnValue = *((QVariant*)args[0]);
968 returnValue = *((QVariant*)args[0]);
964 }
969 }
965 }
970 }
966 }
971 }
967 if (result) { Py_DECREF(result); }
972 if (result) { Py_DECREF(result); }
968 Py_DECREF(obj);
973 Py_DECREF(obj);
969 return returnValue;
974 return returnValue;
970 } else {
975 } else {
971 PyErr_Clear();
976 PyErr_Clear();
972 }
977 }
973 }
978 }
974 return MemSizeWdgt::inputMethodQuery(arg__1);
979 return MemSizeWdgt::inputMethodQuery(arg__1);
975 }
980 }
976 void PythonQtShell_MemSizeWdgt::keyPressEvent(QKeyEvent* arg__1)
981 void PythonQtShell_MemSizeWdgt::keyPressEvent(QKeyEvent* arg__1)
977 {
982 {
978 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
983 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
979 static PyObject* name = PyString_FromString("keyPressEvent");
984 static PyObject* name = PyString_FromString("keyPressEvent");
980 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
985 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
981 if (obj) {
986 if (obj) {
982 static const char* argumentList[] ={"" , "QKeyEvent*"};
987 static const char* argumentList[] ={"" , "QKeyEvent*"};
983 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
988 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
984 void* args[2] = {NULL, (void*)&arg__1};
989 void* args[2] = {NULL, (void*)&arg__1};
985 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
990 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
986 if (result) { Py_DECREF(result); }
991 if (result) { Py_DECREF(result); }
987 Py_DECREF(obj);
992 Py_DECREF(obj);
988 return;
993 return;
989 } else {
994 } else {
990 PyErr_Clear();
995 PyErr_Clear();
991 }
996 }
992 }
997 }
993 MemSizeWdgt::keyPressEvent(arg__1);
998 MemSizeWdgt::keyPressEvent(arg__1);
994 }
999 }
995 void PythonQtShell_MemSizeWdgt::keyReleaseEvent(QKeyEvent* arg__1)
1000 void PythonQtShell_MemSizeWdgt::keyReleaseEvent(QKeyEvent* arg__1)
996 {
1001 {
997 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1002 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
998 static PyObject* name = PyString_FromString("keyReleaseEvent");
1003 static PyObject* name = PyString_FromString("keyReleaseEvent");
999 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1004 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1000 if (obj) {
1005 if (obj) {
1001 static const char* argumentList[] ={"" , "QKeyEvent*"};
1006 static const char* argumentList[] ={"" , "QKeyEvent*"};
1002 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1007 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1003 void* args[2] = {NULL, (void*)&arg__1};
1008 void* args[2] = {NULL, (void*)&arg__1};
1004 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1009 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1005 if (result) { Py_DECREF(result); }
1010 if (result) { Py_DECREF(result); }
1006 Py_DECREF(obj);
1011 Py_DECREF(obj);
1007 return;
1012 return;
1008 } else {
1013 } else {
1009 PyErr_Clear();
1014 PyErr_Clear();
1010 }
1015 }
1011 }
1016 }
1012 MemSizeWdgt::keyReleaseEvent(arg__1);
1017 MemSizeWdgt::keyReleaseEvent(arg__1);
1013 }
1018 }
1014 void PythonQtShell_MemSizeWdgt::leaveEvent(QEvent* arg__1)
1019 void PythonQtShell_MemSizeWdgt::leaveEvent(QEvent* arg__1)
1015 {
1020 {
1016 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1021 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1017 static PyObject* name = PyString_FromString("leaveEvent");
1022 static PyObject* name = PyString_FromString("leaveEvent");
1018 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1023 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1019 if (obj) {
1024 if (obj) {
1020 static const char* argumentList[] ={"" , "QEvent*"};
1025 static const char* argumentList[] ={"" , "QEvent*"};
1021 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1026 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1022 void* args[2] = {NULL, (void*)&arg__1};
1027 void* args[2] = {NULL, (void*)&arg__1};
1023 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1028 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1024 if (result) { Py_DECREF(result); }
1029 if (result) { Py_DECREF(result); }
1025 Py_DECREF(obj);
1030 Py_DECREF(obj);
1026 return;
1031 return;
1027 } else {
1032 } else {
1028 PyErr_Clear();
1033 PyErr_Clear();
1029 }
1034 }
1030 }
1035 }
1031 MemSizeWdgt::leaveEvent(arg__1);
1036 MemSizeWdgt::leaveEvent(arg__1);
1032 }
1037 }
1033 int PythonQtShell_MemSizeWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
1038 int PythonQtShell_MemSizeWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
1034 {
1039 {
1035 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1040 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1036 static PyObject* name = PyString_FromString("metric");
1041 static PyObject* name = PyString_FromString("metric");
1037 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1042 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1038 if (obj) {
1043 if (obj) {
1039 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
1044 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
1040 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1045 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1041 int returnValue;
1046 int returnValue;
1042 void* args[2] = {NULL, (void*)&arg__1};
1047 void* args[2] = {NULL, (void*)&arg__1};
1043 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1048 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1044 if (result) {
1049 if (result) {
1045 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1050 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1046 if (args[0]!=&returnValue) {
1051 if (args[0]!=&returnValue) {
1047 if (args[0]==NULL) {
1052 if (args[0]==NULL) {
1048 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
1053 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
1049 } else {
1054 } else {
1050 returnValue = *((int*)args[0]);
1055 returnValue = *((int*)args[0]);
1051 }
1056 }
1052 }
1057 }
1053 }
1058 }
1054 if (result) { Py_DECREF(result); }
1059 if (result) { Py_DECREF(result); }
1055 Py_DECREF(obj);
1060 Py_DECREF(obj);
1056 return returnValue;
1061 return returnValue;
1057 } else {
1062 } else {
1058 PyErr_Clear();
1063 PyErr_Clear();
1059 }
1064 }
1060 }
1065 }
1061 return MemSizeWdgt::metric(arg__1);
1066 return MemSizeWdgt::metric(arg__1);
1062 }
1067 }
1063 QSize PythonQtShell_MemSizeWdgt::minimumSizeHint() const
1068 QSize PythonQtShell_MemSizeWdgt::minimumSizeHint() const
1064 {
1069 {
1065 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1070 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1066 static PyObject* name = PyString_FromString("getMinimumSizeHint");
1071 static PyObject* name = PyString_FromString("getMinimumSizeHint");
1067 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1072 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1068 if (obj) {
1073 if (obj) {
1069 static const char* argumentList[] ={"QSize"};
1074 static const char* argumentList[] ={"QSize"};
1070 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1075 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1071 QSize returnValue;
1076 QSize returnValue;
1072 void* args[1] = {NULL};
1077 void* args[1] = {NULL};
1073 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1078 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1074 if (result) {
1079 if (result) {
1075 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1080 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1076 if (args[0]!=&returnValue) {
1081 if (args[0]!=&returnValue) {
1077 if (args[0]==NULL) {
1082 if (args[0]==NULL) {
1078 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
1083 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
1079 } else {
1084 } else {
1080 returnValue = *((QSize*)args[0]);
1085 returnValue = *((QSize*)args[0]);
1081 }
1086 }
1082 }
1087 }
1083 }
1088 }
1084 if (result) { Py_DECREF(result); }
1089 if (result) { Py_DECREF(result); }
1085 Py_DECREF(obj);
1090 Py_DECREF(obj);
1086 return returnValue;
1091 return returnValue;
1087 } else {
1092 } else {
1088 PyErr_Clear();
1093 PyErr_Clear();
1089 }
1094 }
1090 }
1095 }
1091 return MemSizeWdgt::minimumSizeHint();
1096 return MemSizeWdgt::minimumSizeHint();
1092 }
1097 }
1093 void PythonQtShell_MemSizeWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
1098 void PythonQtShell_MemSizeWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
1094 {
1099 {
1095 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1100 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1096 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
1101 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
1097 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1102 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1098 if (obj) {
1103 if (obj) {
1099 static const char* argumentList[] ={"" , "QMouseEvent*"};
1104 static const char* argumentList[] ={"" , "QMouseEvent*"};
1100 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1105 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1101 void* args[2] = {NULL, (void*)&arg__1};
1106 void* args[2] = {NULL, (void*)&arg__1};
1102 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1107 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1103 if (result) { Py_DECREF(result); }
1108 if (result) { Py_DECREF(result); }
1104 Py_DECREF(obj);
1109 Py_DECREF(obj);
1105 return;
1110 return;
1106 } else {
1111 } else {
1107 PyErr_Clear();
1112 PyErr_Clear();
1108 }
1113 }
1109 }
1114 }
1110 MemSizeWdgt::mouseDoubleClickEvent(arg__1);
1115 MemSizeWdgt::mouseDoubleClickEvent(arg__1);
1111 }
1116 }
1112 void PythonQtShell_MemSizeWdgt::mouseMoveEvent(QMouseEvent* arg__1)
1117 void PythonQtShell_MemSizeWdgt::mouseMoveEvent(QMouseEvent* arg__1)
1113 {
1118 {
1114 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1119 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1115 static PyObject* name = PyString_FromString("mouseMoveEvent");
1120 static PyObject* name = PyString_FromString("mouseMoveEvent");
1116 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1121 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1117 if (obj) {
1122 if (obj) {
1118 static const char* argumentList[] ={"" , "QMouseEvent*"};
1123 static const char* argumentList[] ={"" , "QMouseEvent*"};
1119 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1124 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1120 void* args[2] = {NULL, (void*)&arg__1};
1125 void* args[2] = {NULL, (void*)&arg__1};
1121 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1126 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1122 if (result) { Py_DECREF(result); }
1127 if (result) { Py_DECREF(result); }
1123 Py_DECREF(obj);
1128 Py_DECREF(obj);
1124 return;
1129 return;
1125 } else {
1130 } else {
1126 PyErr_Clear();
1131 PyErr_Clear();
1127 }
1132 }
1128 }
1133 }
1129 MemSizeWdgt::mouseMoveEvent(arg__1);
1134 MemSizeWdgt::mouseMoveEvent(arg__1);
1130 }
1135 }
1131 void PythonQtShell_MemSizeWdgt::mousePressEvent(QMouseEvent* arg__1)
1136 void PythonQtShell_MemSizeWdgt::mousePressEvent(QMouseEvent* arg__1)
1132 {
1137 {
1133 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1138 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1134 static PyObject* name = PyString_FromString("mousePressEvent");
1139 static PyObject* name = PyString_FromString("mousePressEvent");
1135 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1140 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1136 if (obj) {
1141 if (obj) {
1137 static const char* argumentList[] ={"" , "QMouseEvent*"};
1142 static const char* argumentList[] ={"" , "QMouseEvent*"};
1138 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1143 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1139 void* args[2] = {NULL, (void*)&arg__1};
1144 void* args[2] = {NULL, (void*)&arg__1};
1140 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1145 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1141 if (result) { Py_DECREF(result); }
1146 if (result) { Py_DECREF(result); }
1142 Py_DECREF(obj);
1147 Py_DECREF(obj);
1143 return;
1148 return;
1144 } else {
1149 } else {
1145 PyErr_Clear();
1150 PyErr_Clear();
1146 }
1151 }
1147 }
1152 }
1148 MemSizeWdgt::mousePressEvent(arg__1);
1153 MemSizeWdgt::mousePressEvent(arg__1);
1149 }
1154 }
1150 void PythonQtShell_MemSizeWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
1155 void PythonQtShell_MemSizeWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
1151 {
1156 {
1152 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1157 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1153 static PyObject* name = PyString_FromString("mouseReleaseEvent");
1158 static PyObject* name = PyString_FromString("mouseReleaseEvent");
1154 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1159 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1155 if (obj) {
1160 if (obj) {
1156 static const char* argumentList[] ={"" , "QMouseEvent*"};
1161 static const char* argumentList[] ={"" , "QMouseEvent*"};
1157 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1162 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1158 void* args[2] = {NULL, (void*)&arg__1};
1163 void* args[2] = {NULL, (void*)&arg__1};
1159 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1164 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1160 if (result) { Py_DECREF(result); }
1165 if (result) { Py_DECREF(result); }
1161 Py_DECREF(obj);
1166 Py_DECREF(obj);
1162 return;
1167 return;
1163 } else {
1168 } else {
1164 PyErr_Clear();
1169 PyErr_Clear();
1165 }
1170 }
1166 }
1171 }
1167 MemSizeWdgt::mouseReleaseEvent(arg__1);
1172 MemSizeWdgt::mouseReleaseEvent(arg__1);
1168 }
1173 }
1169 void PythonQtShell_MemSizeWdgt::moveEvent(QMoveEvent* arg__1)
1174 void PythonQtShell_MemSizeWdgt::moveEvent(QMoveEvent* arg__1)
1170 {
1175 {
1171 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1176 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1172 static PyObject* name = PyString_FromString("moveEvent");
1177 static PyObject* name = PyString_FromString("moveEvent");
1173 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1178 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1174 if (obj) {
1179 if (obj) {
1175 static const char* argumentList[] ={"" , "QMoveEvent*"};
1180 static const char* argumentList[] ={"" , "QMoveEvent*"};
1176 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1181 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1177 void* args[2] = {NULL, (void*)&arg__1};
1182 void* args[2] = {NULL, (void*)&arg__1};
1178 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1183 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1179 if (result) { Py_DECREF(result); }
1184 if (result) { Py_DECREF(result); }
1180 Py_DECREF(obj);
1185 Py_DECREF(obj);
1181 return;
1186 return;
1182 } else {
1187 } else {
1183 PyErr_Clear();
1188 PyErr_Clear();
1184 }
1189 }
1185 }
1190 }
1186 MemSizeWdgt::moveEvent(arg__1);
1191 MemSizeWdgt::moveEvent(arg__1);
1187 }
1192 }
1188 bool PythonQtShell_MemSizeWdgt::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
1193 bool PythonQtShell_MemSizeWdgt::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
1189 {
1194 {
1190 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1195 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1191 static PyObject* name = PyString_FromString("nativeEvent");
1196 static PyObject* name = PyString_FromString("nativeEvent");
1192 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1197 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1193 if (obj) {
1198 if (obj) {
1194 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
1199 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
1195 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
1200 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
1196 bool returnValue;
1201 bool returnValue;
1197 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
1202 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
1198 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1203 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1199 if (result) {
1204 if (result) {
1200 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1205 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1201 if (args[0]!=&returnValue) {
1206 if (args[0]!=&returnValue) {
1202 if (args[0]==NULL) {
1207 if (args[0]==NULL) {
1203 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
1208 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
1204 } else {
1209 } else {
1205 returnValue = *((bool*)args[0]);
1210 returnValue = *((bool*)args[0]);
1206 }
1211 }
1207 }
1212 }
1208 }
1213 }
1209 if (result) { Py_DECREF(result); }
1214 if (result) { Py_DECREF(result); }
1210 Py_DECREF(obj);
1215 Py_DECREF(obj);
1211 return returnValue;
1216 return returnValue;
1212 } else {
1217 } else {
1213 PyErr_Clear();
1218 PyErr_Clear();
1214 }
1219 }
1215 }
1220 }
1216 return MemSizeWdgt::nativeEvent(eventType0, message1, result2);
1221 return MemSizeWdgt::nativeEvent(eventType0, message1, result2);
1217 }
1222 }
1218 QPaintEngine* PythonQtShell_MemSizeWdgt::paintEngine() const
1223 QPaintEngine* PythonQtShell_MemSizeWdgt::paintEngine() const
1219 {
1224 {
1220 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1225 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1221 static PyObject* name = PyString_FromString("paintEngine");
1226 static PyObject* name = PyString_FromString("paintEngine");
1222 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1227 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1223 if (obj) {
1228 if (obj) {
1224 static const char* argumentList[] ={"QPaintEngine*"};
1229 static const char* argumentList[] ={"QPaintEngine*"};
1225 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1230 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1226 QPaintEngine* returnValue;
1231 QPaintEngine* returnValue;
1227 void* args[1] = {NULL};
1232 void* args[1] = {NULL};
1228 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1233 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1229 if (result) {
1234 if (result) {
1230 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1235 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1231 if (args[0]!=&returnValue) {
1236 if (args[0]!=&returnValue) {
1232 if (args[0]==NULL) {
1237 if (args[0]==NULL) {
1233 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
1238 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
1234 } else {
1239 } else {
1235 returnValue = *((QPaintEngine**)args[0]);
1240 returnValue = *((QPaintEngine**)args[0]);
1236 }
1241 }
1237 }
1242 }
1238 }
1243 }
1239 if (result) { Py_DECREF(result); }
1244 if (result) { Py_DECREF(result); }
1240 Py_DECREF(obj);
1245 Py_DECREF(obj);
1241 return returnValue;
1246 return returnValue;
1242 } else {
1247 } else {
1243 PyErr_Clear();
1248 PyErr_Clear();
1244 }
1249 }
1245 }
1250 }
1246 return MemSizeWdgt::paintEngine();
1251 return MemSizeWdgt::paintEngine();
1247 }
1252 }
1248 void PythonQtShell_MemSizeWdgt::paintEvent(QPaintEvent* arg__1)
1253 void PythonQtShell_MemSizeWdgt::paintEvent(QPaintEvent* arg__1)
1249 {
1254 {
1250 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1255 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1251 static PyObject* name = PyString_FromString("paintEvent");
1256 static PyObject* name = PyString_FromString("paintEvent");
1252 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1257 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1253 if (obj) {
1258 if (obj) {
1254 static const char* argumentList[] ={"" , "QPaintEvent*"};
1259 static const char* argumentList[] ={"" , "QPaintEvent*"};
1255 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1260 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1256 void* args[2] = {NULL, (void*)&arg__1};
1261 void* args[2] = {NULL, (void*)&arg__1};
1257 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1262 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1258 if (result) { Py_DECREF(result); }
1263 if (result) { Py_DECREF(result); }
1259 Py_DECREF(obj);
1264 Py_DECREF(obj);
1260 return;
1265 return;
1261 } else {
1266 } else {
1262 PyErr_Clear();
1267 PyErr_Clear();
1263 }
1268 }
1264 }
1269 }
1265 MemSizeWdgt::paintEvent(arg__1);
1270 MemSizeWdgt::paintEvent(arg__1);
1266 }
1271 }
1267 QPaintDevice* PythonQtShell_MemSizeWdgt::redirected(QPoint* offset0) const
1272 QPaintDevice* PythonQtShell_MemSizeWdgt::redirected(QPoint* offset0) const
1268 {
1273 {
1269 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1274 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1270 static PyObject* name = PyString_FromString("redirected");
1275 static PyObject* name = PyString_FromString("redirected");
1271 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1276 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1272 if (obj) {
1277 if (obj) {
1273 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
1278 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
1274 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1279 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1275 QPaintDevice* returnValue;
1280 QPaintDevice* returnValue;
1276 void* args[2] = {NULL, (void*)&offset0};
1281 void* args[2] = {NULL, (void*)&offset0};
1277 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1282 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1278 if (result) {
1283 if (result) {
1279 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1284 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1280 if (args[0]!=&returnValue) {
1285 if (args[0]!=&returnValue) {
1281 if (args[0]==NULL) {
1286 if (args[0]==NULL) {
1282 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
1287 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
1283 } else {
1288 } else {
1284 returnValue = *((QPaintDevice**)args[0]);
1289 returnValue = *((QPaintDevice**)args[0]);
1285 }
1290 }
1286 }
1291 }
1287 }
1292 }
1288 if (result) { Py_DECREF(result); }
1293 if (result) { Py_DECREF(result); }
1289 Py_DECREF(obj);
1294 Py_DECREF(obj);
1290 return returnValue;
1295 return returnValue;
1291 } else {
1296 } else {
1292 PyErr_Clear();
1297 PyErr_Clear();
1293 }
1298 }
1294 }
1299 }
1295 return MemSizeWdgt::redirected(offset0);
1300 return MemSizeWdgt::redirected(offset0);
1296 }
1301 }
1297 void PythonQtShell_MemSizeWdgt::resizeEvent(QResizeEvent* arg__1)
1302 void PythonQtShell_MemSizeWdgt::resizeEvent(QResizeEvent* arg__1)
1298 {
1303 {
1299 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1304 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1300 static PyObject* name = PyString_FromString("resizeEvent");
1305 static PyObject* name = PyString_FromString("resizeEvent");
1301 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1306 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1302 if (obj) {
1307 if (obj) {
1303 static const char* argumentList[] ={"" , "QResizeEvent*"};
1308 static const char* argumentList[] ={"" , "QResizeEvent*"};
1304 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1309 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1305 void* args[2] = {NULL, (void*)&arg__1};
1310 void* args[2] = {NULL, (void*)&arg__1};
1306 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1311 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1307 if (result) { Py_DECREF(result); }
1312 if (result) { Py_DECREF(result); }
1308 Py_DECREF(obj);
1313 Py_DECREF(obj);
1309 return;
1314 return;
1310 } else {
1315 } else {
1311 PyErr_Clear();
1316 PyErr_Clear();
1312 }
1317 }
1313 }
1318 }
1314 MemSizeWdgt::resizeEvent(arg__1);
1319 MemSizeWdgt::resizeEvent(arg__1);
1315 }
1320 }
1316 QPainter* PythonQtShell_MemSizeWdgt::sharedPainter() const
1321 QPainter* PythonQtShell_MemSizeWdgt::sharedPainter() const
1317 {
1322 {
1318 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1323 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1319 static PyObject* name = PyString_FromString("sharedPainter");
1324 static PyObject* name = PyString_FromString("sharedPainter");
1320 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1325 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1321 if (obj) {
1326 if (obj) {
1322 static const char* argumentList[] ={"QPainter*"};
1327 static const char* argumentList[] ={"QPainter*"};
1323 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1328 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1324 QPainter* returnValue;
1329 QPainter* returnValue;
1325 void* args[1] = {NULL};
1330 void* args[1] = {NULL};
1326 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1331 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1327 if (result) {
1332 if (result) {
1328 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1333 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1329 if (args[0]!=&returnValue) {
1334 if (args[0]!=&returnValue) {
1330 if (args[0]==NULL) {
1335 if (args[0]==NULL) {
1331 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
1336 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
1332 } else {
1337 } else {
1333 returnValue = *((QPainter**)args[0]);
1338 returnValue = *((QPainter**)args[0]);
1334 }
1339 }
1335 }
1340 }
1336 }
1341 }
1337 if (result) { Py_DECREF(result); }
1342 if (result) { Py_DECREF(result); }
1338 Py_DECREF(obj);
1343 Py_DECREF(obj);
1339 return returnValue;
1344 return returnValue;
1340 } else {
1345 } else {
1341 PyErr_Clear();
1346 PyErr_Clear();
1342 }
1347 }
1343 }
1348 }
1344 return MemSizeWdgt::sharedPainter();
1349 return MemSizeWdgt::sharedPainter();
1345 }
1350 }
1346 void PythonQtShell_MemSizeWdgt::showEvent(QShowEvent* arg__1)
1351 void PythonQtShell_MemSizeWdgt::showEvent(QShowEvent* arg__1)
1347 {
1352 {
1348 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1353 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1349 static PyObject* name = PyString_FromString("showEvent");
1354 static PyObject* name = PyString_FromString("showEvent");
1350 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1355 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1351 if (obj) {
1356 if (obj) {
1352 static const char* argumentList[] ={"" , "QShowEvent*"};
1357 static const char* argumentList[] ={"" , "QShowEvent*"};
1353 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1358 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1354 void* args[2] = {NULL, (void*)&arg__1};
1359 void* args[2] = {NULL, (void*)&arg__1};
1355 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1360 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1356 if (result) { Py_DECREF(result); }
1361 if (result) { Py_DECREF(result); }
1357 Py_DECREF(obj);
1362 Py_DECREF(obj);
1358 return;
1363 return;
1359 } else {
1364 } else {
1360 PyErr_Clear();
1365 PyErr_Clear();
1361 }
1366 }
1362 }
1367 }
1363 MemSizeWdgt::showEvent(arg__1);
1368 MemSizeWdgt::showEvent(arg__1);
1364 }
1369 }
1365 QSize PythonQtShell_MemSizeWdgt::sizeHint() const
1370 QSize PythonQtShell_MemSizeWdgt::sizeHint() const
1366 {
1371 {
1367 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1372 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1368 static PyObject* name = PyString_FromString("getSizeHint");
1373 static PyObject* name = PyString_FromString("getSizeHint");
1369 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1374 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1370 if (obj) {
1375 if (obj) {
1371 static const char* argumentList[] ={"QSize"};
1376 static const char* argumentList[] ={"QSize"};
1372 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1377 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1373 QSize returnValue;
1378 QSize returnValue;
1374 void* args[1] = {NULL};
1379 void* args[1] = {NULL};
1375 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1380 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1376 if (result) {
1381 if (result) {
1377 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1382 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1378 if (args[0]!=&returnValue) {
1383 if (args[0]!=&returnValue) {
1379 if (args[0]==NULL) {
1384 if (args[0]==NULL) {
1380 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
1385 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
1381 } else {
1386 } else {
1382 returnValue = *((QSize*)args[0]);
1387 returnValue = *((QSize*)args[0]);
1383 }
1388 }
1384 }
1389 }
1385 }
1390 }
1386 if (result) { Py_DECREF(result); }
1391 if (result) { Py_DECREF(result); }
1387 Py_DECREF(obj);
1392 Py_DECREF(obj);
1388 return returnValue;
1393 return returnValue;
1389 } else {
1394 } else {
1390 PyErr_Clear();
1395 PyErr_Clear();
1391 }
1396 }
1392 }
1397 }
1393 return MemSizeWdgt::sizeHint();
1398 return MemSizeWdgt::sizeHint();
1394 }
1399 }
1395 void PythonQtShell_MemSizeWdgt::tabletEvent(QTabletEvent* arg__1)
1400 void PythonQtShell_MemSizeWdgt::tabletEvent(QTabletEvent* arg__1)
1396 {
1401 {
1397 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1402 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1398 static PyObject* name = PyString_FromString("tabletEvent");
1403 static PyObject* name = PyString_FromString("tabletEvent");
1399 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1404 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1400 if (obj) {
1405 if (obj) {
1401 static const char* argumentList[] ={"" , "QTabletEvent*"};
1406 static const char* argumentList[] ={"" , "QTabletEvent*"};
1402 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1407 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1403 void* args[2] = {NULL, (void*)&arg__1};
1408 void* args[2] = {NULL, (void*)&arg__1};
1404 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1409 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1405 if (result) { Py_DECREF(result); }
1410 if (result) { Py_DECREF(result); }
1406 Py_DECREF(obj);
1411 Py_DECREF(obj);
1407 return;
1412 return;
1408 } else {
1413 } else {
1409 PyErr_Clear();
1414 PyErr_Clear();
1410 }
1415 }
1411 }
1416 }
1412 MemSizeWdgt::tabletEvent(arg__1);
1417 MemSizeWdgt::tabletEvent(arg__1);
1413 }
1418 }
1414 void PythonQtShell_MemSizeWdgt::timerEvent(QTimerEvent* arg__1)
1419 void PythonQtShell_MemSizeWdgt::timerEvent(QTimerEvent* arg__1)
1415 {
1420 {
1416 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1421 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1417 static PyObject* name = PyString_FromString("timerEvent");
1422 static PyObject* name = PyString_FromString("timerEvent");
1418 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1423 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1419 if (obj) {
1424 if (obj) {
1420 static const char* argumentList[] ={"" , "QTimerEvent*"};
1425 static const char* argumentList[] ={"" , "QTimerEvent*"};
1421 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1426 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1422 void* args[2] = {NULL, (void*)&arg__1};
1427 void* args[2] = {NULL, (void*)&arg__1};
1423 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1428 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1424 if (result) { Py_DECREF(result); }
1429 if (result) { Py_DECREF(result); }
1425 Py_DECREF(obj);
1430 Py_DECREF(obj);
1426 return;
1431 return;
1427 } else {
1432 } else {
1428 PyErr_Clear();
1433 PyErr_Clear();
1429 }
1434 }
1430 }
1435 }
1431 MemSizeWdgt::timerEvent(arg__1);
1436 MemSizeWdgt::timerEvent(arg__1);
1432 }
1437 }
1433 void PythonQtShell_MemSizeWdgt::wheelEvent(QWheelEvent* arg__1)
1438 void PythonQtShell_MemSizeWdgt::wheelEvent(QWheelEvent* arg__1)
1434 {
1439 {
1435 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1440 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1436 static PyObject* name = PyString_FromString("wheelEvent");
1441 static PyObject* name = PyString_FromString("wheelEvent");
1437 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1442 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1438 if (obj) {
1443 if (obj) {
1439 static const char* argumentList[] ={"" , "QWheelEvent*"};
1444 static const char* argumentList[] ={"" , "QWheelEvent*"};
1440 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1445 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1441 void* args[2] = {NULL, (void*)&arg__1};
1446 void* args[2] = {NULL, (void*)&arg__1};
1442 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1447 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1443 if (result) { Py_DECREF(result); }
1448 if (result) { Py_DECREF(result); }
1444 Py_DECREF(obj);
1449 Py_DECREF(obj);
1445 return;
1450 return;
1446 } else {
1451 } else {
1447 PyErr_Clear();
1452 PyErr_Clear();
1448 }
1453 }
1449 }
1454 }
1450 MemSizeWdgt::wheelEvent(arg__1);
1455 MemSizeWdgt::wheelEvent(arg__1);
1451 }
1456 }
1452 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(QWidget* parent)
1457 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(QWidget* parent)
1453 {
1458 {
1454 return new PythonQtShell_MemSizeWdgt(parent); }
1459 return new PythonQtShell_MemSizeWdgt(parent); }
1455
1460
1456 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(int defaultSize, QWidget* parent)
1461 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(int defaultSize, QWidget* parent)
1457 {
1462 {
1458 return new PythonQtShell_MemSizeWdgt(defaultSize, parent); }
1463 return new PythonQtShell_MemSizeWdgt(defaultSize, parent); }
1459
1464
1460 int PythonQtWrapper_MemSizeWdgt::getsize(MemSizeWdgt* theWrappedObject)
1465 int PythonQtWrapper_MemSizeWdgt::getsize(MemSizeWdgt* theWrappedObject)
1461 {
1466 {
1462 return ( theWrappedObject->getsize());
1467 return ( theWrappedObject->getsize());
1463 }
1468 }
1464
1469
1465 void PythonQtWrapper_MemSizeWdgt::setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max)
1470 void PythonQtWrapper_MemSizeWdgt::setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max)
1466 {
1471 {
1467 ( theWrappedObject->setMaximum(max));
1472 ( theWrappedObject->setMaximum(max));
1468 }
1473 }
1469
1474
1470 void PythonQtWrapper_MemSizeWdgt::show(MemSizeWdgt* theWrappedObject)
1475 void PythonQtWrapper_MemSizeWdgt::show(MemSizeWdgt* theWrappedObject)
1471 {
1476 {
1472 ( theWrappedObject->show());
1477 ( theWrappedObject->show());
1473 }
1478 }
1474
1479
1475 void PythonQtWrapper_MemSizeWdgt::updateSizeValue(MemSizeWdgt* theWrappedObject)
1480 void PythonQtWrapper_MemSizeWdgt::updateSizeValue(MemSizeWdgt* theWrappedObject)
1476 {
1481 {
1477 ( theWrappedObject->updateSizeValue());
1482 ( theWrappedObject->updateSizeValue());
1478 }
1483 }
1479
1484
1480
1485
1481
1486
1482 PythonQtShell_QHexEdit::~PythonQtShell_QHexEdit() {
1487 PythonQtShell_QHexEdit::~PythonQtShell_QHexEdit() {
1483 PythonQtPrivate* priv = PythonQt::priv();
1488 PythonQtPrivate* priv = PythonQt::priv();
1484 if (priv) { priv->shellClassDeleted(this); }
1489 if (priv) { priv->shellClassDeleted(this); }
1485 }
1490 }
1486 void PythonQtShell_QHexEdit::actionEvent(QActionEvent* arg__1)
1491 void PythonQtShell_QHexEdit::actionEvent(QActionEvent* arg__1)
1487 {
1492 {
1488 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1493 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1489 static PyObject* name = PyString_FromString("actionEvent");
1494 static PyObject* name = PyString_FromString("actionEvent");
1490 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1495 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1491 if (obj) {
1496 if (obj) {
1492 static const char* argumentList[] ={"" , "QActionEvent*"};
1497 static const char* argumentList[] ={"" , "QActionEvent*"};
1493 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1498 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1494 void* args[2] = {NULL, (void*)&arg__1};
1499 void* args[2] = {NULL, (void*)&arg__1};
1495 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1500 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1496 if (result) { Py_DECREF(result); }
1501 if (result) { Py_DECREF(result); }
1497 Py_DECREF(obj);
1502 Py_DECREF(obj);
1498 return;
1503 return;
1499 } else {
1504 } else {
1500 PyErr_Clear();
1505 PyErr_Clear();
1501 }
1506 }
1502 }
1507 }
1503 QHexEdit::actionEvent(arg__1);
1508 QHexEdit::actionEvent(arg__1);
1504 }
1509 }
1505 void PythonQtShell_QHexEdit::changeEvent(QEvent* arg__1)
1510 void PythonQtShell_QHexEdit::changeEvent(QEvent* arg__1)
1506 {
1511 {
1507 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1512 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1508 static PyObject* name = PyString_FromString("changeEvent");
1513 static PyObject* name = PyString_FromString("changeEvent");
1509 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1514 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1510 if (obj) {
1515 if (obj) {
1511 static const char* argumentList[] ={"" , "QEvent*"};
1516 static const char* argumentList[] ={"" , "QEvent*"};
1512 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1517 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1513 void* args[2] = {NULL, (void*)&arg__1};
1518 void* args[2] = {NULL, (void*)&arg__1};
1514 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1519 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1515 if (result) { Py_DECREF(result); }
1520 if (result) { Py_DECREF(result); }
1516 Py_DECREF(obj);
1521 Py_DECREF(obj);
1517 return;
1522 return;
1518 } else {
1523 } else {
1519 PyErr_Clear();
1524 PyErr_Clear();
1520 }
1525 }
1521 }
1526 }
1522 QHexEdit::changeEvent(arg__1);
1527 QHexEdit::changeEvent(arg__1);
1523 }
1528 }
1524 void PythonQtShell_QHexEdit::childEvent(QChildEvent* arg__1)
1529 void PythonQtShell_QHexEdit::childEvent(QChildEvent* arg__1)
1525 {
1530 {
1526 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1531 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1527 static PyObject* name = PyString_FromString("childEvent");
1532 static PyObject* name = PyString_FromString("childEvent");
1528 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1533 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1529 if (obj) {
1534 if (obj) {
1530 static const char* argumentList[] ={"" , "QChildEvent*"};
1535 static const char* argumentList[] ={"" , "QChildEvent*"};
1531 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1536 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1532 void* args[2] = {NULL, (void*)&arg__1};
1537 void* args[2] = {NULL, (void*)&arg__1};
1533 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1538 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1534 if (result) { Py_DECREF(result); }
1539 if (result) { Py_DECREF(result); }
1535 Py_DECREF(obj);
1540 Py_DECREF(obj);
1536 return;
1541 return;
1537 } else {
1542 } else {
1538 PyErr_Clear();
1543 PyErr_Clear();
1539 }
1544 }
1540 }
1545 }
1541 QHexEdit::childEvent(arg__1);
1546 QHexEdit::childEvent(arg__1);
1542 }
1547 }
1543 void PythonQtShell_QHexEdit::closeEvent(QCloseEvent* arg__1)
1548 void PythonQtShell_QHexEdit::closeEvent(QCloseEvent* arg__1)
1544 {
1549 {
1545 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1550 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1546 static PyObject* name = PyString_FromString("closeEvent");
1551 static PyObject* name = PyString_FromString("closeEvent");
1547 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1552 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1548 if (obj) {
1553 if (obj) {
1549 static const char* argumentList[] ={"" , "QCloseEvent*"};
1554 static const char* argumentList[] ={"" , "QCloseEvent*"};
1550 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1555 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1551 void* args[2] = {NULL, (void*)&arg__1};
1556 void* args[2] = {NULL, (void*)&arg__1};
1552 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1557 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1553 if (result) { Py_DECREF(result); }
1558 if (result) { Py_DECREF(result); }
1554 Py_DECREF(obj);
1559 Py_DECREF(obj);
1555 return;
1560 return;
1556 } else {
1561 } else {
1557 PyErr_Clear();
1562 PyErr_Clear();
1558 }
1563 }
1559 }
1564 }
1560 QHexEdit::closeEvent(arg__1);
1565 QHexEdit::closeEvent(arg__1);
1561 }
1566 }
1562 void PythonQtShell_QHexEdit::contextMenuEvent(QContextMenuEvent* arg__1)
1567 void PythonQtShell_QHexEdit::contextMenuEvent(QContextMenuEvent* arg__1)
1563 {
1568 {
1564 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1569 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1565 static PyObject* name = PyString_FromString("contextMenuEvent");
1570 static PyObject* name = PyString_FromString("contextMenuEvent");
1566 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1571 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1567 if (obj) {
1572 if (obj) {
1568 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
1573 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
1569 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1574 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1570 void* args[2] = {NULL, (void*)&arg__1};
1575 void* args[2] = {NULL, (void*)&arg__1};
1571 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1576 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1572 if (result) { Py_DECREF(result); }
1577 if (result) { Py_DECREF(result); }
1573 Py_DECREF(obj);
1578 Py_DECREF(obj);
1574 return;
1579 return;
1575 } else {
1580 } else {
1576 PyErr_Clear();
1581 PyErr_Clear();
1577 }
1582 }
1578 }
1583 }
1579 QHexEdit::contextMenuEvent(arg__1);
1584 QHexEdit::contextMenuEvent(arg__1);
1580 }
1585 }
1581 void PythonQtShell_QHexEdit::customEvent(QEvent* arg__1)
1586 void PythonQtShell_QHexEdit::customEvent(QEvent* arg__1)
1582 {
1587 {
1583 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1588 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1584 static PyObject* name = PyString_FromString("customEvent");
1589 static PyObject* name = PyString_FromString("customEvent");
1585 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1590 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1586 if (obj) {
1591 if (obj) {
1587 static const char* argumentList[] ={"" , "QEvent*"};
1592 static const char* argumentList[] ={"" , "QEvent*"};
1588 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1593 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1589 void* args[2] = {NULL, (void*)&arg__1};
1594 void* args[2] = {NULL, (void*)&arg__1};
1590 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1595 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1591 if (result) { Py_DECREF(result); }
1596 if (result) { Py_DECREF(result); }
1592 Py_DECREF(obj);
1597 Py_DECREF(obj);
1593 return;
1598 return;
1594 } else {
1599 } else {
1595 PyErr_Clear();
1600 PyErr_Clear();
1596 }
1601 }
1597 }
1602 }
1598 QHexEdit::customEvent(arg__1);
1603 QHexEdit::customEvent(arg__1);
1599 }
1604 }
1600 int PythonQtShell_QHexEdit::devType() const
1605 int PythonQtShell_QHexEdit::devType() const
1601 {
1606 {
1602 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1607 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1603 static PyObject* name = PyString_FromString("devType");
1608 static PyObject* name = PyString_FromString("devType");
1604 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1609 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1605 if (obj) {
1610 if (obj) {
1606 static const char* argumentList[] ={"int"};
1611 static const char* argumentList[] ={"int"};
1607 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1612 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1608 int returnValue;
1613 int returnValue;
1609 void* args[1] = {NULL};
1614 void* args[1] = {NULL};
1610 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1615 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1611 if (result) {
1616 if (result) {
1612 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1617 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1613 if (args[0]!=&returnValue) {
1618 if (args[0]!=&returnValue) {
1614 if (args[0]==NULL) {
1619 if (args[0]==NULL) {
1615 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
1620 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
1616 } else {
1621 } else {
1617 returnValue = *((int*)args[0]);
1622 returnValue = *((int*)args[0]);
1618 }
1623 }
1619 }
1624 }
1620 }
1625 }
1621 if (result) { Py_DECREF(result); }
1626 if (result) { Py_DECREF(result); }
1622 Py_DECREF(obj);
1627 Py_DECREF(obj);
1623 return returnValue;
1628 return returnValue;
1624 } else {
1629 } else {
1625 PyErr_Clear();
1630 PyErr_Clear();
1626 }
1631 }
1627 }
1632 }
1628 return QHexEdit::devType();
1633 return QHexEdit::devType();
1629 }
1634 }
1630 void PythonQtShell_QHexEdit::dragEnterEvent(QDragEnterEvent* arg__1)
1635 void PythonQtShell_QHexEdit::dragEnterEvent(QDragEnterEvent* arg__1)
1631 {
1636 {
1632 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1637 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1633 static PyObject* name = PyString_FromString("dragEnterEvent");
1638 static PyObject* name = PyString_FromString("dragEnterEvent");
1634 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1639 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1635 if (obj) {
1640 if (obj) {
1636 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
1641 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
1637 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1642 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1638 void* args[2] = {NULL, (void*)&arg__1};
1643 void* args[2] = {NULL, (void*)&arg__1};
1639 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1644 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1640 if (result) { Py_DECREF(result); }
1645 if (result) { Py_DECREF(result); }
1641 Py_DECREF(obj);
1646 Py_DECREF(obj);
1642 return;
1647 return;
1643 } else {
1648 } else {
1644 PyErr_Clear();
1649 PyErr_Clear();
1645 }
1650 }
1646 }
1651 }
1647 QHexEdit::dragEnterEvent(arg__1);
1652 QHexEdit::dragEnterEvent(arg__1);
1648 }
1653 }
1649 void PythonQtShell_QHexEdit::dragLeaveEvent(QDragLeaveEvent* arg__1)
1654 void PythonQtShell_QHexEdit::dragLeaveEvent(QDragLeaveEvent* arg__1)
1650 {
1655 {
1651 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1656 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1652 static PyObject* name = PyString_FromString("dragLeaveEvent");
1657 static PyObject* name = PyString_FromString("dragLeaveEvent");
1653 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1658 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1654 if (obj) {
1659 if (obj) {
1655 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
1660 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
1656 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1661 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1657 void* args[2] = {NULL, (void*)&arg__1};
1662 void* args[2] = {NULL, (void*)&arg__1};
1658 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1663 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1659 if (result) { Py_DECREF(result); }
1664 if (result) { Py_DECREF(result); }
1660 Py_DECREF(obj);
1665 Py_DECREF(obj);
1661 return;
1666 return;
1662 } else {
1667 } else {
1663 PyErr_Clear();
1668 PyErr_Clear();
1664 }
1669 }
1665 }
1670 }
1666 QHexEdit::dragLeaveEvent(arg__1);
1671 QHexEdit::dragLeaveEvent(arg__1);
1667 }
1672 }
1668 void PythonQtShell_QHexEdit::dragMoveEvent(QDragMoveEvent* arg__1)
1673 void PythonQtShell_QHexEdit::dragMoveEvent(QDragMoveEvent* arg__1)
1669 {
1674 {
1670 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1675 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1671 static PyObject* name = PyString_FromString("dragMoveEvent");
1676 static PyObject* name = PyString_FromString("dragMoveEvent");
1672 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1677 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1673 if (obj) {
1678 if (obj) {
1674 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
1679 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
1675 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1680 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1676 void* args[2] = {NULL, (void*)&arg__1};
1681 void* args[2] = {NULL, (void*)&arg__1};
1677 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1682 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1678 if (result) { Py_DECREF(result); }
1683 if (result) { Py_DECREF(result); }
1679 Py_DECREF(obj);
1684 Py_DECREF(obj);
1680 return;
1685 return;
1681 } else {
1686 } else {
1682 PyErr_Clear();
1687 PyErr_Clear();
1683 }
1688 }
1684 }
1689 }
1685 QHexEdit::dragMoveEvent(arg__1);
1690 QHexEdit::dragMoveEvent(arg__1);
1686 }
1691 }
1687 void PythonQtShell_QHexEdit::dropEvent(QDropEvent* arg__1)
1692 void PythonQtShell_QHexEdit::dropEvent(QDropEvent* arg__1)
1688 {
1693 {
1689 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1694 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1690 static PyObject* name = PyString_FromString("dropEvent");
1695 static PyObject* name = PyString_FromString("dropEvent");
1691 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1696 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1692 if (obj) {
1697 if (obj) {
1693 static const char* argumentList[] ={"" , "QDropEvent*"};
1698 static const char* argumentList[] ={"" , "QDropEvent*"};
1694 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1699 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1695 void* args[2] = {NULL, (void*)&arg__1};
1700 void* args[2] = {NULL, (void*)&arg__1};
1696 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1701 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1697 if (result) { Py_DECREF(result); }
1702 if (result) { Py_DECREF(result); }
1698 Py_DECREF(obj);
1703 Py_DECREF(obj);
1699 return;
1704 return;
1700 } else {
1705 } else {
1701 PyErr_Clear();
1706 PyErr_Clear();
1702 }
1707 }
1703 }
1708 }
1704 QHexEdit::dropEvent(arg__1);
1709 QHexEdit::dropEvent(arg__1);
1705 }
1710 }
1706 void PythonQtShell_QHexEdit::enterEvent(QEvent* arg__1)
1711 void PythonQtShell_QHexEdit::enterEvent(QEvent* arg__1)
1707 {
1712 {
1708 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1713 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1709 static PyObject* name = PyString_FromString("enterEvent");
1714 static PyObject* name = PyString_FromString("enterEvent");
1710 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1715 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1711 if (obj) {
1716 if (obj) {
1712 static const char* argumentList[] ={"" , "QEvent*"};
1717 static const char* argumentList[] ={"" , "QEvent*"};
1713 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1718 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1714 void* args[2] = {NULL, (void*)&arg__1};
1719 void* args[2] = {NULL, (void*)&arg__1};
1715 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1720 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1716 if (result) { Py_DECREF(result); }
1721 if (result) { Py_DECREF(result); }
1717 Py_DECREF(obj);
1722 Py_DECREF(obj);
1718 return;
1723 return;
1719 } else {
1724 } else {
1720 PyErr_Clear();
1725 PyErr_Clear();
1721 }
1726 }
1722 }
1727 }
1723 QHexEdit::enterEvent(arg__1);
1728 QHexEdit::enterEvent(arg__1);
1724 }
1729 }
1725 bool PythonQtShell_QHexEdit::event(QEvent* arg__1)
1730 bool PythonQtShell_QHexEdit::event(QEvent* arg__1)
1726 {
1731 {
1727 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1732 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1728 static PyObject* name = PyString_FromString("event");
1733 static PyObject* name = PyString_FromString("event");
1729 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1734 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1730 if (obj) {
1735 if (obj) {
1731 static const char* argumentList[] ={"bool" , "QEvent*"};
1736 static const char* argumentList[] ={"bool" , "QEvent*"};
1732 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1737 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1733 bool returnValue;
1738 bool returnValue;
1734 void* args[2] = {NULL, (void*)&arg__1};
1739 void* args[2] = {NULL, (void*)&arg__1};
1735 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1740 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1736 if (result) {
1741 if (result) {
1737 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1742 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1738 if (args[0]!=&returnValue) {
1743 if (args[0]!=&returnValue) {
1739 if (args[0]==NULL) {
1744 if (args[0]==NULL) {
1740 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
1745 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
1741 } else {
1746 } else {
1742 returnValue = *((bool*)args[0]);
1747 returnValue = *((bool*)args[0]);
1743 }
1748 }
1744 }
1749 }
1745 }
1750 }
1746 if (result) { Py_DECREF(result); }
1751 if (result) { Py_DECREF(result); }
1747 Py_DECREF(obj);
1752 Py_DECREF(obj);
1748 return returnValue;
1753 return returnValue;
1749 } else {
1754 } else {
1750 PyErr_Clear();
1755 PyErr_Clear();
1751 }
1756 }
1752 }
1757 }
1753 return QHexEdit::event(arg__1);
1758 return QHexEdit::event(arg__1);
1754 }
1759 }
1755 bool PythonQtShell_QHexEdit::eventFilter(QObject* arg__1, QEvent* arg__2)
1760 bool PythonQtShell_QHexEdit::eventFilter(QObject* arg__1, QEvent* arg__2)
1756 {
1761 {
1757 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1762 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1758 static PyObject* name = PyString_FromString("eventFilter");
1763 static PyObject* name = PyString_FromString("eventFilter");
1759 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1764 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1760 if (obj) {
1765 if (obj) {
1761 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
1766 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
1762 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
1767 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
1763 bool returnValue;
1768 bool returnValue;
1764 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
1769 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
1765 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1770 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1766 if (result) {
1771 if (result) {
1767 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1772 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1768 if (args[0]!=&returnValue) {
1773 if (args[0]!=&returnValue) {
1769 if (args[0]==NULL) {
1774 if (args[0]==NULL) {
1770 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
1775 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
1771 } else {
1776 } else {
1772 returnValue = *((bool*)args[0]);
1777 returnValue = *((bool*)args[0]);
1773 }
1778 }
1774 }
1779 }
1775 }
1780 }
1776 if (result) { Py_DECREF(result); }
1781 if (result) { Py_DECREF(result); }
1777 Py_DECREF(obj);
1782 Py_DECREF(obj);
1778 return returnValue;
1783 return returnValue;
1779 } else {
1784 } else {
1780 PyErr_Clear();
1785 PyErr_Clear();
1781 }
1786 }
1782 }
1787 }
1783 return QHexEdit::eventFilter(arg__1, arg__2);
1788 return QHexEdit::eventFilter(arg__1, arg__2);
1784 }
1789 }
1785 void PythonQtShell_QHexEdit::focusInEvent(QFocusEvent* arg__1)
1790 void PythonQtShell_QHexEdit::focusInEvent(QFocusEvent* arg__1)
1786 {
1791 {
1787 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1792 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1788 static PyObject* name = PyString_FromString("focusInEvent");
1793 static PyObject* name = PyString_FromString("focusInEvent");
1789 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1794 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1790 if (obj) {
1795 if (obj) {
1791 static const char* argumentList[] ={"" , "QFocusEvent*"};
1796 static const char* argumentList[] ={"" , "QFocusEvent*"};
1792 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1797 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1793 void* args[2] = {NULL, (void*)&arg__1};
1798 void* args[2] = {NULL, (void*)&arg__1};
1794 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1799 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1795 if (result) { Py_DECREF(result); }
1800 if (result) { Py_DECREF(result); }
1796 Py_DECREF(obj);
1801 Py_DECREF(obj);
1797 return;
1802 return;
1798 } else {
1803 } else {
1799 PyErr_Clear();
1804 PyErr_Clear();
1800 }
1805 }
1801 }
1806 }
1802 QHexEdit::focusInEvent(arg__1);
1807 QHexEdit::focusInEvent(arg__1);
1803 }
1808 }
1804 bool PythonQtShell_QHexEdit::focusNextPrevChild(bool next0)
1809 bool PythonQtShell_QHexEdit::focusNextPrevChild(bool next0)
1805 {
1810 {
1806 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1811 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1807 static PyObject* name = PyString_FromString("focusNextPrevChild");
1812 static PyObject* name = PyString_FromString("focusNextPrevChild");
1808 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1813 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1809 if (obj) {
1814 if (obj) {
1810 static const char* argumentList[] ={"bool" , "bool"};
1815 static const char* argumentList[] ={"bool" , "bool"};
1811 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1816 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1812 bool returnValue;
1817 bool returnValue;
1813 void* args[2] = {NULL, (void*)&next0};
1818 void* args[2] = {NULL, (void*)&next0};
1814 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1819 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1815 if (result) {
1820 if (result) {
1816 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1821 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1817 if (args[0]!=&returnValue) {
1822 if (args[0]!=&returnValue) {
1818 if (args[0]==NULL) {
1823 if (args[0]==NULL) {
1819 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
1824 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
1820 } else {
1825 } else {
1821 returnValue = *((bool*)args[0]);
1826 returnValue = *((bool*)args[0]);
1822 }
1827 }
1823 }
1828 }
1824 }
1829 }
1825 if (result) { Py_DECREF(result); }
1830 if (result) { Py_DECREF(result); }
1826 Py_DECREF(obj);
1831 Py_DECREF(obj);
1827 return returnValue;
1832 return returnValue;
1828 } else {
1833 } else {
1829 PyErr_Clear();
1834 PyErr_Clear();
1830 }
1835 }
1831 }
1836 }
1832 return QHexEdit::focusNextPrevChild(next0);
1837 return QHexEdit::focusNextPrevChild(next0);
1833 }
1838 }
1834 void PythonQtShell_QHexEdit::focusOutEvent(QFocusEvent* arg__1)
1839 void PythonQtShell_QHexEdit::focusOutEvent(QFocusEvent* arg__1)
1835 {
1840 {
1836 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1841 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1837 static PyObject* name = PyString_FromString("focusOutEvent");
1842 static PyObject* name = PyString_FromString("focusOutEvent");
1838 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1843 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1839 if (obj) {
1844 if (obj) {
1840 static const char* argumentList[] ={"" , "QFocusEvent*"};
1845 static const char* argumentList[] ={"" , "QFocusEvent*"};
1841 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1846 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1842 void* args[2] = {NULL, (void*)&arg__1};
1847 void* args[2] = {NULL, (void*)&arg__1};
1843 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1848 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1844 if (result) { Py_DECREF(result); }
1849 if (result) { Py_DECREF(result); }
1845 Py_DECREF(obj);
1850 Py_DECREF(obj);
1846 return;
1851 return;
1847 } else {
1852 } else {
1848 PyErr_Clear();
1853 PyErr_Clear();
1849 }
1854 }
1850 }
1855 }
1851 QHexEdit::focusOutEvent(arg__1);
1856 QHexEdit::focusOutEvent(arg__1);
1852 }
1857 }
1853 bool PythonQtShell_QHexEdit::hasHeightForWidth() const
1858 bool PythonQtShell_QHexEdit::hasHeightForWidth() const
1854 {
1859 {
1855 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1860 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1856 static PyObject* name = PyString_FromString("hasHeightForWidth");
1861 static PyObject* name = PyString_FromString("hasHeightForWidth");
1857 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1862 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1858 if (obj) {
1863 if (obj) {
1859 static const char* argumentList[] ={"bool"};
1864 static const char* argumentList[] ={"bool"};
1860 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1865 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1861 bool returnValue;
1866 bool returnValue;
1862 void* args[1] = {NULL};
1867 void* args[1] = {NULL};
1863 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1868 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1864 if (result) {
1869 if (result) {
1865 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1870 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1866 if (args[0]!=&returnValue) {
1871 if (args[0]!=&returnValue) {
1867 if (args[0]==NULL) {
1872 if (args[0]==NULL) {
1868 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
1873 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
1869 } else {
1874 } else {
1870 returnValue = *((bool*)args[0]);
1875 returnValue = *((bool*)args[0]);
1871 }
1876 }
1872 }
1877 }
1873 }
1878 }
1874 if (result) { Py_DECREF(result); }
1879 if (result) { Py_DECREF(result); }
1875 Py_DECREF(obj);
1880 Py_DECREF(obj);
1876 return returnValue;
1881 return returnValue;
1877 } else {
1882 } else {
1878 PyErr_Clear();
1883 PyErr_Clear();
1879 }
1884 }
1880 }
1885 }
1881 return QHexEdit::hasHeightForWidth();
1886 return QHexEdit::hasHeightForWidth();
1882 }
1887 }
1883 int PythonQtShell_QHexEdit::heightForWidth(int arg__1) const
1888 int PythonQtShell_QHexEdit::heightForWidth(int arg__1) const
1884 {
1889 {
1885 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1890 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1886 static PyObject* name = PyString_FromString("heightForWidth");
1891 static PyObject* name = PyString_FromString("heightForWidth");
1887 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1892 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1888 if (obj) {
1893 if (obj) {
1889 static const char* argumentList[] ={"int" , "int"};
1894 static const char* argumentList[] ={"int" , "int"};
1890 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1895 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1891 int returnValue;
1896 int returnValue;
1892 void* args[2] = {NULL, (void*)&arg__1};
1897 void* args[2] = {NULL, (void*)&arg__1};
1893 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1898 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1894 if (result) {
1899 if (result) {
1895 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1900 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1896 if (args[0]!=&returnValue) {
1901 if (args[0]!=&returnValue) {
1897 if (args[0]==NULL) {
1902 if (args[0]==NULL) {
1898 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
1903 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
1899 } else {
1904 } else {
1900 returnValue = *((int*)args[0]);
1905 returnValue = *((int*)args[0]);
1901 }
1906 }
1902 }
1907 }
1903 }
1908 }
1904 if (result) { Py_DECREF(result); }
1909 if (result) { Py_DECREF(result); }
1905 Py_DECREF(obj);
1910 Py_DECREF(obj);
1906 return returnValue;
1911 return returnValue;
1907 } else {
1912 } else {
1908 PyErr_Clear();
1913 PyErr_Clear();
1909 }
1914 }
1910 }
1915 }
1911 return QHexEdit::heightForWidth(arg__1);
1916 return QHexEdit::heightForWidth(arg__1);
1912 }
1917 }
1913 void PythonQtShell_QHexEdit::hideEvent(QHideEvent* arg__1)
1918 void PythonQtShell_QHexEdit::hideEvent(QHideEvent* arg__1)
1914 {
1919 {
1915 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1920 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1916 static PyObject* name = PyString_FromString("hideEvent");
1921 static PyObject* name = PyString_FromString("hideEvent");
1917 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1922 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1918 if (obj) {
1923 if (obj) {
1919 static const char* argumentList[] ={"" , "QHideEvent*"};
1924 static const char* argumentList[] ={"" , "QHideEvent*"};
1920 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1925 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1921 void* args[2] = {NULL, (void*)&arg__1};
1926 void* args[2] = {NULL, (void*)&arg__1};
1922 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1927 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1923 if (result) { Py_DECREF(result); }
1928 if (result) { Py_DECREF(result); }
1924 Py_DECREF(obj);
1929 Py_DECREF(obj);
1925 return;
1930 return;
1926 } else {
1931 } else {
1927 PyErr_Clear();
1932 PyErr_Clear();
1928 }
1933 }
1929 }
1934 }
1930 QHexEdit::hideEvent(arg__1);
1935 QHexEdit::hideEvent(arg__1);
1931 }
1936 }
1932 void PythonQtShell_QHexEdit::initPainter(QPainter* painter0) const
1937 void PythonQtShell_QHexEdit::initPainter(QPainter* painter0) const
1933 {
1938 {
1934 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1939 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1935 static PyObject* name = PyString_FromString("initPainter");
1940 static PyObject* name = PyString_FromString("initPainter");
1936 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1941 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1937 if (obj) {
1942 if (obj) {
1938 static const char* argumentList[] ={"" , "QPainter*"};
1943 static const char* argumentList[] ={"" , "QPainter*"};
1939 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1944 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1940 void* args[2] = {NULL, (void*)&painter0};
1945 void* args[2] = {NULL, (void*)&painter0};
1941 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1946 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1942 if (result) { Py_DECREF(result); }
1947 if (result) { Py_DECREF(result); }
1943 Py_DECREF(obj);
1948 Py_DECREF(obj);
1944 return;
1949 return;
1945 } else {
1950 } else {
1946 PyErr_Clear();
1951 PyErr_Clear();
1947 }
1952 }
1948 }
1953 }
1949 QHexEdit::initPainter(painter0);
1954 QHexEdit::initPainter(painter0);
1950 }
1955 }
1951 void PythonQtShell_QHexEdit::inputMethodEvent(QInputMethodEvent* arg__1)
1956 void PythonQtShell_QHexEdit::inputMethodEvent(QInputMethodEvent* arg__1)
1952 {
1957 {
1953 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1958 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1954 static PyObject* name = PyString_FromString("inputMethodEvent");
1959 static PyObject* name = PyString_FromString("inputMethodEvent");
1955 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1960 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1956 if (obj) {
1961 if (obj) {
1957 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
1962 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
1958 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1963 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1959 void* args[2] = {NULL, (void*)&arg__1};
1964 void* args[2] = {NULL, (void*)&arg__1};
1960 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1965 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1961 if (result) { Py_DECREF(result); }
1966 if (result) { Py_DECREF(result); }
1962 Py_DECREF(obj);
1967 Py_DECREF(obj);
1963 return;
1968 return;
1964 } else {
1969 } else {
1965 PyErr_Clear();
1970 PyErr_Clear();
1966 }
1971 }
1967 }
1972 }
1968 QHexEdit::inputMethodEvent(arg__1);
1973 QHexEdit::inputMethodEvent(arg__1);
1969 }
1974 }
1970 QVariant PythonQtShell_QHexEdit::inputMethodQuery(Qt::InputMethodQuery arg__1) const
1975 QVariant PythonQtShell_QHexEdit::inputMethodQuery(Qt::InputMethodQuery arg__1) const
1971 {
1976 {
1972 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1977 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
1973 static PyObject* name = PyString_FromString("inputMethodQuery");
1978 static PyObject* name = PyString_FromString("inputMethodQuery");
1974 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1979 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
1975 if (obj) {
1980 if (obj) {
1976 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
1981 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
1977 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1982 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1978 QVariant returnValue;
1983 QVariant returnValue;
1979 void* args[2] = {NULL, (void*)&arg__1};
1984 void* args[2] = {NULL, (void*)&arg__1};
1980 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1985 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1981 if (result) {
1986 if (result) {
1982 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1987 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1983 if (args[0]!=&returnValue) {
1988 if (args[0]!=&returnValue) {
1984 if (args[0]==NULL) {
1989 if (args[0]==NULL) {
1985 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
1990 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
1986 } else {
1991 } else {
1987 returnValue = *((QVariant*)args[0]);
1992 returnValue = *((QVariant*)args[0]);
1988 }
1993 }
1989 }
1994 }
1990 }
1995 }
1991 if (result) { Py_DECREF(result); }
1996 if (result) { Py_DECREF(result); }
1992 Py_DECREF(obj);
1997 Py_DECREF(obj);
1993 return returnValue;
1998 return returnValue;
1994 } else {
1999 } else {
1995 PyErr_Clear();
2000 PyErr_Clear();
1996 }
2001 }
1997 }
2002 }
1998 return QHexEdit::inputMethodQuery(arg__1);
2003 return QHexEdit::inputMethodQuery(arg__1);
1999 }
2004 }
2000 void PythonQtShell_QHexEdit::keyPressEvent(QKeyEvent* arg__1)
2005 void PythonQtShell_QHexEdit::keyPressEvent(QKeyEvent* arg__1)
2001 {
2006 {
2002 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2007 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2003 static PyObject* name = PyString_FromString("keyPressEvent");
2008 static PyObject* name = PyString_FromString("keyPressEvent");
2004 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2009 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2005 if (obj) {
2010 if (obj) {
2006 static const char* argumentList[] ={"" , "QKeyEvent*"};
2011 static const char* argumentList[] ={"" , "QKeyEvent*"};
2007 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2012 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2008 void* args[2] = {NULL, (void*)&arg__1};
2013 void* args[2] = {NULL, (void*)&arg__1};
2009 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2014 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2010 if (result) { Py_DECREF(result); }
2015 if (result) { Py_DECREF(result); }
2011 Py_DECREF(obj);
2016 Py_DECREF(obj);
2012 return;
2017 return;
2013 } else {
2018 } else {
2014 PyErr_Clear();
2019 PyErr_Clear();
2015 }
2020 }
2016 }
2021 }
2017 QHexEdit::keyPressEvent(arg__1);
2022 QHexEdit::keyPressEvent(arg__1);
2018 }
2023 }
2019 void PythonQtShell_QHexEdit::keyReleaseEvent(QKeyEvent* arg__1)
2024 void PythonQtShell_QHexEdit::keyReleaseEvent(QKeyEvent* arg__1)
2020 {
2025 {
2021 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2026 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2022 static PyObject* name = PyString_FromString("keyReleaseEvent");
2027 static PyObject* name = PyString_FromString("keyReleaseEvent");
2023 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2028 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2024 if (obj) {
2029 if (obj) {
2025 static const char* argumentList[] ={"" , "QKeyEvent*"};
2030 static const char* argumentList[] ={"" , "QKeyEvent*"};
2026 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2031 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2027 void* args[2] = {NULL, (void*)&arg__1};
2032 void* args[2] = {NULL, (void*)&arg__1};
2028 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2033 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2029 if (result) { Py_DECREF(result); }
2034 if (result) { Py_DECREF(result); }
2030 Py_DECREF(obj);
2035 Py_DECREF(obj);
2031 return;
2036 return;
2032 } else {
2037 } else {
2033 PyErr_Clear();
2038 PyErr_Clear();
2034 }
2039 }
2035 }
2040 }
2036 QHexEdit::keyReleaseEvent(arg__1);
2041 QHexEdit::keyReleaseEvent(arg__1);
2037 }
2042 }
2038 void PythonQtShell_QHexEdit::leaveEvent(QEvent* arg__1)
2043 void PythonQtShell_QHexEdit::leaveEvent(QEvent* arg__1)
2039 {
2044 {
2040 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2045 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2041 static PyObject* name = PyString_FromString("leaveEvent");
2046 static PyObject* name = PyString_FromString("leaveEvent");
2042 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2047 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2043 if (obj) {
2048 if (obj) {
2044 static const char* argumentList[] ={"" , "QEvent*"};
2049 static const char* argumentList[] ={"" , "QEvent*"};
2045 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2050 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2046 void* args[2] = {NULL, (void*)&arg__1};
2051 void* args[2] = {NULL, (void*)&arg__1};
2047 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2052 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2048 if (result) { Py_DECREF(result); }
2053 if (result) { Py_DECREF(result); }
2049 Py_DECREF(obj);
2054 Py_DECREF(obj);
2050 return;
2055 return;
2051 } else {
2056 } else {
2052 PyErr_Clear();
2057 PyErr_Clear();
2053 }
2058 }
2054 }
2059 }
2055 QHexEdit::leaveEvent(arg__1);
2060 QHexEdit::leaveEvent(arg__1);
2056 }
2061 }
2057 int PythonQtShell_QHexEdit::metric(QPaintDevice::PaintDeviceMetric arg__1) const
2062 int PythonQtShell_QHexEdit::metric(QPaintDevice::PaintDeviceMetric arg__1) const
2058 {
2063 {
2059 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2064 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2060 static PyObject* name = PyString_FromString("metric");
2065 static PyObject* name = PyString_FromString("metric");
2061 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2066 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2062 if (obj) {
2067 if (obj) {
2063 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
2068 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
2064 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2069 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2065 int returnValue;
2070 int returnValue;
2066 void* args[2] = {NULL, (void*)&arg__1};
2071 void* args[2] = {NULL, (void*)&arg__1};
2067 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2072 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2068 if (result) {
2073 if (result) {
2069 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2074 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2070 if (args[0]!=&returnValue) {
2075 if (args[0]!=&returnValue) {
2071 if (args[0]==NULL) {
2076 if (args[0]==NULL) {
2072 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
2077 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
2073 } else {
2078 } else {
2074 returnValue = *((int*)args[0]);
2079 returnValue = *((int*)args[0]);
2075 }
2080 }
2076 }
2081 }
2077 }
2082 }
2078 if (result) { Py_DECREF(result); }
2083 if (result) { Py_DECREF(result); }
2079 Py_DECREF(obj);
2084 Py_DECREF(obj);
2080 return returnValue;
2085 return returnValue;
2081 } else {
2086 } else {
2082 PyErr_Clear();
2087 PyErr_Clear();
2083 }
2088 }
2084 }
2089 }
2085 return QHexEdit::metric(arg__1);
2090 return QHexEdit::metric(arg__1);
2086 }
2091 }
2087 void PythonQtShell_QHexEdit::mouseDoubleClickEvent(QMouseEvent* arg__1)
2092 void PythonQtShell_QHexEdit::mouseDoubleClickEvent(QMouseEvent* arg__1)
2088 {
2093 {
2089 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2094 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2090 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
2095 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
2091 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2096 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2092 if (obj) {
2097 if (obj) {
2093 static const char* argumentList[] ={"" , "QMouseEvent*"};
2098 static const char* argumentList[] ={"" , "QMouseEvent*"};
2094 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2099 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2095 void* args[2] = {NULL, (void*)&arg__1};
2100 void* args[2] = {NULL, (void*)&arg__1};
2096 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2101 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2097 if (result) { Py_DECREF(result); }
2102 if (result) { Py_DECREF(result); }
2098 Py_DECREF(obj);
2103 Py_DECREF(obj);
2099 return;
2104 return;
2100 } else {
2105 } else {
2101 PyErr_Clear();
2106 PyErr_Clear();
2102 }
2107 }
2103 }
2108 }
2104 QHexEdit::mouseDoubleClickEvent(arg__1);
2109 QHexEdit::mouseDoubleClickEvent(arg__1);
2105 }
2110 }
2106 void PythonQtShell_QHexEdit::mouseMoveEvent(QMouseEvent* arg__1)
2111 void PythonQtShell_QHexEdit::mouseMoveEvent(QMouseEvent* arg__1)
2107 {
2112 {
2108 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2113 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2109 static PyObject* name = PyString_FromString("mouseMoveEvent");
2114 static PyObject* name = PyString_FromString("mouseMoveEvent");
2110 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2115 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2111 if (obj) {
2116 if (obj) {
2112 static const char* argumentList[] ={"" , "QMouseEvent*"};
2117 static const char* argumentList[] ={"" , "QMouseEvent*"};
2113 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2118 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2114 void* args[2] = {NULL, (void*)&arg__1};
2119 void* args[2] = {NULL, (void*)&arg__1};
2115 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2120 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2116 if (result) { Py_DECREF(result); }
2121 if (result) { Py_DECREF(result); }
2117 Py_DECREF(obj);
2122 Py_DECREF(obj);
2118 return;
2123 return;
2119 } else {
2124 } else {
2120 PyErr_Clear();
2125 PyErr_Clear();
2121 }
2126 }
2122 }
2127 }
2123 QHexEdit::mouseMoveEvent(arg__1);
2128 QHexEdit::mouseMoveEvent(arg__1);
2124 }
2129 }
2125 void PythonQtShell_QHexEdit::mousePressEvent(QMouseEvent* arg__1)
2130 void PythonQtShell_QHexEdit::mousePressEvent(QMouseEvent* arg__1)
2126 {
2131 {
2127 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2132 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2128 static PyObject* name = PyString_FromString("mousePressEvent");
2133 static PyObject* name = PyString_FromString("mousePressEvent");
2129 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2134 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2130 if (obj) {
2135 if (obj) {
2131 static const char* argumentList[] ={"" , "QMouseEvent*"};
2136 static const char* argumentList[] ={"" , "QMouseEvent*"};
2132 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2137 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2133 void* args[2] = {NULL, (void*)&arg__1};
2138 void* args[2] = {NULL, (void*)&arg__1};
2134 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2139 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2135 if (result) { Py_DECREF(result); }
2140 if (result) { Py_DECREF(result); }
2136 Py_DECREF(obj);
2141 Py_DECREF(obj);
2137 return;
2142 return;
2138 } else {
2143 } else {
2139 PyErr_Clear();
2144 PyErr_Clear();
2140 }
2145 }
2141 }
2146 }
2142 QHexEdit::mousePressEvent(arg__1);
2147 QHexEdit::mousePressEvent(arg__1);
2143 }
2148 }
2144 void PythonQtShell_QHexEdit::mouseReleaseEvent(QMouseEvent* arg__1)
2149 void PythonQtShell_QHexEdit::mouseReleaseEvent(QMouseEvent* arg__1)
2145 {
2150 {
2146 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2151 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2147 static PyObject* name = PyString_FromString("mouseReleaseEvent");
2152 static PyObject* name = PyString_FromString("mouseReleaseEvent");
2148 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2153 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2149 if (obj) {
2154 if (obj) {
2150 static const char* argumentList[] ={"" , "QMouseEvent*"};
2155 static const char* argumentList[] ={"" , "QMouseEvent*"};
2151 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2156 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2152 void* args[2] = {NULL, (void*)&arg__1};
2157 void* args[2] = {NULL, (void*)&arg__1};
2153 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2158 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2154 if (result) { Py_DECREF(result); }
2159 if (result) { Py_DECREF(result); }
2155 Py_DECREF(obj);
2160 Py_DECREF(obj);
2156 return;
2161 return;
2157 } else {
2162 } else {
2158 PyErr_Clear();
2163 PyErr_Clear();
2159 }
2164 }
2160 }
2165 }
2161 QHexEdit::mouseReleaseEvent(arg__1);
2166 QHexEdit::mouseReleaseEvent(arg__1);
2162 }
2167 }
2163 void PythonQtShell_QHexEdit::moveEvent(QMoveEvent* arg__1)
2168 void PythonQtShell_QHexEdit::moveEvent(QMoveEvent* arg__1)
2164 {
2169 {
2165 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2170 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2166 static PyObject* name = PyString_FromString("moveEvent");
2171 static PyObject* name = PyString_FromString("moveEvent");
2167 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2172 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2168 if (obj) {
2173 if (obj) {
2169 static const char* argumentList[] ={"" , "QMoveEvent*"};
2174 static const char* argumentList[] ={"" , "QMoveEvent*"};
2170 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2175 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2171 void* args[2] = {NULL, (void*)&arg__1};
2176 void* args[2] = {NULL, (void*)&arg__1};
2172 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2177 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2173 if (result) { Py_DECREF(result); }
2178 if (result) { Py_DECREF(result); }
2174 Py_DECREF(obj);
2179 Py_DECREF(obj);
2175 return;
2180 return;
2176 } else {
2181 } else {
2177 PyErr_Clear();
2182 PyErr_Clear();
2178 }
2183 }
2179 }
2184 }
2180 QHexEdit::moveEvent(arg__1);
2185 QHexEdit::moveEvent(arg__1);
2181 }
2186 }
2182 bool PythonQtShell_QHexEdit::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
2187 bool PythonQtShell_QHexEdit::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
2183 {
2188 {
2184 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2189 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2185 static PyObject* name = PyString_FromString("nativeEvent");
2190 static PyObject* name = PyString_FromString("nativeEvent");
2186 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2191 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2187 if (obj) {
2192 if (obj) {
2188 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
2193 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
2189 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
2194 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
2190 bool returnValue;
2195 bool returnValue;
2191 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
2196 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
2192 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2197 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2193 if (result) {
2198 if (result) {
2194 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2199 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2195 if (args[0]!=&returnValue) {
2200 if (args[0]!=&returnValue) {
2196 if (args[0]==NULL) {
2201 if (args[0]==NULL) {
2197 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
2202 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
2198 } else {
2203 } else {
2199 returnValue = *((bool*)args[0]);
2204 returnValue = *((bool*)args[0]);
2200 }
2205 }
2201 }
2206 }
2202 }
2207 }
2203 if (result) { Py_DECREF(result); }
2208 if (result) { Py_DECREF(result); }
2204 Py_DECREF(obj);
2209 Py_DECREF(obj);
2205 return returnValue;
2210 return returnValue;
2206 } else {
2211 } else {
2207 PyErr_Clear();
2212 PyErr_Clear();
2208 }
2213 }
2209 }
2214 }
2210 return QHexEdit::nativeEvent(eventType0, message1, result2);
2215 return QHexEdit::nativeEvent(eventType0, message1, result2);
2211 }
2216 }
2212 QPaintEngine* PythonQtShell_QHexEdit::paintEngine() const
2217 QPaintEngine* PythonQtShell_QHexEdit::paintEngine() const
2213 {
2218 {
2214 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2219 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2215 static PyObject* name = PyString_FromString("paintEngine");
2220 static PyObject* name = PyString_FromString("paintEngine");
2216 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2221 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2217 if (obj) {
2222 if (obj) {
2218 static const char* argumentList[] ={"QPaintEngine*"};
2223 static const char* argumentList[] ={"QPaintEngine*"};
2219 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2224 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2220 QPaintEngine* returnValue;
2225 QPaintEngine* returnValue;
2221 void* args[1] = {NULL};
2226 void* args[1] = {NULL};
2222 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2227 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2223 if (result) {
2228 if (result) {
2224 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2229 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2225 if (args[0]!=&returnValue) {
2230 if (args[0]!=&returnValue) {
2226 if (args[0]==NULL) {
2231 if (args[0]==NULL) {
2227 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
2232 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
2228 } else {
2233 } else {
2229 returnValue = *((QPaintEngine**)args[0]);
2234 returnValue = *((QPaintEngine**)args[0]);
2230 }
2235 }
2231 }
2236 }
2232 }
2237 }
2233 if (result) { Py_DECREF(result); }
2238 if (result) { Py_DECREF(result); }
2234 Py_DECREF(obj);
2239 Py_DECREF(obj);
2235 return returnValue;
2240 return returnValue;
2236 } else {
2241 } else {
2237 PyErr_Clear();
2242 PyErr_Clear();
2238 }
2243 }
2239 }
2244 }
2240 return QHexEdit::paintEngine();
2245 return QHexEdit::paintEngine();
2241 }
2246 }
2242 void PythonQtShell_QHexEdit::paintEvent(QPaintEvent* arg__1)
2247 void PythonQtShell_QHexEdit::paintEvent(QPaintEvent* arg__1)
2243 {
2248 {
2244 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2249 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2245 static PyObject* name = PyString_FromString("paintEvent");
2250 static PyObject* name = PyString_FromString("paintEvent");
2246 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2251 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2247 if (obj) {
2252 if (obj) {
2248 static const char* argumentList[] ={"" , "QPaintEvent*"};
2253 static const char* argumentList[] ={"" , "QPaintEvent*"};
2249 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2254 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2250 void* args[2] = {NULL, (void*)&arg__1};
2255 void* args[2] = {NULL, (void*)&arg__1};
2251 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2256 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2252 if (result) { Py_DECREF(result); }
2257 if (result) { Py_DECREF(result); }
2253 Py_DECREF(obj);
2258 Py_DECREF(obj);
2254 return;
2259 return;
2255 } else {
2260 } else {
2256 PyErr_Clear();
2261 PyErr_Clear();
2257 }
2262 }
2258 }
2263 }
2259 QHexEdit::paintEvent(arg__1);
2264 QHexEdit::paintEvent(arg__1);
2260 }
2265 }
2261 QPaintDevice* PythonQtShell_QHexEdit::redirected(QPoint* offset0) const
2266 QPaintDevice* PythonQtShell_QHexEdit::redirected(QPoint* offset0) const
2262 {
2267 {
2263 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2268 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2264 static PyObject* name = PyString_FromString("redirected");
2269 static PyObject* name = PyString_FromString("redirected");
2265 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2270 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2266 if (obj) {
2271 if (obj) {
2267 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
2272 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
2268 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2273 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2269 QPaintDevice* returnValue;
2274 QPaintDevice* returnValue;
2270 void* args[2] = {NULL, (void*)&offset0};
2275 void* args[2] = {NULL, (void*)&offset0};
2271 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2276 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2272 if (result) {
2277 if (result) {
2273 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2278 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2274 if (args[0]!=&returnValue) {
2279 if (args[0]!=&returnValue) {
2275 if (args[0]==NULL) {
2280 if (args[0]==NULL) {
2276 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
2281 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
2277 } else {
2282 } else {
2278 returnValue = *((QPaintDevice**)args[0]);
2283 returnValue = *((QPaintDevice**)args[0]);
2279 }
2284 }
2280 }
2285 }
2281 }
2286 }
2282 if (result) { Py_DECREF(result); }
2287 if (result) { Py_DECREF(result); }
2283 Py_DECREF(obj);
2288 Py_DECREF(obj);
2284 return returnValue;
2289 return returnValue;
2285 } else {
2290 } else {
2286 PyErr_Clear();
2291 PyErr_Clear();
2287 }
2292 }
2288 }
2293 }
2289 return QHexEdit::redirected(offset0);
2294 return QHexEdit::redirected(offset0);
2290 }
2295 }
2291 void PythonQtShell_QHexEdit::resizeEvent(QResizeEvent* arg__1)
2296 void PythonQtShell_QHexEdit::resizeEvent(QResizeEvent* arg__1)
2292 {
2297 {
2293 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2298 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2294 static PyObject* name = PyString_FromString("resizeEvent");
2299 static PyObject* name = PyString_FromString("resizeEvent");
2295 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2300 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2296 if (obj) {
2301 if (obj) {
2297 static const char* argumentList[] ={"" , "QResizeEvent*"};
2302 static const char* argumentList[] ={"" , "QResizeEvent*"};
2298 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2303 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2299 void* args[2] = {NULL, (void*)&arg__1};
2304 void* args[2] = {NULL, (void*)&arg__1};
2300 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2305 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2301 if (result) { Py_DECREF(result); }
2306 if (result) { Py_DECREF(result); }
2302 Py_DECREF(obj);
2307 Py_DECREF(obj);
2303 return;
2308 return;
2304 } else {
2309 } else {
2305 PyErr_Clear();
2310 PyErr_Clear();
2306 }
2311 }
2307 }
2312 }
2308 QHexEdit::resizeEvent(arg__1);
2313 QHexEdit::resizeEvent(arg__1);
2309 }
2314 }
2310 void PythonQtShell_QHexEdit::scrollContentsBy(int dx0, int dy1)
2315 void PythonQtShell_QHexEdit::scrollContentsBy(int dx0, int dy1)
2311 {
2316 {
2312 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2317 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2313 static PyObject* name = PyString_FromString("scrollContentsBy");
2318 static PyObject* name = PyString_FromString("scrollContentsBy");
2314 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2319 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2315 if (obj) {
2320 if (obj) {
2316 static const char* argumentList[] ={"" , "int" , "int"};
2321 static const char* argumentList[] ={"" , "int" , "int"};
2317 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2322 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2318 void* args[3] = {NULL, (void*)&dx0, (void*)&dy1};
2323 void* args[3] = {NULL, (void*)&dx0, (void*)&dy1};
2319 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2324 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2320 if (result) { Py_DECREF(result); }
2325 if (result) { Py_DECREF(result); }
2321 Py_DECREF(obj);
2326 Py_DECREF(obj);
2322 return;
2327 return;
2323 } else {
2328 } else {
2324 PyErr_Clear();
2329 PyErr_Clear();
2325 }
2330 }
2326 }
2331 }
2327 QHexEdit::scrollContentsBy(dx0, dy1);
2332 QHexEdit::scrollContentsBy(dx0, dy1);
2328 }
2333 }
2329 void PythonQtShell_QHexEdit::setupViewport(QWidget* viewport0)
2334 void PythonQtShell_QHexEdit::setupViewport(QWidget* viewport0)
2330 {
2335 {
2331 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2336 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2332 static PyObject* name = PyString_FromString("setupViewport");
2337 static PyObject* name = PyString_FromString("setupViewport");
2333 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2338 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2334 if (obj) {
2339 if (obj) {
2335 static const char* argumentList[] ={"" , "QWidget*"};
2340 static const char* argumentList[] ={"" , "QWidget*"};
2336 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2341 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2337 void* args[2] = {NULL, (void*)&viewport0};
2342 void* args[2] = {NULL, (void*)&viewport0};
2338 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2343 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2339 if (result) { Py_DECREF(result); }
2344 if (result) { Py_DECREF(result); }
2340 Py_DECREF(obj);
2345 Py_DECREF(obj);
2341 return;
2346 return;
2342 } else {
2347 } else {
2343 PyErr_Clear();
2348 PyErr_Clear();
2344 }
2349 }
2345 }
2350 }
2346 QHexEdit::setupViewport(viewport0);
2351 QHexEdit::setupViewport(viewport0);
2347 }
2352 }
2348 QPainter* PythonQtShell_QHexEdit::sharedPainter() const
2353 QPainter* PythonQtShell_QHexEdit::sharedPainter() const
2349 {
2354 {
2350 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2355 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2351 static PyObject* name = PyString_FromString("sharedPainter");
2356 static PyObject* name = PyString_FromString("sharedPainter");
2352 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2357 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2353 if (obj) {
2358 if (obj) {
2354 static const char* argumentList[] ={"QPainter*"};
2359 static const char* argumentList[] ={"QPainter*"};
2355 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2360 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2356 QPainter* returnValue;
2361 QPainter* returnValue;
2357 void* args[1] = {NULL};
2362 void* args[1] = {NULL};
2358 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2363 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2359 if (result) {
2364 if (result) {
2360 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2365 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2361 if (args[0]!=&returnValue) {
2366 if (args[0]!=&returnValue) {
2362 if (args[0]==NULL) {
2367 if (args[0]==NULL) {
2363 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
2368 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
2364 } else {
2369 } else {
2365 returnValue = *((QPainter**)args[0]);
2370 returnValue = *((QPainter**)args[0]);
2366 }
2371 }
2367 }
2372 }
2368 }
2373 }
2369 if (result) { Py_DECREF(result); }
2374 if (result) { Py_DECREF(result); }
2370 Py_DECREF(obj);
2375 Py_DECREF(obj);
2371 return returnValue;
2376 return returnValue;
2372 } else {
2377 } else {
2373 PyErr_Clear();
2378 PyErr_Clear();
2374 }
2379 }
2375 }
2380 }
2376 return QHexEdit::sharedPainter();
2381 return QHexEdit::sharedPainter();
2377 }
2382 }
2378 void PythonQtShell_QHexEdit::showEvent(QShowEvent* arg__1)
2383 void PythonQtShell_QHexEdit::showEvent(QShowEvent* arg__1)
2379 {
2384 {
2380 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2385 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2381 static PyObject* name = PyString_FromString("showEvent");
2386 static PyObject* name = PyString_FromString("showEvent");
2382 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2387 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2383 if (obj) {
2388 if (obj) {
2384 static const char* argumentList[] ={"" , "QShowEvent*"};
2389 static const char* argumentList[] ={"" , "QShowEvent*"};
2385 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2390 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2386 void* args[2] = {NULL, (void*)&arg__1};
2391 void* args[2] = {NULL, (void*)&arg__1};
2387 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2392 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2388 if (result) { Py_DECREF(result); }
2393 if (result) { Py_DECREF(result); }
2389 Py_DECREF(obj);
2394 Py_DECREF(obj);
2390 return;
2395 return;
2391 } else {
2396 } else {
2392 PyErr_Clear();
2397 PyErr_Clear();
2393 }
2398 }
2394 }
2399 }
2395 QHexEdit::showEvent(arg__1);
2400 QHexEdit::showEvent(arg__1);
2396 }
2401 }
2397 void PythonQtShell_QHexEdit::tabletEvent(QTabletEvent* arg__1)
2402 void PythonQtShell_QHexEdit::tabletEvent(QTabletEvent* arg__1)
2398 {
2403 {
2399 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2404 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2400 static PyObject* name = PyString_FromString("tabletEvent");
2405 static PyObject* name = PyString_FromString("tabletEvent");
2401 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2406 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2402 if (obj) {
2407 if (obj) {
2403 static const char* argumentList[] ={"" , "QTabletEvent*"};
2408 static const char* argumentList[] ={"" , "QTabletEvent*"};
2404 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2409 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2405 void* args[2] = {NULL, (void*)&arg__1};
2410 void* args[2] = {NULL, (void*)&arg__1};
2406 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2411 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2407 if (result) { Py_DECREF(result); }
2412 if (result) { Py_DECREF(result); }
2408 Py_DECREF(obj);
2413 Py_DECREF(obj);
2409 return;
2414 return;
2410 } else {
2415 } else {
2411 PyErr_Clear();
2416 PyErr_Clear();
2412 }
2417 }
2413 }
2418 }
2414 QHexEdit::tabletEvent(arg__1);
2419 QHexEdit::tabletEvent(arg__1);
2415 }
2420 }
2416 void PythonQtShell_QHexEdit::timerEvent(QTimerEvent* arg__1)
2421 void PythonQtShell_QHexEdit::timerEvent(QTimerEvent* arg__1)
2417 {
2422 {
2418 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2423 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2419 static PyObject* name = PyString_FromString("timerEvent");
2424 static PyObject* name = PyString_FromString("timerEvent");
2420 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2425 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2421 if (obj) {
2426 if (obj) {
2422 static const char* argumentList[] ={"" , "QTimerEvent*"};
2427 static const char* argumentList[] ={"" , "QTimerEvent*"};
2423 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2428 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2424 void* args[2] = {NULL, (void*)&arg__1};
2429 void* args[2] = {NULL, (void*)&arg__1};
2425 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2430 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2426 if (result) { Py_DECREF(result); }
2431 if (result) { Py_DECREF(result); }
2427 Py_DECREF(obj);
2432 Py_DECREF(obj);
2428 return;
2433 return;
2429 } else {
2434 } else {
2430 PyErr_Clear();
2435 PyErr_Clear();
2431 }
2436 }
2432 }
2437 }
2433 QHexEdit::timerEvent(arg__1);
2438 QHexEdit::timerEvent(arg__1);
2434 }
2439 }
2435 bool PythonQtShell_QHexEdit::viewportEvent(QEvent* arg__1)
2440 bool PythonQtShell_QHexEdit::viewportEvent(QEvent* arg__1)
2436 {
2441 {
2437 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2442 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2438 static PyObject* name = PyString_FromString("viewportEvent");
2443 static PyObject* name = PyString_FromString("viewportEvent");
2439 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2444 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2440 if (obj) {
2445 if (obj) {
2441 static const char* argumentList[] ={"bool" , "QEvent*"};
2446 static const char* argumentList[] ={"bool" , "QEvent*"};
2442 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2447 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2443 bool returnValue;
2448 bool returnValue;
2444 void* args[2] = {NULL, (void*)&arg__1};
2449 void* args[2] = {NULL, (void*)&arg__1};
2445 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2450 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2446 if (result) {
2451 if (result) {
2447 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2452 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2448 if (args[0]!=&returnValue) {
2453 if (args[0]!=&returnValue) {
2449 if (args[0]==NULL) {
2454 if (args[0]==NULL) {
2450 PythonQt::priv()->handleVirtualOverloadReturnError("viewportEvent", methodInfo, result);
2455 PythonQt::priv()->handleVirtualOverloadReturnError("viewportEvent", methodInfo, result);
2451 } else {
2456 } else {
2452 returnValue = *((bool*)args[0]);
2457 returnValue = *((bool*)args[0]);
2453 }
2458 }
2454 }
2459 }
2455 }
2460 }
2456 if (result) { Py_DECREF(result); }
2461 if (result) { Py_DECREF(result); }
2457 Py_DECREF(obj);
2462 Py_DECREF(obj);
2458 return returnValue;
2463 return returnValue;
2459 } else {
2464 } else {
2460 PyErr_Clear();
2465 PyErr_Clear();
2461 }
2466 }
2462 }
2467 }
2463 return QHexEdit::viewportEvent(arg__1);
2468 return QHexEdit::viewportEvent(arg__1);
2464 }
2469 }
2465 QSize PythonQtShell_QHexEdit::viewportSizeHint() const
2470 QSize PythonQtShell_QHexEdit::viewportSizeHint() const
2466 {
2471 {
2467 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2472 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2468 static PyObject* name = PyString_FromString("viewportSizeHint");
2473 static PyObject* name = PyString_FromString("viewportSizeHint");
2469 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2474 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2470 if (obj) {
2475 if (obj) {
2471 static const char* argumentList[] ={"QSize"};
2476 static const char* argumentList[] ={"QSize"};
2472 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2477 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2473 QSize returnValue;
2478 QSize returnValue;
2474 void* args[1] = {NULL};
2479 void* args[1] = {NULL};
2475 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2480 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2476 if (result) {
2481 if (result) {
2477 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2482 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2478 if (args[0]!=&returnValue) {
2483 if (args[0]!=&returnValue) {
2479 if (args[0]==NULL) {
2484 if (args[0]==NULL) {
2480 PythonQt::priv()->handleVirtualOverloadReturnError("viewportSizeHint", methodInfo, result);
2485 PythonQt::priv()->handleVirtualOverloadReturnError("viewportSizeHint", methodInfo, result);
2481 } else {
2486 } else {
2482 returnValue = *((QSize*)args[0]);
2487 returnValue = *((QSize*)args[0]);
2483 }
2488 }
2484 }
2489 }
2485 }
2490 }
2486 if (result) { Py_DECREF(result); }
2491 if (result) { Py_DECREF(result); }
2487 Py_DECREF(obj);
2492 Py_DECREF(obj);
2488 return returnValue;
2493 return returnValue;
2489 } else {
2494 } else {
2490 PyErr_Clear();
2495 PyErr_Clear();
2491 }
2496 }
2492 }
2497 }
2493 return QHexEdit::viewportSizeHint();
2498 return QHexEdit::viewportSizeHint();
2494 }
2499 }
2495 void PythonQtShell_QHexEdit::wheelEvent(QWheelEvent* arg__1)
2500 void PythonQtShell_QHexEdit::wheelEvent(QWheelEvent* arg__1)
2496 {
2501 {
2497 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2502 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2498 static PyObject* name = PyString_FromString("wheelEvent");
2503 static PyObject* name = PyString_FromString("wheelEvent");
2499 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2504 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2500 if (obj) {
2505 if (obj) {
2501 static const char* argumentList[] ={"" , "QWheelEvent*"};
2506 static const char* argumentList[] ={"" , "QWheelEvent*"};
2502 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2507 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2503 void* args[2] = {NULL, (void*)&arg__1};
2508 void* args[2] = {NULL, (void*)&arg__1};
2504 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2509 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2505 if (result) { Py_DECREF(result); }
2510 if (result) { Py_DECREF(result); }
2506 Py_DECREF(obj);
2511 Py_DECREF(obj);
2507 return;
2512 return;
2508 } else {
2513 } else {
2509 PyErr_Clear();
2514 PyErr_Clear();
2510 }
2515 }
2511 }
2516 }
2512 QHexEdit::wheelEvent(arg__1);
2517 QHexEdit::wheelEvent(arg__1);
2513 }
2518 }
2514 QHexEdit* PythonQtWrapper_QHexEdit::new_QHexEdit(QWidget* parent)
2519 QHexEdit* PythonQtWrapper_QHexEdit::new_QHexEdit(QWidget* parent)
2515 {
2520 {
2516 return new PythonQtShell_QHexEdit(parent); }
2521 return new PythonQtShell_QHexEdit(parent); }
2517
2522
2518 QColor PythonQtWrapper_QHexEdit::addressAreaColor(QHexEdit* theWrappedObject)
2523 QColor PythonQtWrapper_QHexEdit::addressAreaColor(QHexEdit* theWrappedObject)
2519 {
2524 {
2520 return ( theWrappedObject->addressAreaColor());
2525 return ( theWrappedObject->addressAreaColor());
2521 }
2526 }
2522
2527
2523 int PythonQtWrapper_QHexEdit::addressOffset(QHexEdit* theWrappedObject)
2528 int PythonQtWrapper_QHexEdit::addressOffset(QHexEdit* theWrappedObject)
2524 {
2529 {
2525 return ( theWrappedObject->addressOffset());
2530 return ( theWrappedObject->addressOffset());
2526 }
2531 }
2527
2532
2528 int PythonQtWrapper_QHexEdit::cursorPosition(QHexEdit* theWrappedObject)
2533 int PythonQtWrapper_QHexEdit::cursorPosition(QHexEdit* theWrappedObject)
2529 {
2534 {
2530 return ( theWrappedObject->cursorPosition());
2535 return ( theWrappedObject->cursorPosition());
2531 }
2536 }
2532
2537
2533 QByteArray PythonQtWrapper_QHexEdit::data(QHexEdit* theWrappedObject)
2538 QByteArray PythonQtWrapper_QHexEdit::data(QHexEdit* theWrappedObject)
2534 {
2539 {
2535 return ( theWrappedObject->data());
2540 return ( theWrappedObject->data());
2536 }
2541 }
2537
2542
2538 const QFont* PythonQtWrapper_QHexEdit::font(QHexEdit* theWrappedObject) const
2543 const QFont* PythonQtWrapper_QHexEdit::font(QHexEdit* theWrappedObject) const
2539 {
2544 {
2540 return &( theWrappedObject->font());
2545 return &( theWrappedObject->font());
2541 }
2546 }
2542
2547
2543 int PythonQtWrapper_QHexEdit::getSelectionBegin(QHexEdit* theWrappedObject)
2548 int PythonQtWrapper_QHexEdit::getSelectionBegin(QHexEdit* theWrappedObject)
2544 {
2549 {
2545 return ( theWrappedObject->getSelectionBegin());
2550 return ( theWrappedObject->getSelectionBegin());
2546 }
2551 }
2547
2552
2548 int PythonQtWrapper_QHexEdit::getSelectionEnd(QHexEdit* theWrappedObject)
2553 int PythonQtWrapper_QHexEdit::getSelectionEnd(QHexEdit* theWrappedObject)
2549 {
2554 {
2550 return ( theWrappedObject->getSelectionEnd());
2555 return ( theWrappedObject->getSelectionEnd());
2551 }
2556 }
2552
2557
2553 QColor PythonQtWrapper_QHexEdit::highlightingColor(QHexEdit* theWrappedObject)
2558 QColor PythonQtWrapper_QHexEdit::highlightingColor(QHexEdit* theWrappedObject)
2554 {
2559 {
2555 return ( theWrappedObject->highlightingColor());
2560 return ( theWrappedObject->highlightingColor());
2556 }
2561 }
2557
2562
2558 int PythonQtWrapper_QHexEdit::indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2563 int PythonQtWrapper_QHexEdit::indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2559 {
2564 {
2560 return ( theWrappedObject->indexOf(ba, from));
2565 return ( theWrappedObject->indexOf(ba, from));
2561 }
2566 }
2562
2567
2563 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, char ch)
2568 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, char ch)
2564 {
2569 {
2565 ( theWrappedObject->insert(i, ch));
2570 ( theWrappedObject->insert(i, ch));
2566 }
2571 }
2567
2572
2568 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba)
2573 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba)
2569 {
2574 {
2570 ( theWrappedObject->insert(i, ba));
2575 ( theWrappedObject->insert(i, ba));
2571 }
2576 }
2572
2577
2573 bool PythonQtWrapper_QHexEdit::isReadOnly(QHexEdit* theWrappedObject)
2578 bool PythonQtWrapper_QHexEdit::isReadOnly(QHexEdit* theWrappedObject)
2574 {
2579 {
2575 return ( theWrappedObject->isReadOnly());
2580 return ( theWrappedObject->isReadOnly());
2576 }
2581 }
2577
2582
2578 int PythonQtWrapper_QHexEdit::lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2583 int PythonQtWrapper_QHexEdit::lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2579 {
2584 {
2580 return ( theWrappedObject->lastIndexOf(ba, from));
2585 return ( theWrappedObject->lastIndexOf(ba, from));
2581 }
2586 }
2582
2587
2583 bool PythonQtWrapper_QHexEdit::overwriteMode(QHexEdit* theWrappedObject)
2588 bool PythonQtWrapper_QHexEdit::overwriteMode(QHexEdit* theWrappedObject)
2584 {
2589 {
2585 return ( theWrappedObject->overwriteMode());
2590 return ( theWrappedObject->overwriteMode());
2586 }
2591 }
2587
2592
2588 void PythonQtWrapper_QHexEdit::remove(QHexEdit* theWrappedObject, int pos, int len)
2593 void PythonQtWrapper_QHexEdit::remove(QHexEdit* theWrappedObject, int pos, int len)
2589 {
2594 {
2590 ( theWrappedObject->remove(pos, len));
2595 ( theWrappedObject->remove(pos, len));
2591 }
2596 }
2592
2597
2593 void PythonQtWrapper_QHexEdit::replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after)
2598 void PythonQtWrapper_QHexEdit::replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after)
2594 {
2599 {
2595 ( theWrappedObject->replace(pos, len, after));
2600 ( theWrappedObject->replace(pos, len, after));
2596 }
2601 }
2597
2602
2598 void PythonQtWrapper_QHexEdit::resetSelection(QHexEdit* theWrappedObject)
2603 void PythonQtWrapper_QHexEdit::resetSelection(QHexEdit* theWrappedObject)
2599 {
2604 {
2600 ( theWrappedObject->resetSelection());
2605 ( theWrappedObject->resetSelection());
2601 }
2606 }
2602
2607
2603 void PythonQtWrapper_QHexEdit::resetSelection(QHexEdit* theWrappedObject, int pos)
2608 void PythonQtWrapper_QHexEdit::resetSelection(QHexEdit* theWrappedObject, int pos)
2604 {
2609 {
2605 ( theWrappedObject->resetSelection(pos));
2610 ( theWrappedObject->resetSelection(pos));
2606 }
2611 }
2607
2612
2608 QColor PythonQtWrapper_QHexEdit::selectionColor(QHexEdit* theWrappedObject)
2613 QColor PythonQtWrapper_QHexEdit::selectionColor(QHexEdit* theWrappedObject)
2609 {
2614 {
2610 return ( theWrappedObject->selectionColor());
2615 return ( theWrappedObject->selectionColor());
2611 }
2616 }
2612
2617
2613 QString PythonQtWrapper_QHexEdit::selectionToReadableString(QHexEdit* theWrappedObject)
2618 QString PythonQtWrapper_QHexEdit::selectionToReadableString(QHexEdit* theWrappedObject)
2614 {
2619 {
2615 return ( theWrappedObject->selectionToReadableString());
2620 return ( theWrappedObject->selectionToReadableString());
2616 }
2621 }
2617
2622
2618 void PythonQtWrapper_QHexEdit::setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color)
2623 void PythonQtWrapper_QHexEdit::setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color)
2619 {
2624 {
2620 ( theWrappedObject->setAddressAreaColor(color));
2625 ( theWrappedObject->setAddressAreaColor(color));
2621 }
2626 }
2622
2627
2623 void PythonQtWrapper_QHexEdit::setAddressOffset(QHexEdit* theWrappedObject, int offset)
2628 void PythonQtWrapper_QHexEdit::setAddressOffset(QHexEdit* theWrappedObject, int offset)
2624 {
2629 {
2625 ( theWrappedObject->setAddressOffset(offset));
2630 ( theWrappedObject->setAddressOffset(offset));
2626 }
2631 }
2627
2632
2628 void PythonQtWrapper_QHexEdit::setCursorPosition(QHexEdit* theWrappedObject, int cusorPos)
2633 void PythonQtWrapper_QHexEdit::setCursorPosition(QHexEdit* theWrappedObject, int cusorPos)
2629 {
2634 {
2630 ( theWrappedObject->setCursorPosition(cusorPos));
2635 ( theWrappedObject->setCursorPosition(cusorPos));
2631 }
2636 }
2632
2637
2633 void PythonQtWrapper_QHexEdit::setData(QHexEdit* theWrappedObject, const QByteArray& data)
2638 void PythonQtWrapper_QHexEdit::setData(QHexEdit* theWrappedObject, const QByteArray& data)
2634 {
2639 {
2635 ( theWrappedObject->setData(data));
2640 ( theWrappedObject->setData(data));
2636 }
2641 }
2637
2642
2638 void PythonQtWrapper_QHexEdit::setFont(QHexEdit* theWrappedObject, const QFont& arg__1)
2643 void PythonQtWrapper_QHexEdit::setFont(QHexEdit* theWrappedObject, const QFont& arg__1)
2639 {
2644 {
2640 ( theWrappedObject->setFont(arg__1));
2645 ( theWrappedObject->setFont(arg__1));
2641 }
2646 }
2642
2647
2643 void PythonQtWrapper_QHexEdit::setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color)
2648 void PythonQtWrapper_QHexEdit::setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color)
2644 {
2649 {
2645 ( theWrappedObject->setHighlightingColor(color));
2650 ( theWrappedObject->setHighlightingColor(color));
2646 }
2651 }
2647
2652
2648 void PythonQtWrapper_QHexEdit::setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1)
2653 void PythonQtWrapper_QHexEdit::setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1)
2649 {
2654 {
2650 ( theWrappedObject->setOverwriteMode(arg__1));
2655 ( theWrappedObject->setOverwriteMode(arg__1));
2651 }
2656 }
2652
2657
2653 void PythonQtWrapper_QHexEdit::setReadOnly(QHexEdit* theWrappedObject, bool arg__1)
2658 void PythonQtWrapper_QHexEdit::setReadOnly(QHexEdit* theWrappedObject, bool arg__1)
2654 {
2659 {
2655 ( theWrappedObject->setReadOnly(arg__1));
2660 ( theWrappedObject->setReadOnly(arg__1));
2656 }
2661 }
2657
2662
2658 void PythonQtWrapper_QHexEdit::setSelection(QHexEdit* theWrappedObject, int pos)
2663 void PythonQtWrapper_QHexEdit::setSelection(QHexEdit* theWrappedObject, int pos)
2659 {
2664 {
2660 ( theWrappedObject->setSelection(pos));
2665 ( theWrappedObject->setSelection(pos));
2661 }
2666 }
2662
2667
2663 void PythonQtWrapper_QHexEdit::setSelectionColor(QHexEdit* theWrappedObject, const QColor& color)
2668 void PythonQtWrapper_QHexEdit::setSelectionColor(QHexEdit* theWrappedObject, const QColor& color)
2664 {
2669 {
2665 ( theWrappedObject->setSelectionColor(color));
2670 ( theWrappedObject->setSelectionColor(color));
2666 }
2671 }
2667
2672
2668 QString PythonQtWrapper_QHexEdit::toReadableString(QHexEdit* theWrappedObject)
2673 QString PythonQtWrapper_QHexEdit::toReadableString(QHexEdit* theWrappedObject)
2669 {
2674 {
2670 return ( theWrappedObject->toReadableString());
2675 return ( theWrappedObject->toReadableString());
2671 }
2676 }
2672
2677
2673
2678
2674
2679
2675 PythonQtShell_QHexSpinBox::~PythonQtShell_QHexSpinBox() {
2680 PythonQtShell_QHexSpinBox::~PythonQtShell_QHexSpinBox() {
2676 PythonQtPrivate* priv = PythonQt::priv();
2681 PythonQtPrivate* priv = PythonQt::priv();
2677 if (priv) { priv->shellClassDeleted(this); }
2682 if (priv) { priv->shellClassDeleted(this); }
2678 }
2683 }
2679 void PythonQtShell_QHexSpinBox::actionEvent(QActionEvent* arg__1)
2684 void PythonQtShell_QHexSpinBox::actionEvent(QActionEvent* arg__1)
2680 {
2685 {
2681 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2686 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2682 static PyObject* name = PyString_FromString("actionEvent");
2687 static PyObject* name = PyString_FromString("actionEvent");
2683 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2688 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2684 if (obj) {
2689 if (obj) {
2685 static const char* argumentList[] ={"" , "QActionEvent*"};
2690 static const char* argumentList[] ={"" , "QActionEvent*"};
2686 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2691 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2687 void* args[2] = {NULL, (void*)&arg__1};
2692 void* args[2] = {NULL, (void*)&arg__1};
2688 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2693 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2689 if (result) { Py_DECREF(result); }
2694 if (result) { Py_DECREF(result); }
2690 Py_DECREF(obj);
2695 Py_DECREF(obj);
2691 return;
2696 return;
2692 } else {
2697 } else {
2693 PyErr_Clear();
2698 PyErr_Clear();
2694 }
2699 }
2695 }
2700 }
2696 QHexSpinBox::actionEvent(arg__1);
2701 QHexSpinBox::actionEvent(arg__1);
2697 }
2702 }
2698 void PythonQtShell_QHexSpinBox::changeEvent(QEvent* event0)
2703 void PythonQtShell_QHexSpinBox::changeEvent(QEvent* event0)
2699 {
2704 {
2700 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2705 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2701 static PyObject* name = PyString_FromString("changeEvent");
2706 static PyObject* name = PyString_FromString("changeEvent");
2702 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2707 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2703 if (obj) {
2708 if (obj) {
2704 static const char* argumentList[] ={"" , "QEvent*"};
2709 static const char* argumentList[] ={"" , "QEvent*"};
2705 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2710 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2706 void* args[2] = {NULL, (void*)&event0};
2711 void* args[2] = {NULL, (void*)&event0};
2707 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2712 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2708 if (result) { Py_DECREF(result); }
2713 if (result) { Py_DECREF(result); }
2709 Py_DECREF(obj);
2714 Py_DECREF(obj);
2710 return;
2715 return;
2711 } else {
2716 } else {
2712 PyErr_Clear();
2717 PyErr_Clear();
2713 }
2718 }
2714 }
2719 }
2715 QHexSpinBox::changeEvent(event0);
2720 QHexSpinBox::changeEvent(event0);
2716 }
2721 }
2717 void PythonQtShell_QHexSpinBox::childEvent(QChildEvent* arg__1)
2722 void PythonQtShell_QHexSpinBox::childEvent(QChildEvent* arg__1)
2718 {
2723 {
2719 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2724 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2720 static PyObject* name = PyString_FromString("childEvent");
2725 static PyObject* name = PyString_FromString("childEvent");
2721 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2726 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2722 if (obj) {
2727 if (obj) {
2723 static const char* argumentList[] ={"" , "QChildEvent*"};
2728 static const char* argumentList[] ={"" , "QChildEvent*"};
2724 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2729 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2725 void* args[2] = {NULL, (void*)&arg__1};
2730 void* args[2] = {NULL, (void*)&arg__1};
2726 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2731 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2727 if (result) { Py_DECREF(result); }
2732 if (result) { Py_DECREF(result); }
2728 Py_DECREF(obj);
2733 Py_DECREF(obj);
2729 return;
2734 return;
2730 } else {
2735 } else {
2731 PyErr_Clear();
2736 PyErr_Clear();
2732 }
2737 }
2733 }
2738 }
2734 QHexSpinBox::childEvent(arg__1);
2739 QHexSpinBox::childEvent(arg__1);
2735 }
2740 }
2736 void PythonQtShell_QHexSpinBox::clear()
2741 void PythonQtShell_QHexSpinBox::clear()
2737 {
2742 {
2738 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2743 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2739 static PyObject* name = PyString_FromString("clear");
2744 static PyObject* name = PyString_FromString("clear");
2740 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2745 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2741 if (obj) {
2746 if (obj) {
2742 static const char* argumentList[] ={""};
2747 static const char* argumentList[] ={""};
2743 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2748 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2744 void* args[1] = {NULL};
2749 void* args[1] = {NULL};
2745 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2750 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2746 if (result) { Py_DECREF(result); }
2751 if (result) { Py_DECREF(result); }
2747 Py_DECREF(obj);
2752 Py_DECREF(obj);
2748 return;
2753 return;
2749 } else {
2754 } else {
2750 PyErr_Clear();
2755 PyErr_Clear();
2751 }
2756 }
2752 }
2757 }
2753 QHexSpinBox::clear();
2758 QHexSpinBox::clear();
2754 }
2759 }
2755 void PythonQtShell_QHexSpinBox::closeEvent(QCloseEvent* event0)
2760 void PythonQtShell_QHexSpinBox::closeEvent(QCloseEvent* event0)
2756 {
2761 {
2757 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2762 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2758 static PyObject* name = PyString_FromString("closeEvent");
2763 static PyObject* name = PyString_FromString("closeEvent");
2759 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2764 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2760 if (obj) {
2765 if (obj) {
2761 static const char* argumentList[] ={"" , "QCloseEvent*"};
2766 static const char* argumentList[] ={"" , "QCloseEvent*"};
2762 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2767 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2763 void* args[2] = {NULL, (void*)&event0};
2768 void* args[2] = {NULL, (void*)&event0};
2764 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2769 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2765 if (result) { Py_DECREF(result); }
2770 if (result) { Py_DECREF(result); }
2766 Py_DECREF(obj);
2771 Py_DECREF(obj);
2767 return;
2772 return;
2768 } else {
2773 } else {
2769 PyErr_Clear();
2774 PyErr_Clear();
2770 }
2775 }
2771 }
2776 }
2772 QHexSpinBox::closeEvent(event0);
2777 QHexSpinBox::closeEvent(event0);
2773 }
2778 }
2774 void PythonQtShell_QHexSpinBox::contextMenuEvent(QContextMenuEvent* event0)
2779 void PythonQtShell_QHexSpinBox::contextMenuEvent(QContextMenuEvent* event0)
2775 {
2780 {
2776 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2781 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2777 static PyObject* name = PyString_FromString("contextMenuEvent");
2782 static PyObject* name = PyString_FromString("contextMenuEvent");
2778 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2783 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2779 if (obj) {
2784 if (obj) {
2780 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
2785 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
2781 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2786 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2782 void* args[2] = {NULL, (void*)&event0};
2787 void* args[2] = {NULL, (void*)&event0};
2783 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2788 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2784 if (result) { Py_DECREF(result); }
2789 if (result) { Py_DECREF(result); }
2785 Py_DECREF(obj);
2790 Py_DECREF(obj);
2786 return;
2791 return;
2787 } else {
2792 } else {
2788 PyErr_Clear();
2793 PyErr_Clear();
2789 }
2794 }
2790 }
2795 }
2791 QHexSpinBox::contextMenuEvent(event0);
2796 QHexSpinBox::contextMenuEvent(event0);
2792 }
2797 }
2793 void PythonQtShell_QHexSpinBox::customEvent(QEvent* arg__1)
2798 void PythonQtShell_QHexSpinBox::customEvent(QEvent* arg__1)
2794 {
2799 {
2795 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2800 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2796 static PyObject* name = PyString_FromString("customEvent");
2801 static PyObject* name = PyString_FromString("customEvent");
2797 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2802 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2798 if (obj) {
2803 if (obj) {
2799 static const char* argumentList[] ={"" , "QEvent*"};
2804 static const char* argumentList[] ={"" , "QEvent*"};
2800 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2805 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2801 void* args[2] = {NULL, (void*)&arg__1};
2806 void* args[2] = {NULL, (void*)&arg__1};
2802 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2807 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2803 if (result) { Py_DECREF(result); }
2808 if (result) { Py_DECREF(result); }
2804 Py_DECREF(obj);
2809 Py_DECREF(obj);
2805 return;
2810 return;
2806 } else {
2811 } else {
2807 PyErr_Clear();
2812 PyErr_Clear();
2808 }
2813 }
2809 }
2814 }
2810 QHexSpinBox::customEvent(arg__1);
2815 QHexSpinBox::customEvent(arg__1);
2811 }
2816 }
2812 int PythonQtShell_QHexSpinBox::devType() const
2817 int PythonQtShell_QHexSpinBox::devType() const
2813 {
2818 {
2814 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2819 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2815 static PyObject* name = PyString_FromString("devType");
2820 static PyObject* name = PyString_FromString("devType");
2816 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2821 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2817 if (obj) {
2822 if (obj) {
2818 static const char* argumentList[] ={"int"};
2823 static const char* argumentList[] ={"int"};
2819 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2824 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2820 int returnValue;
2825 int returnValue;
2821 void* args[1] = {NULL};
2826 void* args[1] = {NULL};
2822 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2827 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2823 if (result) {
2828 if (result) {
2824 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2829 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2825 if (args[0]!=&returnValue) {
2830 if (args[0]!=&returnValue) {
2826 if (args[0]==NULL) {
2831 if (args[0]==NULL) {
2827 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
2832 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
2828 } else {
2833 } else {
2829 returnValue = *((int*)args[0]);
2834 returnValue = *((int*)args[0]);
2830 }
2835 }
2831 }
2836 }
2832 }
2837 }
2833 if (result) { Py_DECREF(result); }
2838 if (result) { Py_DECREF(result); }
2834 Py_DECREF(obj);
2839 Py_DECREF(obj);
2835 return returnValue;
2840 return returnValue;
2836 } else {
2841 } else {
2837 PyErr_Clear();
2842 PyErr_Clear();
2838 }
2843 }
2839 }
2844 }
2840 return QHexSpinBox::devType();
2845 return QHexSpinBox::devType();
2841 }
2846 }
2842 void PythonQtShell_QHexSpinBox::dragEnterEvent(QDragEnterEvent* arg__1)
2847 void PythonQtShell_QHexSpinBox::dragEnterEvent(QDragEnterEvent* arg__1)
2843 {
2848 {
2844 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2849 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2845 static PyObject* name = PyString_FromString("dragEnterEvent");
2850 static PyObject* name = PyString_FromString("dragEnterEvent");
2846 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2851 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2847 if (obj) {
2852 if (obj) {
2848 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
2853 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
2849 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2854 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2850 void* args[2] = {NULL, (void*)&arg__1};
2855 void* args[2] = {NULL, (void*)&arg__1};
2851 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2856 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2852 if (result) { Py_DECREF(result); }
2857 if (result) { Py_DECREF(result); }
2853 Py_DECREF(obj);
2858 Py_DECREF(obj);
2854 return;
2859 return;
2855 } else {
2860 } else {
2856 PyErr_Clear();
2861 PyErr_Clear();
2857 }
2862 }
2858 }
2863 }
2859 QHexSpinBox::dragEnterEvent(arg__1);
2864 QHexSpinBox::dragEnterEvent(arg__1);
2860 }
2865 }
2861 void PythonQtShell_QHexSpinBox::dragLeaveEvent(QDragLeaveEvent* arg__1)
2866 void PythonQtShell_QHexSpinBox::dragLeaveEvent(QDragLeaveEvent* arg__1)
2862 {
2867 {
2863 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2868 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2864 static PyObject* name = PyString_FromString("dragLeaveEvent");
2869 static PyObject* name = PyString_FromString("dragLeaveEvent");
2865 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2870 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2866 if (obj) {
2871 if (obj) {
2867 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
2872 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
2868 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2873 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2869 void* args[2] = {NULL, (void*)&arg__1};
2874 void* args[2] = {NULL, (void*)&arg__1};
2870 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2875 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2871 if (result) { Py_DECREF(result); }
2876 if (result) { Py_DECREF(result); }
2872 Py_DECREF(obj);
2877 Py_DECREF(obj);
2873 return;
2878 return;
2874 } else {
2879 } else {
2875 PyErr_Clear();
2880 PyErr_Clear();
2876 }
2881 }
2877 }
2882 }
2878 QHexSpinBox::dragLeaveEvent(arg__1);
2883 QHexSpinBox::dragLeaveEvent(arg__1);
2879 }
2884 }
2880 void PythonQtShell_QHexSpinBox::dragMoveEvent(QDragMoveEvent* arg__1)
2885 void PythonQtShell_QHexSpinBox::dragMoveEvent(QDragMoveEvent* arg__1)
2881 {
2886 {
2882 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2887 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2883 static PyObject* name = PyString_FromString("dragMoveEvent");
2888 static PyObject* name = PyString_FromString("dragMoveEvent");
2884 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2889 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2885 if (obj) {
2890 if (obj) {
2886 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
2891 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
2887 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2892 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2888 void* args[2] = {NULL, (void*)&arg__1};
2893 void* args[2] = {NULL, (void*)&arg__1};
2889 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2894 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2890 if (result) { Py_DECREF(result); }
2895 if (result) { Py_DECREF(result); }
2891 Py_DECREF(obj);
2896 Py_DECREF(obj);
2892 return;
2897 return;
2893 } else {
2898 } else {
2894 PyErr_Clear();
2899 PyErr_Clear();
2895 }
2900 }
2896 }
2901 }
2897 QHexSpinBox::dragMoveEvent(arg__1);
2902 QHexSpinBox::dragMoveEvent(arg__1);
2898 }
2903 }
2899 void PythonQtShell_QHexSpinBox::dropEvent(QDropEvent* arg__1)
2904 void PythonQtShell_QHexSpinBox::dropEvent(QDropEvent* arg__1)
2900 {
2905 {
2901 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2906 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2902 static PyObject* name = PyString_FromString("dropEvent");
2907 static PyObject* name = PyString_FromString("dropEvent");
2903 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2908 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2904 if (obj) {
2909 if (obj) {
2905 static const char* argumentList[] ={"" , "QDropEvent*"};
2910 static const char* argumentList[] ={"" , "QDropEvent*"};
2906 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2911 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2907 void* args[2] = {NULL, (void*)&arg__1};
2912 void* args[2] = {NULL, (void*)&arg__1};
2908 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2913 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2909 if (result) { Py_DECREF(result); }
2914 if (result) { Py_DECREF(result); }
2910 Py_DECREF(obj);
2915 Py_DECREF(obj);
2911 return;
2916 return;
2912 } else {
2917 } else {
2913 PyErr_Clear();
2918 PyErr_Clear();
2914 }
2919 }
2915 }
2920 }
2916 QHexSpinBox::dropEvent(arg__1);
2921 QHexSpinBox::dropEvent(arg__1);
2917 }
2922 }
2918 void PythonQtShell_QHexSpinBox::enterEvent(QEvent* arg__1)
2923 void PythonQtShell_QHexSpinBox::enterEvent(QEvent* arg__1)
2919 {
2924 {
2920 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2925 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2921 static PyObject* name = PyString_FromString("enterEvent");
2926 static PyObject* name = PyString_FromString("enterEvent");
2922 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2927 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2923 if (obj) {
2928 if (obj) {
2924 static const char* argumentList[] ={"" , "QEvent*"};
2929 static const char* argumentList[] ={"" , "QEvent*"};
2925 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2930 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2926 void* args[2] = {NULL, (void*)&arg__1};
2931 void* args[2] = {NULL, (void*)&arg__1};
2927 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2932 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2928 if (result) { Py_DECREF(result); }
2933 if (result) { Py_DECREF(result); }
2929 Py_DECREF(obj);
2934 Py_DECREF(obj);
2930 return;
2935 return;
2931 } else {
2936 } else {
2932 PyErr_Clear();
2937 PyErr_Clear();
2933 }
2938 }
2934 }
2939 }
2935 QHexSpinBox::enterEvent(arg__1);
2940 QHexSpinBox::enterEvent(arg__1);
2936 }
2941 }
2937 bool PythonQtShell_QHexSpinBox::event(QEvent* event0)
2942 bool PythonQtShell_QHexSpinBox::event(QEvent* event0)
2938 {
2943 {
2939 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2944 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2940 static PyObject* name = PyString_FromString("event");
2945 static PyObject* name = PyString_FromString("event");
2941 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2946 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2942 if (obj) {
2947 if (obj) {
2943 static const char* argumentList[] ={"bool" , "QEvent*"};
2948 static const char* argumentList[] ={"bool" , "QEvent*"};
2944 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2949 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2945 bool returnValue;
2950 bool returnValue;
2946 void* args[2] = {NULL, (void*)&event0};
2951 void* args[2] = {NULL, (void*)&event0};
2947 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2952 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2948 if (result) {
2953 if (result) {
2949 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2954 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2950 if (args[0]!=&returnValue) {
2955 if (args[0]!=&returnValue) {
2951 if (args[0]==NULL) {
2956 if (args[0]==NULL) {
2952 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
2957 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
2953 } else {
2958 } else {
2954 returnValue = *((bool*)args[0]);
2959 returnValue = *((bool*)args[0]);
2955 }
2960 }
2956 }
2961 }
2957 }
2962 }
2958 if (result) { Py_DECREF(result); }
2963 if (result) { Py_DECREF(result); }
2959 Py_DECREF(obj);
2964 Py_DECREF(obj);
2960 return returnValue;
2965 return returnValue;
2961 } else {
2966 } else {
2962 PyErr_Clear();
2967 PyErr_Clear();
2963 }
2968 }
2964 }
2969 }
2965 return QHexSpinBox::event(event0);
2970 return QHexSpinBox::event(event0);
2966 }
2971 }
2967 bool PythonQtShell_QHexSpinBox::eventFilter(QObject* arg__1, QEvent* arg__2)
2972 bool PythonQtShell_QHexSpinBox::eventFilter(QObject* arg__1, QEvent* arg__2)
2968 {
2973 {
2969 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2974 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
2970 static PyObject* name = PyString_FromString("eventFilter");
2975 static PyObject* name = PyString_FromString("eventFilter");
2971 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2976 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
2972 if (obj) {
2977 if (obj) {
2973 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
2978 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
2974 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2979 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2975 bool returnValue;
2980 bool returnValue;
2976 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
2981 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
2977 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2982 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2978 if (result) {
2983 if (result) {
2979 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2984 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2980 if (args[0]!=&returnValue) {
2985 if (args[0]!=&returnValue) {
2981 if (args[0]==NULL) {
2986 if (args[0]==NULL) {
2982 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
2987 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
2983 } else {
2988 } else {
2984 returnValue = *((bool*)args[0]);
2989 returnValue = *((bool*)args[0]);
2985 }
2990 }
2986 }
2991 }
2987 }
2992 }
2988 if (result) { Py_DECREF(result); }
2993 if (result) { Py_DECREF(result); }
2989 Py_DECREF(obj);
2994 Py_DECREF(obj);
2990 return returnValue;
2995 return returnValue;
2991 } else {
2996 } else {
2992 PyErr_Clear();
2997 PyErr_Clear();
2993 }
2998 }
2994 }
2999 }
2995 return QHexSpinBox::eventFilter(arg__1, arg__2);
3000 return QHexSpinBox::eventFilter(arg__1, arg__2);
2996 }
3001 }
2997 void PythonQtShell_QHexSpinBox::fixup(QString& str0) const
3002 void PythonQtShell_QHexSpinBox::fixup(QString& str0) const
2998 {
3003 {
2999 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3004 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3000 static PyObject* name = PyString_FromString("fixup");
3005 static PyObject* name = PyString_FromString("fixup");
3001 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3006 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3002 if (obj) {
3007 if (obj) {
3003 static const char* argumentList[] ={"" , "QString&"};
3008 static const char* argumentList[] ={"" , "QString&"};
3004 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3009 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3005 void* args[2] = {NULL, (void*)&str0};
3010 void* args[2] = {NULL, (void*)&str0};
3006 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3011 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3007 if (result) { Py_DECREF(result); }
3012 if (result) { Py_DECREF(result); }
3008 Py_DECREF(obj);
3013 Py_DECREF(obj);
3009 return;
3014 return;
3010 } else {
3015 } else {
3011 PyErr_Clear();
3016 PyErr_Clear();
3012 }
3017 }
3013 }
3018 }
3014 QHexSpinBox::fixup(str0);
3019 QHexSpinBox::fixup(str0);
3015 }
3020 }
3016 void PythonQtShell_QHexSpinBox::focusInEvent(QFocusEvent* event0)
3021 void PythonQtShell_QHexSpinBox::focusInEvent(QFocusEvent* event0)
3017 {
3022 {
3018 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3023 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3019 static PyObject* name = PyString_FromString("focusInEvent");
3024 static PyObject* name = PyString_FromString("focusInEvent");
3020 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3025 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3021 if (obj) {
3026 if (obj) {
3022 static const char* argumentList[] ={"" , "QFocusEvent*"};
3027 static const char* argumentList[] ={"" , "QFocusEvent*"};
3023 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3028 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3024 void* args[2] = {NULL, (void*)&event0};
3029 void* args[2] = {NULL, (void*)&event0};
3025 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3030 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3026 if (result) { Py_DECREF(result); }
3031 if (result) { Py_DECREF(result); }
3027 Py_DECREF(obj);
3032 Py_DECREF(obj);
3028 return;
3033 return;
3029 } else {
3034 } else {
3030 PyErr_Clear();
3035 PyErr_Clear();
3031 }
3036 }
3032 }
3037 }
3033 QHexSpinBox::focusInEvent(event0);
3038 QHexSpinBox::focusInEvent(event0);
3034 }
3039 }
3035 bool PythonQtShell_QHexSpinBox::focusNextPrevChild(bool next0)
3040 bool PythonQtShell_QHexSpinBox::focusNextPrevChild(bool next0)
3036 {
3041 {
3037 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3042 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3038 static PyObject* name = PyString_FromString("focusNextPrevChild");
3043 static PyObject* name = PyString_FromString("focusNextPrevChild");
3039 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3044 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3040 if (obj) {
3045 if (obj) {
3041 static const char* argumentList[] ={"bool" , "bool"};
3046 static const char* argumentList[] ={"bool" , "bool"};
3042 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3047 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3043 bool returnValue;
3048 bool returnValue;
3044 void* args[2] = {NULL, (void*)&next0};
3049 void* args[2] = {NULL, (void*)&next0};
3045 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3050 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3046 if (result) {
3051 if (result) {
3047 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3052 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3048 if (args[0]!=&returnValue) {
3053 if (args[0]!=&returnValue) {
3049 if (args[0]==NULL) {
3054 if (args[0]==NULL) {
3050 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
3055 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
3051 } else {
3056 } else {
3052 returnValue = *((bool*)args[0]);
3057 returnValue = *((bool*)args[0]);
3053 }
3058 }
3054 }
3059 }
3055 }
3060 }
3056 if (result) { Py_DECREF(result); }
3061 if (result) { Py_DECREF(result); }
3057 Py_DECREF(obj);
3062 Py_DECREF(obj);
3058 return returnValue;
3063 return returnValue;
3059 } else {
3064 } else {
3060 PyErr_Clear();
3065 PyErr_Clear();
3061 }
3066 }
3062 }
3067 }
3063 return QHexSpinBox::focusNextPrevChild(next0);
3068 return QHexSpinBox::focusNextPrevChild(next0);
3064 }
3069 }
3065 void PythonQtShell_QHexSpinBox::focusOutEvent(QFocusEvent* event0)
3070 void PythonQtShell_QHexSpinBox::focusOutEvent(QFocusEvent* event0)
3066 {
3071 {
3067 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3072 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3068 static PyObject* name = PyString_FromString("focusOutEvent");
3073 static PyObject* name = PyString_FromString("focusOutEvent");
3069 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3074 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3070 if (obj) {
3075 if (obj) {
3071 static const char* argumentList[] ={"" , "QFocusEvent*"};
3076 static const char* argumentList[] ={"" , "QFocusEvent*"};
3072 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3077 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3073 void* args[2] = {NULL, (void*)&event0};
3078 void* args[2] = {NULL, (void*)&event0};
3074 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3079 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3075 if (result) { Py_DECREF(result); }
3080 if (result) { Py_DECREF(result); }
3076 Py_DECREF(obj);
3081 Py_DECREF(obj);
3077 return;
3082 return;
3078 } else {
3083 } else {
3079 PyErr_Clear();
3084 PyErr_Clear();
3080 }
3085 }
3081 }
3086 }
3082 QHexSpinBox::focusOutEvent(event0);
3087 QHexSpinBox::focusOutEvent(event0);
3083 }
3088 }
3084 bool PythonQtShell_QHexSpinBox::hasHeightForWidth() const
3089 bool PythonQtShell_QHexSpinBox::hasHeightForWidth() const
3085 {
3090 {
3086 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3091 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3087 static PyObject* name = PyString_FromString("hasHeightForWidth");
3092 static PyObject* name = PyString_FromString("hasHeightForWidth");
3088 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3093 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3089 if (obj) {
3094 if (obj) {
3090 static const char* argumentList[] ={"bool"};
3095 static const char* argumentList[] ={"bool"};
3091 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3096 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3092 bool returnValue;
3097 bool returnValue;
3093 void* args[1] = {NULL};
3098 void* args[1] = {NULL};
3094 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3099 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3095 if (result) {
3100 if (result) {
3096 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3101 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3097 if (args[0]!=&returnValue) {
3102 if (args[0]!=&returnValue) {
3098 if (args[0]==NULL) {
3103 if (args[0]==NULL) {
3099 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
3104 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
3100 } else {
3105 } else {
3101 returnValue = *((bool*)args[0]);
3106 returnValue = *((bool*)args[0]);
3102 }
3107 }
3103 }
3108 }
3104 }
3109 }
3105 if (result) { Py_DECREF(result); }
3110 if (result) { Py_DECREF(result); }
3106 Py_DECREF(obj);
3111 Py_DECREF(obj);
3107 return returnValue;
3112 return returnValue;
3108 } else {
3113 } else {
3109 PyErr_Clear();
3114 PyErr_Clear();
3110 }
3115 }
3111 }
3116 }
3112 return QHexSpinBox::hasHeightForWidth();
3117 return QHexSpinBox::hasHeightForWidth();
3113 }
3118 }
3114 int PythonQtShell_QHexSpinBox::heightForWidth(int arg__1) const
3119 int PythonQtShell_QHexSpinBox::heightForWidth(int arg__1) const
3115 {
3120 {
3116 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3121 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3117 static PyObject* name = PyString_FromString("heightForWidth");
3122 static PyObject* name = PyString_FromString("heightForWidth");
3118 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3123 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3119 if (obj) {
3124 if (obj) {
3120 static const char* argumentList[] ={"int" , "int"};
3125 static const char* argumentList[] ={"int" , "int"};
3121 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3126 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3122 int returnValue;
3127 int returnValue;
3123 void* args[2] = {NULL, (void*)&arg__1};
3128 void* args[2] = {NULL, (void*)&arg__1};
3124 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3129 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3125 if (result) {
3130 if (result) {
3126 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3131 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3127 if (args[0]!=&returnValue) {
3132 if (args[0]!=&returnValue) {
3128 if (args[0]==NULL) {
3133 if (args[0]==NULL) {
3129 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
3134 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
3130 } else {
3135 } else {
3131 returnValue = *((int*)args[0]);
3136 returnValue = *((int*)args[0]);
3132 }
3137 }
3133 }
3138 }
3134 }
3139 }
3135 if (result) { Py_DECREF(result); }
3140 if (result) { Py_DECREF(result); }
3136 Py_DECREF(obj);
3141 Py_DECREF(obj);
3137 return returnValue;
3142 return returnValue;
3138 } else {
3143 } else {
3139 PyErr_Clear();
3144 PyErr_Clear();
3140 }
3145 }
3141 }
3146 }
3142 return QHexSpinBox::heightForWidth(arg__1);
3147 return QHexSpinBox::heightForWidth(arg__1);
3143 }
3148 }
3144 void PythonQtShell_QHexSpinBox::hideEvent(QHideEvent* event0)
3149 void PythonQtShell_QHexSpinBox::hideEvent(QHideEvent* event0)
3145 {
3150 {
3146 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3151 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3147 static PyObject* name = PyString_FromString("hideEvent");
3152 static PyObject* name = PyString_FromString("hideEvent");
3148 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3153 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3149 if (obj) {
3154 if (obj) {
3150 static const char* argumentList[] ={"" , "QHideEvent*"};
3155 static const char* argumentList[] ={"" , "QHideEvent*"};
3151 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3156 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3152 void* args[2] = {NULL, (void*)&event0};
3157 void* args[2] = {NULL, (void*)&event0};
3153 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3158 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3154 if (result) { Py_DECREF(result); }
3159 if (result) { Py_DECREF(result); }
3155 Py_DECREF(obj);
3160 Py_DECREF(obj);
3156 return;
3161 return;
3157 } else {
3162 } else {
3158 PyErr_Clear();
3163 PyErr_Clear();
3159 }
3164 }
3160 }
3165 }
3161 QHexSpinBox::hideEvent(event0);
3166 QHexSpinBox::hideEvent(event0);
3162 }
3167 }
3163 void PythonQtShell_QHexSpinBox::initPainter(QPainter* painter0) const
3168 void PythonQtShell_QHexSpinBox::initPainter(QPainter* painter0) const
3164 {
3169 {
3165 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3170 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3166 static PyObject* name = PyString_FromString("initPainter");
3171 static PyObject* name = PyString_FromString("initPainter");
3167 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3172 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3168 if (obj) {
3173 if (obj) {
3169 static const char* argumentList[] ={"" , "QPainter*"};
3174 static const char* argumentList[] ={"" , "QPainter*"};
3170 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3175 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3171 void* args[2] = {NULL, (void*)&painter0};
3176 void* args[2] = {NULL, (void*)&painter0};
3172 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3177 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3173 if (result) { Py_DECREF(result); }
3178 if (result) { Py_DECREF(result); }
3174 Py_DECREF(obj);
3179 Py_DECREF(obj);
3175 return;
3180 return;
3176 } else {
3181 } else {
3177 PyErr_Clear();
3182 PyErr_Clear();
3178 }
3183 }
3179 }
3184 }
3180 QHexSpinBox::initPainter(painter0);
3185 QHexSpinBox::initPainter(painter0);
3181 }
3186 }
3182 void PythonQtShell_QHexSpinBox::inputMethodEvent(QInputMethodEvent* arg__1)
3187 void PythonQtShell_QHexSpinBox::inputMethodEvent(QInputMethodEvent* arg__1)
3183 {
3188 {
3184 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3189 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3185 static PyObject* name = PyString_FromString("inputMethodEvent");
3190 static PyObject* name = PyString_FromString("inputMethodEvent");
3186 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3191 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3187 if (obj) {
3192 if (obj) {
3188 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
3193 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
3189 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3194 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3190 void* args[2] = {NULL, (void*)&arg__1};
3195 void* args[2] = {NULL, (void*)&arg__1};
3191 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3196 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3192 if (result) { Py_DECREF(result); }
3197 if (result) { Py_DECREF(result); }
3193 Py_DECREF(obj);
3198 Py_DECREF(obj);
3194 return;
3199 return;
3195 } else {
3200 } else {
3196 PyErr_Clear();
3201 PyErr_Clear();
3197 }
3202 }
3198 }
3203 }
3199 QHexSpinBox::inputMethodEvent(arg__1);
3204 QHexSpinBox::inputMethodEvent(arg__1);
3200 }
3205 }
3201 QVariant PythonQtShell_QHexSpinBox::inputMethodQuery(Qt::InputMethodQuery arg__1) const
3206 QVariant PythonQtShell_QHexSpinBox::inputMethodQuery(Qt::InputMethodQuery arg__1) const
3202 {
3207 {
3203 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3208 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3204 static PyObject* name = PyString_FromString("inputMethodQuery");
3209 static PyObject* name = PyString_FromString("inputMethodQuery");
3205 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3210 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3206 if (obj) {
3211 if (obj) {
3207 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
3212 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
3208 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3213 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3209 QVariant returnValue;
3214 QVariant returnValue;
3210 void* args[2] = {NULL, (void*)&arg__1};
3215 void* args[2] = {NULL, (void*)&arg__1};
3211 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3216 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3212 if (result) {
3217 if (result) {
3213 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3218 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3214 if (args[0]!=&returnValue) {
3219 if (args[0]!=&returnValue) {
3215 if (args[0]==NULL) {
3220 if (args[0]==NULL) {
3216 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
3221 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
3217 } else {
3222 } else {
3218 returnValue = *((QVariant*)args[0]);
3223 returnValue = *((QVariant*)args[0]);
3219 }
3224 }
3220 }
3225 }
3221 }
3226 }
3222 if (result) { Py_DECREF(result); }
3227 if (result) { Py_DECREF(result); }
3223 Py_DECREF(obj);
3228 Py_DECREF(obj);
3224 return returnValue;
3229 return returnValue;
3225 } else {
3230 } else {
3226 PyErr_Clear();
3231 PyErr_Clear();
3227 }
3232 }
3228 }
3233 }
3229 return QHexSpinBox::inputMethodQuery(arg__1);
3234 return QHexSpinBox::inputMethodQuery(arg__1);
3230 }
3235 }
3231 void PythonQtShell_QHexSpinBox::keyPressEvent(QKeyEvent* event0)
3236 void PythonQtShell_QHexSpinBox::keyPressEvent(QKeyEvent* event0)
3232 {
3237 {
3233 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3238 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3234 static PyObject* name = PyString_FromString("keyPressEvent");
3239 static PyObject* name = PyString_FromString("keyPressEvent");
3235 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3240 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3236 if (obj) {
3241 if (obj) {
3237 static const char* argumentList[] ={"" , "QKeyEvent*"};
3242 static const char* argumentList[] ={"" , "QKeyEvent*"};
3238 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3243 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3239 void* args[2] = {NULL, (void*)&event0};
3244 void* args[2] = {NULL, (void*)&event0};
3240 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3245 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3241 if (result) { Py_DECREF(result); }
3246 if (result) { Py_DECREF(result); }
3242 Py_DECREF(obj);
3247 Py_DECREF(obj);
3243 return;
3248 return;
3244 } else {
3249 } else {
3245 PyErr_Clear();
3250 PyErr_Clear();
3246 }
3251 }
3247 }
3252 }
3248 QHexSpinBox::keyPressEvent(event0);
3253 QHexSpinBox::keyPressEvent(event0);
3249 }
3254 }
3250 void PythonQtShell_QHexSpinBox::keyReleaseEvent(QKeyEvent* event0)
3255 void PythonQtShell_QHexSpinBox::keyReleaseEvent(QKeyEvent* event0)
3251 {
3256 {
3252 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3257 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3253 static PyObject* name = PyString_FromString("keyReleaseEvent");
3258 static PyObject* name = PyString_FromString("keyReleaseEvent");
3254 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3259 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3255 if (obj) {
3260 if (obj) {
3256 static const char* argumentList[] ={"" , "QKeyEvent*"};
3261 static const char* argumentList[] ={"" , "QKeyEvent*"};
3257 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3262 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3258 void* args[2] = {NULL, (void*)&event0};
3263 void* args[2] = {NULL, (void*)&event0};
3259 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3264 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3260 if (result) { Py_DECREF(result); }
3265 if (result) { Py_DECREF(result); }
3261 Py_DECREF(obj);
3266 Py_DECREF(obj);
3262 return;
3267 return;
3263 } else {
3268 } else {
3264 PyErr_Clear();
3269 PyErr_Clear();
3265 }
3270 }
3266 }
3271 }
3267 QHexSpinBox::keyReleaseEvent(event0);
3272 QHexSpinBox::keyReleaseEvent(event0);
3268 }
3273 }
3269 void PythonQtShell_QHexSpinBox::leaveEvent(QEvent* arg__1)
3274 void PythonQtShell_QHexSpinBox::leaveEvent(QEvent* arg__1)
3270 {
3275 {
3271 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3276 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3272 static PyObject* name = PyString_FromString("leaveEvent");
3277 static PyObject* name = PyString_FromString("leaveEvent");
3273 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3278 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3274 if (obj) {
3279 if (obj) {
3275 static const char* argumentList[] ={"" , "QEvent*"};
3280 static const char* argumentList[] ={"" , "QEvent*"};
3276 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3281 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3277 void* args[2] = {NULL, (void*)&arg__1};
3282 void* args[2] = {NULL, (void*)&arg__1};
3278 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3283 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3279 if (result) { Py_DECREF(result); }
3284 if (result) { Py_DECREF(result); }
3280 Py_DECREF(obj);
3285 Py_DECREF(obj);
3281 return;
3286 return;
3282 } else {
3287 } else {
3283 PyErr_Clear();
3288 PyErr_Clear();
3284 }
3289 }
3285 }
3290 }
3286 QHexSpinBox::leaveEvent(arg__1);
3291 QHexSpinBox::leaveEvent(arg__1);
3287 }
3292 }
3288 int PythonQtShell_QHexSpinBox::metric(QPaintDevice::PaintDeviceMetric arg__1) const
3293 int PythonQtShell_QHexSpinBox::metric(QPaintDevice::PaintDeviceMetric arg__1) const
3289 {
3294 {
3290 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3295 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3291 static PyObject* name = PyString_FromString("metric");
3296 static PyObject* name = PyString_FromString("metric");
3292 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3297 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3293 if (obj) {
3298 if (obj) {
3294 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
3299 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
3295 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3300 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3296 int returnValue;
3301 int returnValue;
3297 void* args[2] = {NULL, (void*)&arg__1};
3302 void* args[2] = {NULL, (void*)&arg__1};
3298 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3303 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3299 if (result) {
3304 if (result) {
3300 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3305 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3301 if (args[0]!=&returnValue) {
3306 if (args[0]!=&returnValue) {
3302 if (args[0]==NULL) {
3307 if (args[0]==NULL) {
3303 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
3308 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
3304 } else {
3309 } else {
3305 returnValue = *((int*)args[0]);
3310 returnValue = *((int*)args[0]);
3306 }
3311 }
3307 }
3312 }
3308 }
3313 }
3309 if (result) { Py_DECREF(result); }
3314 if (result) { Py_DECREF(result); }
3310 Py_DECREF(obj);
3315 Py_DECREF(obj);
3311 return returnValue;
3316 return returnValue;
3312 } else {
3317 } else {
3313 PyErr_Clear();
3318 PyErr_Clear();
3314 }
3319 }
3315 }
3320 }
3316 return QHexSpinBox::metric(arg__1);
3321 return QHexSpinBox::metric(arg__1);
3317 }
3322 }
3318 void PythonQtShell_QHexSpinBox::mouseDoubleClickEvent(QMouseEvent* arg__1)
3323 void PythonQtShell_QHexSpinBox::mouseDoubleClickEvent(QMouseEvent* arg__1)
3319 {
3324 {
3320 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3325 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3321 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
3326 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
3322 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3327 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3323 if (obj) {
3328 if (obj) {
3324 static const char* argumentList[] ={"" , "QMouseEvent*"};
3329 static const char* argumentList[] ={"" , "QMouseEvent*"};
3325 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3330 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3326 void* args[2] = {NULL, (void*)&arg__1};
3331 void* args[2] = {NULL, (void*)&arg__1};
3327 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3332 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3328 if (result) { Py_DECREF(result); }
3333 if (result) { Py_DECREF(result); }
3329 Py_DECREF(obj);
3334 Py_DECREF(obj);
3330 return;
3335 return;
3331 } else {
3336 } else {
3332 PyErr_Clear();
3337 PyErr_Clear();
3333 }
3338 }
3334 }
3339 }
3335 QHexSpinBox::mouseDoubleClickEvent(arg__1);
3340 QHexSpinBox::mouseDoubleClickEvent(arg__1);
3336 }
3341 }
3337 void PythonQtShell_QHexSpinBox::mouseMoveEvent(QMouseEvent* event0)
3342 void PythonQtShell_QHexSpinBox::mouseMoveEvent(QMouseEvent* event0)
3338 {
3343 {
3339 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3344 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3340 static PyObject* name = PyString_FromString("mouseMoveEvent");
3345 static PyObject* name = PyString_FromString("mouseMoveEvent");
3341 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3346 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3342 if (obj) {
3347 if (obj) {
3343 static const char* argumentList[] ={"" , "QMouseEvent*"};
3348 static const char* argumentList[] ={"" , "QMouseEvent*"};
3344 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3349 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3345 void* args[2] = {NULL, (void*)&event0};
3350 void* args[2] = {NULL, (void*)&event0};
3346 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3351 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3347 if (result) { Py_DECREF(result); }
3352 if (result) { Py_DECREF(result); }
3348 Py_DECREF(obj);
3353 Py_DECREF(obj);
3349 return;
3354 return;
3350 } else {
3355 } else {
3351 PyErr_Clear();
3356 PyErr_Clear();
3352 }
3357 }
3353 }
3358 }
3354 QHexSpinBox::mouseMoveEvent(event0);
3359 QHexSpinBox::mouseMoveEvent(event0);
3355 }
3360 }
3356 void PythonQtShell_QHexSpinBox::mousePressEvent(QMouseEvent* event0)
3361 void PythonQtShell_QHexSpinBox::mousePressEvent(QMouseEvent* event0)
3357 {
3362 {
3358 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3363 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3359 static PyObject* name = PyString_FromString("mousePressEvent");
3364 static PyObject* name = PyString_FromString("mousePressEvent");
3360 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3365 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3361 if (obj) {
3366 if (obj) {
3362 static const char* argumentList[] ={"" , "QMouseEvent*"};
3367 static const char* argumentList[] ={"" , "QMouseEvent*"};
3363 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3368 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3364 void* args[2] = {NULL, (void*)&event0};
3369 void* args[2] = {NULL, (void*)&event0};
3365 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3370 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3366 if (result) { Py_DECREF(result); }
3371 if (result) { Py_DECREF(result); }
3367 Py_DECREF(obj);
3372 Py_DECREF(obj);
3368 return;
3373 return;
3369 } else {
3374 } else {
3370 PyErr_Clear();
3375 PyErr_Clear();
3371 }
3376 }
3372 }
3377 }
3373 QHexSpinBox::mousePressEvent(event0);
3378 QHexSpinBox::mousePressEvent(event0);
3374 }
3379 }
3375 void PythonQtShell_QHexSpinBox::mouseReleaseEvent(QMouseEvent* event0)
3380 void PythonQtShell_QHexSpinBox::mouseReleaseEvent(QMouseEvent* event0)
3376 {
3381 {
3377 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3382 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3378 static PyObject* name = PyString_FromString("mouseReleaseEvent");
3383 static PyObject* name = PyString_FromString("mouseReleaseEvent");
3379 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3384 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3380 if (obj) {
3385 if (obj) {
3381 static const char* argumentList[] ={"" , "QMouseEvent*"};
3386 static const char* argumentList[] ={"" , "QMouseEvent*"};
3382 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3387 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3383 void* args[2] = {NULL, (void*)&event0};
3388 void* args[2] = {NULL, (void*)&event0};
3384 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3389 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3385 if (result) { Py_DECREF(result); }
3390 if (result) { Py_DECREF(result); }
3386 Py_DECREF(obj);
3391 Py_DECREF(obj);
3387 return;
3392 return;
3388 } else {
3393 } else {
3389 PyErr_Clear();
3394 PyErr_Clear();
3390 }
3395 }
3391 }
3396 }
3392 QHexSpinBox::mouseReleaseEvent(event0);
3397 QHexSpinBox::mouseReleaseEvent(event0);
3393 }
3398 }
3394 void PythonQtShell_QHexSpinBox::moveEvent(QMoveEvent* arg__1)
3399 void PythonQtShell_QHexSpinBox::moveEvent(QMoveEvent* arg__1)
3395 {
3400 {
3396 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3401 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3397 static PyObject* name = PyString_FromString("moveEvent");
3402 static PyObject* name = PyString_FromString("moveEvent");
3398 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3403 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3399 if (obj) {
3404 if (obj) {
3400 static const char* argumentList[] ={"" , "QMoveEvent*"};
3405 static const char* argumentList[] ={"" , "QMoveEvent*"};
3401 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3406 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3402 void* args[2] = {NULL, (void*)&arg__1};
3407 void* args[2] = {NULL, (void*)&arg__1};
3403 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3408 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3404 if (result) { Py_DECREF(result); }
3409 if (result) { Py_DECREF(result); }
3405 Py_DECREF(obj);
3410 Py_DECREF(obj);
3406 return;
3411 return;
3407 } else {
3412 } else {
3408 PyErr_Clear();
3413 PyErr_Clear();
3409 }
3414 }
3410 }
3415 }
3411 QHexSpinBox::moveEvent(arg__1);
3416 QHexSpinBox::moveEvent(arg__1);
3412 }
3417 }
3413 bool PythonQtShell_QHexSpinBox::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
3418 bool PythonQtShell_QHexSpinBox::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
3414 {
3419 {
3415 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3420 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3416 static PyObject* name = PyString_FromString("nativeEvent");
3421 static PyObject* name = PyString_FromString("nativeEvent");
3417 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3422 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3418 if (obj) {
3423 if (obj) {
3419 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
3424 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
3420 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
3425 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
3421 bool returnValue;
3426 bool returnValue;
3422 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
3427 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
3423 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3428 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3424 if (result) {
3429 if (result) {
3425 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3430 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3426 if (args[0]!=&returnValue) {
3431 if (args[0]!=&returnValue) {
3427 if (args[0]==NULL) {
3432 if (args[0]==NULL) {
3428 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
3433 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
3429 } else {
3434 } else {
3430 returnValue = *((bool*)args[0]);
3435 returnValue = *((bool*)args[0]);
3431 }
3436 }
3432 }
3437 }
3433 }
3438 }
3434 if (result) { Py_DECREF(result); }
3439 if (result) { Py_DECREF(result); }
3435 Py_DECREF(obj);
3440 Py_DECREF(obj);
3436 return returnValue;
3441 return returnValue;
3437 } else {
3442 } else {
3438 PyErr_Clear();
3443 PyErr_Clear();
3439 }
3444 }
3440 }
3445 }
3441 return QHexSpinBox::nativeEvent(eventType0, message1, result2);
3446 return QHexSpinBox::nativeEvent(eventType0, message1, result2);
3442 }
3447 }
3443 QPaintEngine* PythonQtShell_QHexSpinBox::paintEngine() const
3448 QPaintEngine* PythonQtShell_QHexSpinBox::paintEngine() const
3444 {
3449 {
3445 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3450 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3446 static PyObject* name = PyString_FromString("paintEngine");
3451 static PyObject* name = PyString_FromString("paintEngine");
3447 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3452 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3448 if (obj) {
3453 if (obj) {
3449 static const char* argumentList[] ={"QPaintEngine*"};
3454 static const char* argumentList[] ={"QPaintEngine*"};
3450 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3455 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3451 QPaintEngine* returnValue;
3456 QPaintEngine* returnValue;
3452 void* args[1] = {NULL};
3457 void* args[1] = {NULL};
3453 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3458 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3454 if (result) {
3459 if (result) {
3455 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3460 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3456 if (args[0]!=&returnValue) {
3461 if (args[0]!=&returnValue) {
3457 if (args[0]==NULL) {
3462 if (args[0]==NULL) {
3458 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
3463 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
3459 } else {
3464 } else {
3460 returnValue = *((QPaintEngine**)args[0]);
3465 returnValue = *((QPaintEngine**)args[0]);
3461 }
3466 }
3462 }
3467 }
3463 }
3468 }
3464 if (result) { Py_DECREF(result); }
3469 if (result) { Py_DECREF(result); }
3465 Py_DECREF(obj);
3470 Py_DECREF(obj);
3466 return returnValue;
3471 return returnValue;
3467 } else {
3472 } else {
3468 PyErr_Clear();
3473 PyErr_Clear();
3469 }
3474 }
3470 }
3475 }
3471 return QHexSpinBox::paintEngine();
3476 return QHexSpinBox::paintEngine();
3472 }
3477 }
3473 void PythonQtShell_QHexSpinBox::paintEvent(QPaintEvent* event0)
3478 void PythonQtShell_QHexSpinBox::paintEvent(QPaintEvent* event0)
3474 {
3479 {
3475 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3480 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3476 static PyObject* name = PyString_FromString("paintEvent");
3481 static PyObject* name = PyString_FromString("paintEvent");
3477 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3482 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3478 if (obj) {
3483 if (obj) {
3479 static const char* argumentList[] ={"" , "QPaintEvent*"};
3484 static const char* argumentList[] ={"" , "QPaintEvent*"};
3480 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3485 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3481 void* args[2] = {NULL, (void*)&event0};
3486 void* args[2] = {NULL, (void*)&event0};
3482 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3487 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3483 if (result) { Py_DECREF(result); }
3488 if (result) { Py_DECREF(result); }
3484 Py_DECREF(obj);
3489 Py_DECREF(obj);
3485 return;
3490 return;
3486 } else {
3491 } else {
3487 PyErr_Clear();
3492 PyErr_Clear();
3488 }
3493 }
3489 }
3494 }
3490 QHexSpinBox::paintEvent(event0);
3495 QHexSpinBox::paintEvent(event0);
3491 }
3496 }
3492 QPaintDevice* PythonQtShell_QHexSpinBox::redirected(QPoint* offset0) const
3497 QPaintDevice* PythonQtShell_QHexSpinBox::redirected(QPoint* offset0) const
3493 {
3498 {
3494 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3499 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3495 static PyObject* name = PyString_FromString("redirected");
3500 static PyObject* name = PyString_FromString("redirected");
3496 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3501 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3497 if (obj) {
3502 if (obj) {
3498 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
3503 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
3499 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3504 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3500 QPaintDevice* returnValue;
3505 QPaintDevice* returnValue;
3501 void* args[2] = {NULL, (void*)&offset0};
3506 void* args[2] = {NULL, (void*)&offset0};
3502 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3507 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3503 if (result) {
3508 if (result) {
3504 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3509 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3505 if (args[0]!=&returnValue) {
3510 if (args[0]!=&returnValue) {
3506 if (args[0]==NULL) {
3511 if (args[0]==NULL) {
3507 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
3512 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
3508 } else {
3513 } else {
3509 returnValue = *((QPaintDevice**)args[0]);
3514 returnValue = *((QPaintDevice**)args[0]);
3510 }
3515 }
3511 }
3516 }
3512 }
3517 }
3513 if (result) { Py_DECREF(result); }
3518 if (result) { Py_DECREF(result); }
3514 Py_DECREF(obj);
3519 Py_DECREF(obj);
3515 return returnValue;
3520 return returnValue;
3516 } else {
3521 } else {
3517 PyErr_Clear();
3522 PyErr_Clear();
3518 }
3523 }
3519 }
3524 }
3520 return QHexSpinBox::redirected(offset0);
3525 return QHexSpinBox::redirected(offset0);
3521 }
3526 }
3522 void PythonQtShell_QHexSpinBox::resizeEvent(QResizeEvent* event0)
3527 void PythonQtShell_QHexSpinBox::resizeEvent(QResizeEvent* event0)
3523 {
3528 {
3524 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3529 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3525 static PyObject* name = PyString_FromString("resizeEvent");
3530 static PyObject* name = PyString_FromString("resizeEvent");
3526 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3531 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3527 if (obj) {
3532 if (obj) {
3528 static const char* argumentList[] ={"" , "QResizeEvent*"};
3533 static const char* argumentList[] ={"" , "QResizeEvent*"};
3529 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3534 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3530 void* args[2] = {NULL, (void*)&event0};
3535 void* args[2] = {NULL, (void*)&event0};
3531 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3536 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3532 if (result) { Py_DECREF(result); }
3537 if (result) { Py_DECREF(result); }
3533 Py_DECREF(obj);
3538 Py_DECREF(obj);
3534 return;
3539 return;
3535 } else {
3540 } else {
3536 PyErr_Clear();
3541 PyErr_Clear();
3537 }
3542 }
3538 }
3543 }
3539 QHexSpinBox::resizeEvent(event0);
3544 QHexSpinBox::resizeEvent(event0);
3540 }
3545 }
3541 QPainter* PythonQtShell_QHexSpinBox::sharedPainter() const
3546 QPainter* PythonQtShell_QHexSpinBox::sharedPainter() const
3542 {
3547 {
3543 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3548 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3544 static PyObject* name = PyString_FromString("sharedPainter");
3549 static PyObject* name = PyString_FromString("sharedPainter");
3545 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3550 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3546 if (obj) {
3551 if (obj) {
3547 static const char* argumentList[] ={"QPainter*"};
3552 static const char* argumentList[] ={"QPainter*"};
3548 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3553 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3549 QPainter* returnValue;
3554 QPainter* returnValue;
3550 void* args[1] = {NULL};
3555 void* args[1] = {NULL};
3551 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3556 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3552 if (result) {
3557 if (result) {
3553 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3558 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3554 if (args[0]!=&returnValue) {
3559 if (args[0]!=&returnValue) {
3555 if (args[0]==NULL) {
3560 if (args[0]==NULL) {
3556 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
3561 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
3557 } else {
3562 } else {
3558 returnValue = *((QPainter**)args[0]);
3563 returnValue = *((QPainter**)args[0]);
3559 }
3564 }
3560 }
3565 }
3561 }
3566 }
3562 if (result) { Py_DECREF(result); }
3567 if (result) { Py_DECREF(result); }
3563 Py_DECREF(obj);
3568 Py_DECREF(obj);
3564 return returnValue;
3569 return returnValue;
3565 } else {
3570 } else {
3566 PyErr_Clear();
3571 PyErr_Clear();
3567 }
3572 }
3568 }
3573 }
3569 return QHexSpinBox::sharedPainter();
3574 return QHexSpinBox::sharedPainter();
3570 }
3575 }
3571 void PythonQtShell_QHexSpinBox::showEvent(QShowEvent* event0)
3576 void PythonQtShell_QHexSpinBox::showEvent(QShowEvent* event0)
3572 {
3577 {
3573 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3578 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3574 static PyObject* name = PyString_FromString("showEvent");
3579 static PyObject* name = PyString_FromString("showEvent");
3575 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3580 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3576 if (obj) {
3581 if (obj) {
3577 static const char* argumentList[] ={"" , "QShowEvent*"};
3582 static const char* argumentList[] ={"" , "QShowEvent*"};
3578 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3583 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3579 void* args[2] = {NULL, (void*)&event0};
3584 void* args[2] = {NULL, (void*)&event0};
3580 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3585 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3581 if (result) { Py_DECREF(result); }
3586 if (result) { Py_DECREF(result); }
3582 Py_DECREF(obj);
3587 Py_DECREF(obj);
3583 return;
3588 return;
3584 } else {
3589 } else {
3585 PyErr_Clear();
3590 PyErr_Clear();
3586 }
3591 }
3587 }
3592 }
3588 QHexSpinBox::showEvent(event0);
3593 QHexSpinBox::showEvent(event0);
3589 }
3594 }
3590 void PythonQtShell_QHexSpinBox::stepBy(int steps0)
3595 void PythonQtShell_QHexSpinBox::stepBy(int steps0)
3591 {
3596 {
3592 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3597 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3593 static PyObject* name = PyString_FromString("stepBy");
3598 static PyObject* name = PyString_FromString("stepBy");
3594 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3599 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3595 if (obj) {
3600 if (obj) {
3596 static const char* argumentList[] ={"" , "int"};
3601 static const char* argumentList[] ={"" , "int"};
3597 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3602 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3598 void* args[2] = {NULL, (void*)&steps0};
3603 void* args[2] = {NULL, (void*)&steps0};
3599 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3604 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3600 if (result) { Py_DECREF(result); }
3605 if (result) { Py_DECREF(result); }
3601 Py_DECREF(obj);
3606 Py_DECREF(obj);
3602 return;
3607 return;
3603 } else {
3608 } else {
3604 PyErr_Clear();
3609 PyErr_Clear();
3605 }
3610 }
3606 }
3611 }
3607 QHexSpinBox::stepBy(steps0);
3612 QHexSpinBox::stepBy(steps0);
3608 }
3613 }
3609 QAbstractSpinBox::StepEnabled PythonQtShell_QHexSpinBox::stepEnabled() const
3614 QAbstractSpinBox::StepEnabled PythonQtShell_QHexSpinBox::stepEnabled() const
3610 {
3615 {
3611 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3616 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3612 static PyObject* name = PyString_FromString("stepEnabled");
3617 static PyObject* name = PyString_FromString("stepEnabled");
3613 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3618 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3614 if (obj) {
3619 if (obj) {
3615 static const char* argumentList[] ={"QAbstractSpinBox::StepEnabled"};
3620 static const char* argumentList[] ={"QAbstractSpinBox::StepEnabled"};
3616 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3621 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3617 QAbstractSpinBox::StepEnabled returnValue;
3622 QAbstractSpinBox::StepEnabled returnValue;
3618 void* args[1] = {NULL};
3623 void* args[1] = {NULL};
3619 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3624 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3620 if (result) {
3625 if (result) {
3621 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3626 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3622 if (args[0]!=&returnValue) {
3627 if (args[0]!=&returnValue) {
3623 if (args[0]==NULL) {
3628 if (args[0]==NULL) {
3624 PythonQt::priv()->handleVirtualOverloadReturnError("stepEnabled", methodInfo, result);
3629 PythonQt::priv()->handleVirtualOverloadReturnError("stepEnabled", methodInfo, result);
3625 } else {
3630 } else {
3626 returnValue = *((QAbstractSpinBox::StepEnabled*)args[0]);
3631 returnValue = *((QAbstractSpinBox::StepEnabled*)args[0]);
3627 }
3632 }
3628 }
3633 }
3629 }
3634 }
3630 if (result) { Py_DECREF(result); }
3635 if (result) { Py_DECREF(result); }
3631 Py_DECREF(obj);
3636 Py_DECREF(obj);
3632 return returnValue;
3637 return returnValue;
3633 } else {
3638 } else {
3634 PyErr_Clear();
3639 PyErr_Clear();
3635 }
3640 }
3636 }
3641 }
3637 return QHexSpinBox::stepEnabled();
3642 return QHexSpinBox::stepEnabled();
3638 }
3643 }
3639 void PythonQtShell_QHexSpinBox::tabletEvent(QTabletEvent* arg__1)
3644 void PythonQtShell_QHexSpinBox::tabletEvent(QTabletEvent* arg__1)
3640 {
3645 {
3641 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3646 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3642 static PyObject* name = PyString_FromString("tabletEvent");
3647 static PyObject* name = PyString_FromString("tabletEvent");
3643 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3648 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3644 if (obj) {
3649 if (obj) {
3645 static const char* argumentList[] ={"" , "QTabletEvent*"};
3650 static const char* argumentList[] ={"" , "QTabletEvent*"};
3646 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3651 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3647 void* args[2] = {NULL, (void*)&arg__1};
3652 void* args[2] = {NULL, (void*)&arg__1};
3648 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3653 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3649 if (result) { Py_DECREF(result); }
3654 if (result) { Py_DECREF(result); }
3650 Py_DECREF(obj);
3655 Py_DECREF(obj);
3651 return;
3656 return;
3652 } else {
3657 } else {
3653 PyErr_Clear();
3658 PyErr_Clear();
3654 }
3659 }
3655 }
3660 }
3656 QHexSpinBox::tabletEvent(arg__1);
3661 QHexSpinBox::tabletEvent(arg__1);
3657 }
3662 }
3658 QString PythonQtShell_QHexSpinBox::textFromValue(int value0) const
3663 QString PythonQtShell_QHexSpinBox::textFromValue(int value0) const
3659 {
3664 {
3660 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3665 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3661 static PyObject* name = PyString_FromString("textFromValue");
3666 static PyObject* name = PyString_FromString("textFromValue");
3662 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3667 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3663 if (obj) {
3668 if (obj) {
3664 static const char* argumentList[] ={"QString" , "int"};
3669 static const char* argumentList[] ={"QString" , "int"};
3665 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3670 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3666 QString returnValue;
3671 QString returnValue;
3667 void* args[2] = {NULL, (void*)&value0};
3672 void* args[2] = {NULL, (void*)&value0};
3668 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3673 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3669 if (result) {
3674 if (result) {
3670 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3675 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3671 if (args[0]!=&returnValue) {
3676 if (args[0]!=&returnValue) {
3672 if (args[0]==NULL) {
3677 if (args[0]==NULL) {
3673 PythonQt::priv()->handleVirtualOverloadReturnError("textFromValue", methodInfo, result);
3678 PythonQt::priv()->handleVirtualOverloadReturnError("textFromValue", methodInfo, result);
3674 } else {
3679 } else {
3675 returnValue = *((QString*)args[0]);
3680 returnValue = *((QString*)args[0]);
3676 }
3681 }
3677 }
3682 }
3678 }
3683 }
3679 if (result) { Py_DECREF(result); }
3684 if (result) { Py_DECREF(result); }
3680 Py_DECREF(obj);
3685 Py_DECREF(obj);
3681 return returnValue;
3686 return returnValue;
3682 } else {
3687 } else {
3683 PyErr_Clear();
3688 PyErr_Clear();
3684 }
3689 }
3685 }
3690 }
3686 return QHexSpinBox::textFromValue(value0);
3691 return QHexSpinBox::textFromValue(value0);
3687 }
3692 }
3688 void PythonQtShell_QHexSpinBox::timerEvent(QTimerEvent* event0)
3693 void PythonQtShell_QHexSpinBox::timerEvent(QTimerEvent* event0)
3689 {
3694 {
3690 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3695 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3691 static PyObject* name = PyString_FromString("timerEvent");
3696 static PyObject* name = PyString_FromString("timerEvent");
3692 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3697 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3693 if (obj) {
3698 if (obj) {
3694 static const char* argumentList[] ={"" , "QTimerEvent*"};
3699 static const char* argumentList[] ={"" , "QTimerEvent*"};
3695 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3700 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3696 void* args[2] = {NULL, (void*)&event0};
3701 void* args[2] = {NULL, (void*)&event0};
3697 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3702 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3698 if (result) { Py_DECREF(result); }
3703 if (result) { Py_DECREF(result); }
3699 Py_DECREF(obj);
3704 Py_DECREF(obj);
3700 return;
3705 return;
3701 } else {
3706 } else {
3702 PyErr_Clear();
3707 PyErr_Clear();
3703 }
3708 }
3704 }
3709 }
3705 QHexSpinBox::timerEvent(event0);
3710 QHexSpinBox::timerEvent(event0);
3706 }
3711 }
3707 QValidator::State PythonQtShell_QHexSpinBox::validate(QString& input0, int& pos1) const
3712 QValidator::State PythonQtShell_QHexSpinBox::validate(QString& input0, int& pos1) const
3708 {
3713 {
3709 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3714 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3710 static PyObject* name = PyString_FromString("validate");
3715 static PyObject* name = PyString_FromString("validate");
3711 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3716 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3712 if (obj) {
3717 if (obj) {
3713 static const char* argumentList[] ={"QValidator::State" , "QString&" , "int&"};
3718 static const char* argumentList[] ={"QValidator::State" , "QString&" , "int&"};
3714 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3719 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3715 QValidator::State returnValue;
3720 QValidator::State returnValue;
3716 void* args[3] = {NULL, (void*)&input0, (void*)&pos1};
3721 void* args[3] = {NULL, (void*)&input0, (void*)&pos1};
3717 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3722 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3718 if (result) {
3723 if (result) {
3719 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3724 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3720 if (args[0]!=&returnValue) {
3725 if (args[0]!=&returnValue) {
3721 if (args[0]==NULL) {
3726 if (args[0]==NULL) {
3722 PythonQt::priv()->handleVirtualOverloadReturnError("validate", methodInfo, result);
3727 PythonQt::priv()->handleVirtualOverloadReturnError("validate", methodInfo, result);
3723 } else {
3728 } else {
3724 returnValue = *((QValidator::State*)args[0]);
3729 returnValue = *((QValidator::State*)args[0]);
3725 }
3730 }
3726 }
3731 }
3727 }
3732 }
3728 if (result) { Py_DECREF(result); }
3733 if (result) { Py_DECREF(result); }
3729 Py_DECREF(obj);
3734 Py_DECREF(obj);
3730 return returnValue;
3735 return returnValue;
3731 } else {
3736 } else {
3732 PyErr_Clear();
3737 PyErr_Clear();
3733 }
3738 }
3734 }
3739 }
3735 return QHexSpinBox::validate(input0, pos1);
3740 return QHexSpinBox::validate(input0, pos1);
3736 }
3741 }
3737 int PythonQtShell_QHexSpinBox::valueFromText(const QString& text0) const
3742 int PythonQtShell_QHexSpinBox::valueFromText(const QString& text0) const
3738 {
3743 {
3739 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3744 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3740 static PyObject* name = PyString_FromString("valueFromText");
3745 static PyObject* name = PyString_FromString("valueFromText");
3741 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3746 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3742 if (obj) {
3747 if (obj) {
3743 static const char* argumentList[] ={"int" , "const QString&"};
3748 static const char* argumentList[] ={"int" , "const QString&"};
3744 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3749 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3745 int returnValue;
3750 int returnValue;
3746 void* args[2] = {NULL, (void*)&text0};
3751 void* args[2] = {NULL, (void*)&text0};
3747 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3752 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3748 if (result) {
3753 if (result) {
3749 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3754 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3750 if (args[0]!=&returnValue) {
3755 if (args[0]!=&returnValue) {
3751 if (args[0]==NULL) {
3756 if (args[0]==NULL) {
3752 PythonQt::priv()->handleVirtualOverloadReturnError("valueFromText", methodInfo, result);
3757 PythonQt::priv()->handleVirtualOverloadReturnError("valueFromText", methodInfo, result);
3753 } else {
3758 } else {
3754 returnValue = *((int*)args[0]);
3759 returnValue = *((int*)args[0]);
3755 }
3760 }
3756 }
3761 }
3757 }
3762 }
3758 if (result) { Py_DECREF(result); }
3763 if (result) { Py_DECREF(result); }
3759 Py_DECREF(obj);
3764 Py_DECREF(obj);
3760 return returnValue;
3765 return returnValue;
3761 } else {
3766 } else {
3762 PyErr_Clear();
3767 PyErr_Clear();
3763 }
3768 }
3764 }
3769 }
3765 return QHexSpinBox::valueFromText(text0);
3770 return QHexSpinBox::valueFromText(text0);
3766 }
3771 }
3767 void PythonQtShell_QHexSpinBox::wheelEvent(QWheelEvent* event0)
3772 void PythonQtShell_QHexSpinBox::wheelEvent(QWheelEvent* event0)
3768 {
3773 {
3769 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3774 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3770 static PyObject* name = PyString_FromString("wheelEvent");
3775 static PyObject* name = PyString_FromString("wheelEvent");
3771 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3776 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3772 if (obj) {
3777 if (obj) {
3773 static const char* argumentList[] ={"" , "QWheelEvent*"};
3778 static const char* argumentList[] ={"" , "QWheelEvent*"};
3774 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3779 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3775 void* args[2] = {NULL, (void*)&event0};
3780 void* args[2] = {NULL, (void*)&event0};
3776 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3781 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3777 if (result) { Py_DECREF(result); }
3782 if (result) { Py_DECREF(result); }
3778 Py_DECREF(obj);
3783 Py_DECREF(obj);
3779 return;
3784 return;
3780 } else {
3785 } else {
3781 PyErr_Clear();
3786 PyErr_Clear();
3782 }
3787 }
3783 }
3788 }
3784 QHexSpinBox::wheelEvent(event0);
3789 QHexSpinBox::wheelEvent(event0);
3785 }
3790 }
3786 QHexSpinBox* PythonQtWrapper_QHexSpinBox::new_QHexSpinBox(QWidget* parent)
3791 QHexSpinBox* PythonQtWrapper_QHexSpinBox::new_QHexSpinBox(QWidget* parent)
3787 {
3792 {
3788 return new PythonQtShell_QHexSpinBox(parent); }
3793 return new PythonQtShell_QHexSpinBox(parent); }
3789
3794
3790 void PythonQtWrapper_QHexSpinBox::show(QHexSpinBox* theWrappedObject)
3795 void PythonQtWrapper_QHexSpinBox::show(QHexSpinBox* theWrappedObject)
3791 {
3796 {
3792 ( theWrappedObject->show());
3797 ( theWrappedObject->show());
3793 }
3798 }
3794
3799
3795 QString PythonQtWrapper_QHexSpinBox::textFromValue(QHexSpinBox* theWrappedObject, int value) const
3800 QString PythonQtWrapper_QHexSpinBox::textFromValue(QHexSpinBox* theWrappedObject, int value) const
3796 {
3801 {
3797 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_textFromValue(value));
3802 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_textFromValue(value));
3798 }
3803 }
3799
3804
3800 QValidator::State PythonQtWrapper_QHexSpinBox::validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const
3805 QValidator::State PythonQtWrapper_QHexSpinBox::validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const
3801 {
3806 {
3802 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_validate(input, pos));
3807 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_validate(input, pos));
3803 }
3808 }
3804
3809
3805 int PythonQtWrapper_QHexSpinBox::valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const
3810 int PythonQtWrapper_QHexSpinBox::valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const
3806 {
3811 {
3807 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_valueFromText(text));
3812 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_valueFromText(text));
3808 }
3813 }
3809
3814
3810
3815
3811
3816
3812 PythonQtShell_SocExplorerPlot::~PythonQtShell_SocExplorerPlot() {
3817 PythonQtShell_SocExplorerPlot::~PythonQtShell_SocExplorerPlot() {
3813 PythonQtPrivate* priv = PythonQt::priv();
3818 PythonQtPrivate* priv = PythonQt::priv();
3814 if (priv) { priv->shellClassDeleted(this); }
3819 if (priv) { priv->shellClassDeleted(this); }
3815 }
3820 }
3816 void PythonQtShell_SocExplorerPlot::actionEvent(QActionEvent* arg__1)
3821 void PythonQtShell_SocExplorerPlot::actionEvent(QActionEvent* arg__1)
3817 {
3822 {
3818 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3823 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3819 static PyObject* name = PyString_FromString("actionEvent");
3824 static PyObject* name = PyString_FromString("actionEvent");
3820 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3825 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3821 if (obj) {
3826 if (obj) {
3822 static const char* argumentList[] ={"" , "QActionEvent*"};
3827 static const char* argumentList[] ={"" , "QActionEvent*"};
3823 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3828 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3824 void* args[2] = {NULL, (void*)&arg__1};
3829 void* args[2] = {NULL, (void*)&arg__1};
3825 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3830 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3826 if (result) { Py_DECREF(result); }
3831 if (result) { Py_DECREF(result); }
3827 Py_DECREF(obj);
3832 Py_DECREF(obj);
3828 return;
3833 return;
3829 } else {
3834 } else {
3830 PyErr_Clear();
3835 PyErr_Clear();
3831 }
3836 }
3832 }
3837 }
3833 SocExplorerPlot::actionEvent(arg__1);
3838 SocExplorerPlot::actionEvent(arg__1);
3834 }
3839 }
3835 void PythonQtShell_SocExplorerPlot::changeEvent(QEvent* arg__1)
3840 void PythonQtShell_SocExplorerPlot::changeEvent(QEvent* arg__1)
3836 {
3841 {
3837 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3842 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3838 static PyObject* name = PyString_FromString("changeEvent");
3843 static PyObject* name = PyString_FromString("changeEvent");
3839 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3844 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3840 if (obj) {
3845 if (obj) {
3841 static const char* argumentList[] ={"" , "QEvent*"};
3846 static const char* argumentList[] ={"" , "QEvent*"};
3842 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3847 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3843 void* args[2] = {NULL, (void*)&arg__1};
3848 void* args[2] = {NULL, (void*)&arg__1};
3844 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3849 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3845 if (result) { Py_DECREF(result); }
3850 if (result) { Py_DECREF(result); }
3846 Py_DECREF(obj);
3851 Py_DECREF(obj);
3847 return;
3852 return;
3848 } else {
3853 } else {
3849 PyErr_Clear();
3854 PyErr_Clear();
3850 }
3855 }
3851 }
3856 }
3852 SocExplorerPlot::changeEvent(arg__1);
3857 SocExplorerPlot::changeEvent(arg__1);
3853 }
3858 }
3854 void PythonQtShell_SocExplorerPlot::childEvent(QChildEvent* arg__1)
3859 void PythonQtShell_SocExplorerPlot::childEvent(QChildEvent* arg__1)
3855 {
3860 {
3856 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3861 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3857 static PyObject* name = PyString_FromString("childEvent");
3862 static PyObject* name = PyString_FromString("childEvent");
3858 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3863 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3859 if (obj) {
3864 if (obj) {
3860 static const char* argumentList[] ={"" , "QChildEvent*"};
3865 static const char* argumentList[] ={"" , "QChildEvent*"};
3861 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3866 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3862 void* args[2] = {NULL, (void*)&arg__1};
3867 void* args[2] = {NULL, (void*)&arg__1};
3863 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3868 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3864 if (result) { Py_DECREF(result); }
3869 if (result) { Py_DECREF(result); }
3865 Py_DECREF(obj);
3870 Py_DECREF(obj);
3866 return;
3871 return;
3867 } else {
3872 } else {
3868 PyErr_Clear();
3873 PyErr_Clear();
3869 }
3874 }
3870 }
3875 }
3871 SocExplorerPlot::childEvent(arg__1);
3876 SocExplorerPlot::childEvent(arg__1);
3872 }
3877 }
3873 void PythonQtShell_SocExplorerPlot::closeEvent(QCloseEvent* arg__1)
3878 void PythonQtShell_SocExplorerPlot::closeEvent(QCloseEvent* arg__1)
3874 {
3879 {
3875 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3880 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3876 static PyObject* name = PyString_FromString("closeEvent");
3881 static PyObject* name = PyString_FromString("closeEvent");
3877 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3882 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3878 if (obj) {
3883 if (obj) {
3879 static const char* argumentList[] ={"" , "QCloseEvent*"};
3884 static const char* argumentList[] ={"" , "QCloseEvent*"};
3880 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3885 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3881 void* args[2] = {NULL, (void*)&arg__1};
3886 void* args[2] = {NULL, (void*)&arg__1};
3882 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3887 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3883 if (result) { Py_DECREF(result); }
3888 if (result) { Py_DECREF(result); }
3884 Py_DECREF(obj);
3889 Py_DECREF(obj);
3885 return;
3890 return;
3886 } else {
3891 } else {
3887 PyErr_Clear();
3892 PyErr_Clear();
3888 }
3893 }
3889 }
3894 }
3890 SocExplorerPlot::closeEvent(arg__1);
3895 SocExplorerPlot::closeEvent(arg__1);
3891 }
3896 }
3892 void PythonQtShell_SocExplorerPlot::contextMenuEvent(QContextMenuEvent* arg__1)
3897 void PythonQtShell_SocExplorerPlot::contextMenuEvent(QContextMenuEvent* arg__1)
3893 {
3898 {
3894 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3899 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3895 static PyObject* name = PyString_FromString("contextMenuEvent");
3900 static PyObject* name = PyString_FromString("contextMenuEvent");
3896 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3901 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3897 if (obj) {
3902 if (obj) {
3898 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
3903 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
3899 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3904 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3900 void* args[2] = {NULL, (void*)&arg__1};
3905 void* args[2] = {NULL, (void*)&arg__1};
3901 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3906 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3902 if (result) { Py_DECREF(result); }
3907 if (result) { Py_DECREF(result); }
3903 Py_DECREF(obj);
3908 Py_DECREF(obj);
3904 return;
3909 return;
3905 } else {
3910 } else {
3906 PyErr_Clear();
3911 PyErr_Clear();
3907 }
3912 }
3908 }
3913 }
3909 SocExplorerPlot::contextMenuEvent(arg__1);
3914 SocExplorerPlot::contextMenuEvent(arg__1);
3910 }
3915 }
3911 void PythonQtShell_SocExplorerPlot::customEvent(QEvent* arg__1)
3916 void PythonQtShell_SocExplorerPlot::customEvent(QEvent* arg__1)
3912 {
3917 {
3913 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3918 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3914 static PyObject* name = PyString_FromString("customEvent");
3919 static PyObject* name = PyString_FromString("customEvent");
3915 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3920 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3916 if (obj) {
3921 if (obj) {
3917 static const char* argumentList[] ={"" , "QEvent*"};
3922 static const char* argumentList[] ={"" , "QEvent*"};
3918 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3923 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3919 void* args[2] = {NULL, (void*)&arg__1};
3924 void* args[2] = {NULL, (void*)&arg__1};
3920 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3925 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3921 if (result) { Py_DECREF(result); }
3926 if (result) { Py_DECREF(result); }
3922 Py_DECREF(obj);
3927 Py_DECREF(obj);
3923 return;
3928 return;
3924 } else {
3929 } else {
3925 PyErr_Clear();
3930 PyErr_Clear();
3926 }
3931 }
3927 }
3932 }
3928 SocExplorerPlot::customEvent(arg__1);
3933 SocExplorerPlot::customEvent(arg__1);
3929 }
3934 }
3930 int PythonQtShell_SocExplorerPlot::devType() const
3935 int PythonQtShell_SocExplorerPlot::devType() const
3931 {
3936 {
3932 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3937 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3933 static PyObject* name = PyString_FromString("devType");
3938 static PyObject* name = PyString_FromString("devType");
3934 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3939 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3935 if (obj) {
3940 if (obj) {
3936 static const char* argumentList[] ={"int"};
3941 static const char* argumentList[] ={"int"};
3937 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3942 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3938 int returnValue;
3943 int returnValue;
3939 void* args[1] = {NULL};
3944 void* args[1] = {NULL};
3940 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3945 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3941 if (result) {
3946 if (result) {
3942 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3947 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3943 if (args[0]!=&returnValue) {
3948 if (args[0]!=&returnValue) {
3944 if (args[0]==NULL) {
3949 if (args[0]==NULL) {
3945 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
3950 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
3946 } else {
3951 } else {
3947 returnValue = *((int*)args[0]);
3952 returnValue = *((int*)args[0]);
3948 }
3953 }
3949 }
3954 }
3950 }
3955 }
3951 if (result) { Py_DECREF(result); }
3956 if (result) { Py_DECREF(result); }
3952 Py_DECREF(obj);
3957 Py_DECREF(obj);
3953 return returnValue;
3958 return returnValue;
3954 } else {
3959 } else {
3955 PyErr_Clear();
3960 PyErr_Clear();
3956 }
3961 }
3957 }
3962 }
3958 return SocExplorerPlot::devType();
3963 return SocExplorerPlot::devType();
3959 }
3964 }
3960 void PythonQtShell_SocExplorerPlot::dragEnterEvent(QDragEnterEvent* arg__1)
3965 void PythonQtShell_SocExplorerPlot::dragEnterEvent(QDragEnterEvent* arg__1)
3961 {
3966 {
3962 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3967 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3963 static PyObject* name = PyString_FromString("dragEnterEvent");
3968 static PyObject* name = PyString_FromString("dragEnterEvent");
3964 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3969 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3965 if (obj) {
3970 if (obj) {
3966 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
3971 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
3967 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3972 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3968 void* args[2] = {NULL, (void*)&arg__1};
3973 void* args[2] = {NULL, (void*)&arg__1};
3969 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3974 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3970 if (result) { Py_DECREF(result); }
3975 if (result) { Py_DECREF(result); }
3971 Py_DECREF(obj);
3976 Py_DECREF(obj);
3972 return;
3977 return;
3973 } else {
3978 } else {
3974 PyErr_Clear();
3979 PyErr_Clear();
3975 }
3980 }
3976 }
3981 }
3977 SocExplorerPlot::dragEnterEvent(arg__1);
3982 SocExplorerPlot::dragEnterEvent(arg__1);
3978 }
3983 }
3979 void PythonQtShell_SocExplorerPlot::dragLeaveEvent(QDragLeaveEvent* arg__1)
3984 void PythonQtShell_SocExplorerPlot::dragLeaveEvent(QDragLeaveEvent* arg__1)
3980 {
3985 {
3981 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3986 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
3982 static PyObject* name = PyString_FromString("dragLeaveEvent");
3987 static PyObject* name = PyString_FromString("dragLeaveEvent");
3983 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3988 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
3984 if (obj) {
3989 if (obj) {
3985 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
3990 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
3986 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3991 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3987 void* args[2] = {NULL, (void*)&arg__1};
3992 void* args[2] = {NULL, (void*)&arg__1};
3988 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3993 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3989 if (result) { Py_DECREF(result); }
3994 if (result) { Py_DECREF(result); }
3990 Py_DECREF(obj);
3995 Py_DECREF(obj);
3991 return;
3996 return;
3992 } else {
3997 } else {
3993 PyErr_Clear();
3998 PyErr_Clear();
3994 }
3999 }
3995 }
4000 }
3996 SocExplorerPlot::dragLeaveEvent(arg__1);
4001 SocExplorerPlot::dragLeaveEvent(arg__1);
3997 }
4002 }
3998 void PythonQtShell_SocExplorerPlot::dragMoveEvent(QDragMoveEvent* arg__1)
4003 void PythonQtShell_SocExplorerPlot::dragMoveEvent(QDragMoveEvent* arg__1)
3999 {
4004 {
4000 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4005 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4001 static PyObject* name = PyString_FromString("dragMoveEvent");
4006 static PyObject* name = PyString_FromString("dragMoveEvent");
4002 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4007 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4003 if (obj) {
4008 if (obj) {
4004 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
4009 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
4005 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4010 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4006 void* args[2] = {NULL, (void*)&arg__1};
4011 void* args[2] = {NULL, (void*)&arg__1};
4007 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4012 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4008 if (result) { Py_DECREF(result); }
4013 if (result) { Py_DECREF(result); }
4009 Py_DECREF(obj);
4014 Py_DECREF(obj);
4010 return;
4015 return;
4011 } else {
4016 } else {
4012 PyErr_Clear();
4017 PyErr_Clear();
4013 }
4018 }
4014 }
4019 }
4015 SocExplorerPlot::dragMoveEvent(arg__1);
4020 SocExplorerPlot::dragMoveEvent(arg__1);
4016 }
4021 }
4017 void PythonQtShell_SocExplorerPlot::dropEvent(QDropEvent* arg__1)
4022 void PythonQtShell_SocExplorerPlot::dropEvent(QDropEvent* arg__1)
4018 {
4023 {
4019 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4024 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4020 static PyObject* name = PyString_FromString("dropEvent");
4025 static PyObject* name = PyString_FromString("dropEvent");
4021 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4026 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4022 if (obj) {
4027 if (obj) {
4023 static const char* argumentList[] ={"" , "QDropEvent*"};
4028 static const char* argumentList[] ={"" , "QDropEvent*"};
4024 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4029 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4025 void* args[2] = {NULL, (void*)&arg__1};
4030 void* args[2] = {NULL, (void*)&arg__1};
4026 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4031 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4027 if (result) { Py_DECREF(result); }
4032 if (result) { Py_DECREF(result); }
4028 Py_DECREF(obj);
4033 Py_DECREF(obj);
4029 return;
4034 return;
4030 } else {
4035 } else {
4031 PyErr_Clear();
4036 PyErr_Clear();
4032 }
4037 }
4033 }
4038 }
4034 SocExplorerPlot::dropEvent(arg__1);
4039 SocExplorerPlot::dropEvent(arg__1);
4035 }
4040 }
4036 void PythonQtShell_SocExplorerPlot::enterEvent(QEvent* arg__1)
4041 void PythonQtShell_SocExplorerPlot::enterEvent(QEvent* arg__1)
4037 {
4042 {
4038 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4043 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4039 static PyObject* name = PyString_FromString("enterEvent");
4044 static PyObject* name = PyString_FromString("enterEvent");
4040 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4045 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4041 if (obj) {
4046 if (obj) {
4042 static const char* argumentList[] ={"" , "QEvent*"};
4047 static const char* argumentList[] ={"" , "QEvent*"};
4043 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4048 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4044 void* args[2] = {NULL, (void*)&arg__1};
4049 void* args[2] = {NULL, (void*)&arg__1};
4045 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4050 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4046 if (result) { Py_DECREF(result); }
4051 if (result) { Py_DECREF(result); }
4047 Py_DECREF(obj);
4052 Py_DECREF(obj);
4048 return;
4053 return;
4049 } else {
4054 } else {
4050 PyErr_Clear();
4055 PyErr_Clear();
4051 }
4056 }
4052 }
4057 }
4053 SocExplorerPlot::enterEvent(arg__1);
4058 SocExplorerPlot::enterEvent(arg__1);
4054 }
4059 }
4055 bool PythonQtShell_SocExplorerPlot::event(QEvent* arg__1)
4060 bool PythonQtShell_SocExplorerPlot::event(QEvent* arg__1)
4056 {
4061 {
4057 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4062 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4058 static PyObject* name = PyString_FromString("event");
4063 static PyObject* name = PyString_FromString("event");
4059 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4064 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4060 if (obj) {
4065 if (obj) {
4061 static const char* argumentList[] ={"bool" , "QEvent*"};
4066 static const char* argumentList[] ={"bool" , "QEvent*"};
4062 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4067 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4063 bool returnValue;
4068 bool returnValue;
4064 void* args[2] = {NULL, (void*)&arg__1};
4069 void* args[2] = {NULL, (void*)&arg__1};
4065 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4070 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4066 if (result) {
4071 if (result) {
4067 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4072 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4068 if (args[0]!=&returnValue) {
4073 if (args[0]!=&returnValue) {
4069 if (args[0]==NULL) {
4074 if (args[0]==NULL) {
4070 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
4075 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
4071 } else {
4076 } else {
4072 returnValue = *((bool*)args[0]);
4077 returnValue = *((bool*)args[0]);
4073 }
4078 }
4074 }
4079 }
4075 }
4080 }
4076 if (result) { Py_DECREF(result); }
4081 if (result) { Py_DECREF(result); }
4077 Py_DECREF(obj);
4082 Py_DECREF(obj);
4078 return returnValue;
4083 return returnValue;
4079 } else {
4084 } else {
4080 PyErr_Clear();
4085 PyErr_Clear();
4081 }
4086 }
4082 }
4087 }
4083 return SocExplorerPlot::event(arg__1);
4088 return SocExplorerPlot::event(arg__1);
4084 }
4089 }
4085 bool PythonQtShell_SocExplorerPlot::eventFilter(QObject* arg__1, QEvent* arg__2)
4090 bool PythonQtShell_SocExplorerPlot::eventFilter(QObject* arg__1, QEvent* arg__2)
4086 {
4091 {
4087 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4092 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4088 static PyObject* name = PyString_FromString("eventFilter");
4093 static PyObject* name = PyString_FromString("eventFilter");
4089 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4094 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4090 if (obj) {
4095 if (obj) {
4091 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4096 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4092 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4097 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4093 bool returnValue;
4098 bool returnValue;
4094 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
4099 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
4095 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4100 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4096 if (result) {
4101 if (result) {
4097 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4102 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4098 if (args[0]!=&returnValue) {
4103 if (args[0]!=&returnValue) {
4099 if (args[0]==NULL) {
4104 if (args[0]==NULL) {
4100 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
4105 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
4101 } else {
4106 } else {
4102 returnValue = *((bool*)args[0]);
4107 returnValue = *((bool*)args[0]);
4103 }
4108 }
4104 }
4109 }
4105 }
4110 }
4106 if (result) { Py_DECREF(result); }
4111 if (result) { Py_DECREF(result); }
4107 Py_DECREF(obj);
4112 Py_DECREF(obj);
4108 return returnValue;
4113 return returnValue;
4109 } else {
4114 } else {
4110 PyErr_Clear();
4115 PyErr_Clear();
4111 }
4116 }
4112 }
4117 }
4113 return SocExplorerPlot::eventFilter(arg__1, arg__2);
4118 return SocExplorerPlot::eventFilter(arg__1, arg__2);
4114 }
4119 }
4115 void PythonQtShell_SocExplorerPlot::focusInEvent(QFocusEvent* arg__1)
4120 void PythonQtShell_SocExplorerPlot::focusInEvent(QFocusEvent* arg__1)
4116 {
4121 {
4117 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4122 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4118 static PyObject* name = PyString_FromString("focusInEvent");
4123 static PyObject* name = PyString_FromString("focusInEvent");
4119 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4124 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4120 if (obj) {
4125 if (obj) {
4121 static const char* argumentList[] ={"" , "QFocusEvent*"};
4126 static const char* argumentList[] ={"" , "QFocusEvent*"};
4122 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4127 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4123 void* args[2] = {NULL, (void*)&arg__1};
4128 void* args[2] = {NULL, (void*)&arg__1};
4124 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4129 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4125 if (result) { Py_DECREF(result); }
4130 if (result) { Py_DECREF(result); }
4126 Py_DECREF(obj);
4131 Py_DECREF(obj);
4127 return;
4132 return;
4128 } else {
4133 } else {
4129 PyErr_Clear();
4134 PyErr_Clear();
4130 }
4135 }
4131 }
4136 }
4132 SocExplorerPlot::focusInEvent(arg__1);
4137 SocExplorerPlot::focusInEvent(arg__1);
4133 }
4138 }
4134 bool PythonQtShell_SocExplorerPlot::focusNextPrevChild(bool next0)
4139 bool PythonQtShell_SocExplorerPlot::focusNextPrevChild(bool next0)
4135 {
4140 {
4136 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4141 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4137 static PyObject* name = PyString_FromString("focusNextPrevChild");
4142 static PyObject* name = PyString_FromString("focusNextPrevChild");
4138 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4143 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4139 if (obj) {
4144 if (obj) {
4140 static const char* argumentList[] ={"bool" , "bool"};
4145 static const char* argumentList[] ={"bool" , "bool"};
4141 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4146 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4142 bool returnValue;
4147 bool returnValue;
4143 void* args[2] = {NULL, (void*)&next0};
4148 void* args[2] = {NULL, (void*)&next0};
4144 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4149 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4145 if (result) {
4150 if (result) {
4146 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4151 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4147 if (args[0]!=&returnValue) {
4152 if (args[0]!=&returnValue) {
4148 if (args[0]==NULL) {
4153 if (args[0]==NULL) {
4149 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
4154 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
4150 } else {
4155 } else {
4151 returnValue = *((bool*)args[0]);
4156 returnValue = *((bool*)args[0]);
4152 }
4157 }
4153 }
4158 }
4154 }
4159 }
4155 if (result) { Py_DECREF(result); }
4160 if (result) { Py_DECREF(result); }
4156 Py_DECREF(obj);
4161 Py_DECREF(obj);
4157 return returnValue;
4162 return returnValue;
4158 } else {
4163 } else {
4159 PyErr_Clear();
4164 PyErr_Clear();
4160 }
4165 }
4161 }
4166 }
4162 return SocExplorerPlot::focusNextPrevChild(next0);
4167 return SocExplorerPlot::focusNextPrevChild(next0);
4163 }
4168 }
4164 void PythonQtShell_SocExplorerPlot::focusOutEvent(QFocusEvent* arg__1)
4169 void PythonQtShell_SocExplorerPlot::focusOutEvent(QFocusEvent* arg__1)
4165 {
4170 {
4166 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4171 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4167 static PyObject* name = PyString_FromString("focusOutEvent");
4172 static PyObject* name = PyString_FromString("focusOutEvent");
4168 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4173 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4169 if (obj) {
4174 if (obj) {
4170 static const char* argumentList[] ={"" , "QFocusEvent*"};
4175 static const char* argumentList[] ={"" , "QFocusEvent*"};
4171 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4176 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4172 void* args[2] = {NULL, (void*)&arg__1};
4177 void* args[2] = {NULL, (void*)&arg__1};
4173 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4178 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4174 if (result) { Py_DECREF(result); }
4179 if (result) { Py_DECREF(result); }
4175 Py_DECREF(obj);
4180 Py_DECREF(obj);
4176 return;
4181 return;
4177 } else {
4182 } else {
4178 PyErr_Clear();
4183 PyErr_Clear();
4179 }
4184 }
4180 }
4185 }
4181 SocExplorerPlot::focusOutEvent(arg__1);
4186 SocExplorerPlot::focusOutEvent(arg__1);
4182 }
4187 }
4183 bool PythonQtShell_SocExplorerPlot::hasHeightForWidth() const
4188 bool PythonQtShell_SocExplorerPlot::hasHeightForWidth() const
4184 {
4189 {
4185 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4190 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4186 static PyObject* name = PyString_FromString("hasHeightForWidth");
4191 static PyObject* name = PyString_FromString("hasHeightForWidth");
4187 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4192 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4188 if (obj) {
4193 if (obj) {
4189 static const char* argumentList[] ={"bool"};
4194 static const char* argumentList[] ={"bool"};
4190 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4195 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4191 bool returnValue;
4196 bool returnValue;
4192 void* args[1] = {NULL};
4197 void* args[1] = {NULL};
4193 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4198 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4194 if (result) {
4199 if (result) {
4195 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4200 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4196 if (args[0]!=&returnValue) {
4201 if (args[0]!=&returnValue) {
4197 if (args[0]==NULL) {
4202 if (args[0]==NULL) {
4198 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
4203 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
4199 } else {
4204 } else {
4200 returnValue = *((bool*)args[0]);
4205 returnValue = *((bool*)args[0]);
4201 }
4206 }
4202 }
4207 }
4203 }
4208 }
4204 if (result) { Py_DECREF(result); }
4209 if (result) { Py_DECREF(result); }
4205 Py_DECREF(obj);
4210 Py_DECREF(obj);
4206 return returnValue;
4211 return returnValue;
4207 } else {
4212 } else {
4208 PyErr_Clear();
4213 PyErr_Clear();
4209 }
4214 }
4210 }
4215 }
4211 return SocExplorerPlot::hasHeightForWidth();
4216 return SocExplorerPlot::hasHeightForWidth();
4212 }
4217 }
4213 int PythonQtShell_SocExplorerPlot::heightForWidth(int arg__1) const
4218 int PythonQtShell_SocExplorerPlot::heightForWidth(int arg__1) const
4214 {
4219 {
4215 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4220 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4216 static PyObject* name = PyString_FromString("heightForWidth");
4221 static PyObject* name = PyString_FromString("heightForWidth");
4217 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4222 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4218 if (obj) {
4223 if (obj) {
4219 static const char* argumentList[] ={"int" , "int"};
4224 static const char* argumentList[] ={"int" , "int"};
4220 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4225 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4221 int returnValue;
4226 int returnValue;
4222 void* args[2] = {NULL, (void*)&arg__1};
4227 void* args[2] = {NULL, (void*)&arg__1};
4223 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4228 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4224 if (result) {
4229 if (result) {
4225 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4230 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4226 if (args[0]!=&returnValue) {
4231 if (args[0]!=&returnValue) {
4227 if (args[0]==NULL) {
4232 if (args[0]==NULL) {
4228 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
4233 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
4229 } else {
4234 } else {
4230 returnValue = *((int*)args[0]);
4235 returnValue = *((int*)args[0]);
4231 }
4236 }
4232 }
4237 }
4233 }
4238 }
4234 if (result) { Py_DECREF(result); }
4239 if (result) { Py_DECREF(result); }
4235 Py_DECREF(obj);
4240 Py_DECREF(obj);
4236 return returnValue;
4241 return returnValue;
4237 } else {
4242 } else {
4238 PyErr_Clear();
4243 PyErr_Clear();
4239 }
4244 }
4240 }
4245 }
4241 return SocExplorerPlot::heightForWidth(arg__1);
4246 return SocExplorerPlot::heightForWidth(arg__1);
4242 }
4247 }
4243 void PythonQtShell_SocExplorerPlot::hideEvent(QHideEvent* arg__1)
4248 void PythonQtShell_SocExplorerPlot::hideEvent(QHideEvent* arg__1)
4244 {
4249 {
4245 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4250 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4246 static PyObject* name = PyString_FromString("hideEvent");
4251 static PyObject* name = PyString_FromString("hideEvent");
4247 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4252 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4248 if (obj) {
4253 if (obj) {
4249 static const char* argumentList[] ={"" , "QHideEvent*"};
4254 static const char* argumentList[] ={"" , "QHideEvent*"};
4250 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4255 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4251 void* args[2] = {NULL, (void*)&arg__1};
4256 void* args[2] = {NULL, (void*)&arg__1};
4252 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4257 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4253 if (result) { Py_DECREF(result); }
4258 if (result) { Py_DECREF(result); }
4254 Py_DECREF(obj);
4259 Py_DECREF(obj);
4255 return;
4260 return;
4256 } else {
4261 } else {
4257 PyErr_Clear();
4262 PyErr_Clear();
4258 }
4263 }
4259 }
4264 }
4260 SocExplorerPlot::hideEvent(arg__1);
4265 SocExplorerPlot::hideEvent(arg__1);
4261 }
4266 }
4262 void PythonQtShell_SocExplorerPlot::initPainter(QPainter* painter0) const
4267 void PythonQtShell_SocExplorerPlot::initPainter(QPainter* painter0) const
4263 {
4268 {
4264 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4269 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4265 static PyObject* name = PyString_FromString("initPainter");
4270 static PyObject* name = PyString_FromString("initPainter");
4266 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4271 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4267 if (obj) {
4272 if (obj) {
4268 static const char* argumentList[] ={"" , "QPainter*"};
4273 static const char* argumentList[] ={"" , "QPainter*"};
4269 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4274 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4270 void* args[2] = {NULL, (void*)&painter0};
4275 void* args[2] = {NULL, (void*)&painter0};
4271 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4276 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4272 if (result) { Py_DECREF(result); }
4277 if (result) { Py_DECREF(result); }
4273 Py_DECREF(obj);
4278 Py_DECREF(obj);
4274 return;
4279 return;
4275 } else {
4280 } else {
4276 PyErr_Clear();
4281 PyErr_Clear();
4277 }
4282 }
4278 }
4283 }
4279 SocExplorerPlot::initPainter(painter0);
4284 SocExplorerPlot::initPainter(painter0);
4280 }
4285 }
4281 void PythonQtShell_SocExplorerPlot::inputMethodEvent(QInputMethodEvent* arg__1)
4286 void PythonQtShell_SocExplorerPlot::inputMethodEvent(QInputMethodEvent* arg__1)
4282 {
4287 {
4283 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4288 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4284 static PyObject* name = PyString_FromString("inputMethodEvent");
4289 static PyObject* name = PyString_FromString("inputMethodEvent");
4285 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4290 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4286 if (obj) {
4291 if (obj) {
4287 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
4292 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
4288 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4293 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4289 void* args[2] = {NULL, (void*)&arg__1};
4294 void* args[2] = {NULL, (void*)&arg__1};
4290 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4295 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4291 if (result) { Py_DECREF(result); }
4296 if (result) { Py_DECREF(result); }
4292 Py_DECREF(obj);
4297 Py_DECREF(obj);
4293 return;
4298 return;
4294 } else {
4299 } else {
4295 PyErr_Clear();
4300 PyErr_Clear();
4296 }
4301 }
4297 }
4302 }
4298 SocExplorerPlot::inputMethodEvent(arg__1);
4303 SocExplorerPlot::inputMethodEvent(arg__1);
4299 }
4304 }
4300 QVariant PythonQtShell_SocExplorerPlot::inputMethodQuery(Qt::InputMethodQuery arg__1) const
4305 QVariant PythonQtShell_SocExplorerPlot::inputMethodQuery(Qt::InputMethodQuery arg__1) const
4301 {
4306 {
4302 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4307 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4303 static PyObject* name = PyString_FromString("inputMethodQuery");
4308 static PyObject* name = PyString_FromString("inputMethodQuery");
4304 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4309 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4305 if (obj) {
4310 if (obj) {
4306 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
4311 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
4307 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4312 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4308 QVariant returnValue;
4313 QVariant returnValue;
4309 void* args[2] = {NULL, (void*)&arg__1};
4314 void* args[2] = {NULL, (void*)&arg__1};
4310 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4315 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4311 if (result) {
4316 if (result) {
4312 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4317 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4313 if (args[0]!=&returnValue) {
4318 if (args[0]!=&returnValue) {
4314 if (args[0]==NULL) {
4319 if (args[0]==NULL) {
4315 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
4320 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
4316 } else {
4321 } else {
4317 returnValue = *((QVariant*)args[0]);
4322 returnValue = *((QVariant*)args[0]);
4318 }
4323 }
4319 }
4324 }
4320 }
4325 }
4321 if (result) { Py_DECREF(result); }
4326 if (result) { Py_DECREF(result); }
4322 Py_DECREF(obj);
4327 Py_DECREF(obj);
4323 return returnValue;
4328 return returnValue;
4324 } else {
4329 } else {
4325 PyErr_Clear();
4330 PyErr_Clear();
4326 }
4331 }
4327 }
4332 }
4328 return SocExplorerPlot::inputMethodQuery(arg__1);
4333 return SocExplorerPlot::inputMethodQuery(arg__1);
4329 }
4334 }
4330 void PythonQtShell_SocExplorerPlot::keyPressEvent(QKeyEvent* arg__1)
4335 void PythonQtShell_SocExplorerPlot::keyPressEvent(QKeyEvent* arg__1)
4331 {
4336 {
4332 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4337 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4333 static PyObject* name = PyString_FromString("keyPressEvent");
4338 static PyObject* name = PyString_FromString("keyPressEvent");
4334 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4339 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4335 if (obj) {
4340 if (obj) {
4336 static const char* argumentList[] ={"" , "QKeyEvent*"};
4341 static const char* argumentList[] ={"" , "QKeyEvent*"};
4337 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4342 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4338 void* args[2] = {NULL, (void*)&arg__1};
4343 void* args[2] = {NULL, (void*)&arg__1};
4339 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4344 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4340 if (result) { Py_DECREF(result); }
4345 if (result) { Py_DECREF(result); }
4341 Py_DECREF(obj);
4346 Py_DECREF(obj);
4342 return;
4347 return;
4343 } else {
4348 } else {
4344 PyErr_Clear();
4349 PyErr_Clear();
4345 }
4350 }
4346 }
4351 }
4347 SocExplorerPlot::keyPressEvent(arg__1);
4352 SocExplorerPlot::keyPressEvent(arg__1);
4348 }
4353 }
4349 void PythonQtShell_SocExplorerPlot::keyReleaseEvent(QKeyEvent* arg__1)
4354 void PythonQtShell_SocExplorerPlot::keyReleaseEvent(QKeyEvent* arg__1)
4350 {
4355 {
4351 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4356 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4352 static PyObject* name = PyString_FromString("keyReleaseEvent");
4357 static PyObject* name = PyString_FromString("keyReleaseEvent");
4353 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4358 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4354 if (obj) {
4359 if (obj) {
4355 static const char* argumentList[] ={"" , "QKeyEvent*"};
4360 static const char* argumentList[] ={"" , "QKeyEvent*"};
4356 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4361 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4357 void* args[2] = {NULL, (void*)&arg__1};
4362 void* args[2] = {NULL, (void*)&arg__1};
4358 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4363 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4359 if (result) { Py_DECREF(result); }
4364 if (result) { Py_DECREF(result); }
4360 Py_DECREF(obj);
4365 Py_DECREF(obj);
4361 return;
4366 return;
4362 } else {
4367 } else {
4363 PyErr_Clear();
4368 PyErr_Clear();
4364 }
4369 }
4365 }
4370 }
4366 SocExplorerPlot::keyReleaseEvent(arg__1);
4371 SocExplorerPlot::keyReleaseEvent(arg__1);
4367 }
4372 }
4368 void PythonQtShell_SocExplorerPlot::leaveEvent(QEvent* arg__1)
4373 void PythonQtShell_SocExplorerPlot::leaveEvent(QEvent* arg__1)
4369 {
4374 {
4370 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4375 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4371 static PyObject* name = PyString_FromString("leaveEvent");
4376 static PyObject* name = PyString_FromString("leaveEvent");
4372 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4377 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4373 if (obj) {
4378 if (obj) {
4374 static const char* argumentList[] ={"" , "QEvent*"};
4379 static const char* argumentList[] ={"" , "QEvent*"};
4375 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4380 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4376 void* args[2] = {NULL, (void*)&arg__1};
4381 void* args[2] = {NULL, (void*)&arg__1};
4377 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4382 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4378 if (result) { Py_DECREF(result); }
4383 if (result) { Py_DECREF(result); }
4379 Py_DECREF(obj);
4384 Py_DECREF(obj);
4380 return;
4385 return;
4381 } else {
4386 } else {
4382 PyErr_Clear();
4387 PyErr_Clear();
4383 }
4388 }
4384 }
4389 }
4385 SocExplorerPlot::leaveEvent(arg__1);
4390 SocExplorerPlot::leaveEvent(arg__1);
4386 }
4391 }
4387 int PythonQtShell_SocExplorerPlot::metric(QPaintDevice::PaintDeviceMetric arg__1) const
4392 int PythonQtShell_SocExplorerPlot::metric(QPaintDevice::PaintDeviceMetric arg__1) const
4388 {
4393 {
4389 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4394 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4390 static PyObject* name = PyString_FromString("metric");
4395 static PyObject* name = PyString_FromString("metric");
4391 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4396 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4392 if (obj) {
4397 if (obj) {
4393 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
4398 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
4394 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4399 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4395 int returnValue;
4400 int returnValue;
4396 void* args[2] = {NULL, (void*)&arg__1};
4401 void* args[2] = {NULL, (void*)&arg__1};
4397 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4402 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4398 if (result) {
4403 if (result) {
4399 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4404 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4400 if (args[0]!=&returnValue) {
4405 if (args[0]!=&returnValue) {
4401 if (args[0]==NULL) {
4406 if (args[0]==NULL) {
4402 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
4407 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
4403 } else {
4408 } else {
4404 returnValue = *((int*)args[0]);
4409 returnValue = *((int*)args[0]);
4405 }
4410 }
4406 }
4411 }
4407 }
4412 }
4408 if (result) { Py_DECREF(result); }
4413 if (result) { Py_DECREF(result); }
4409 Py_DECREF(obj);
4414 Py_DECREF(obj);
4410 return returnValue;
4415 return returnValue;
4411 } else {
4416 } else {
4412 PyErr_Clear();
4417 PyErr_Clear();
4413 }
4418 }
4414 }
4419 }
4415 return SocExplorerPlot::metric(arg__1);
4420 return SocExplorerPlot::metric(arg__1);
4416 }
4421 }
4417 QSize PythonQtShell_SocExplorerPlot::minimumSizeHint() const
4422 QSize PythonQtShell_SocExplorerPlot::minimumSizeHint() const
4418 {
4423 {
4419 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4424 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4420 static PyObject* name = PyString_FromString("getMinimumSizeHint");
4425 static PyObject* name = PyString_FromString("getMinimumSizeHint");
4421 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4426 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4422 if (obj) {
4427 if (obj) {
4423 static const char* argumentList[] ={"QSize"};
4428 static const char* argumentList[] ={"QSize"};
4424 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4429 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4425 QSize returnValue;
4430 QSize returnValue;
4426 void* args[1] = {NULL};
4431 void* args[1] = {NULL};
4427 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4432 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4428 if (result) {
4433 if (result) {
4429 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4434 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4430 if (args[0]!=&returnValue) {
4435 if (args[0]!=&returnValue) {
4431 if (args[0]==NULL) {
4436 if (args[0]==NULL) {
4432 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
4437 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
4433 } else {
4438 } else {
4434 returnValue = *((QSize*)args[0]);
4439 returnValue = *((QSize*)args[0]);
4435 }
4440 }
4436 }
4441 }
4437 }
4442 }
4438 if (result) { Py_DECREF(result); }
4443 if (result) { Py_DECREF(result); }
4439 Py_DECREF(obj);
4444 Py_DECREF(obj);
4440 return returnValue;
4445 return returnValue;
4441 } else {
4446 } else {
4442 PyErr_Clear();
4447 PyErr_Clear();
4443 }
4448 }
4444 }
4449 }
4445 return SocExplorerPlot::minimumSizeHint();
4450 return SocExplorerPlot::minimumSizeHint();
4446 }
4451 }
4447 void PythonQtShell_SocExplorerPlot::mouseDoubleClickEvent(QMouseEvent* arg__1)
4452 void PythonQtShell_SocExplorerPlot::mouseDoubleClickEvent(QMouseEvent* arg__1)
4448 {
4453 {
4449 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4454 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4450 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
4455 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
4451 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4456 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4452 if (obj) {
4457 if (obj) {
4453 static const char* argumentList[] ={"" , "QMouseEvent*"};
4458 static const char* argumentList[] ={"" , "QMouseEvent*"};
4454 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4459 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4455 void* args[2] = {NULL, (void*)&arg__1};
4460 void* args[2] = {NULL, (void*)&arg__1};
4456 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4461 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4457 if (result) { Py_DECREF(result); }
4462 if (result) { Py_DECREF(result); }
4458 Py_DECREF(obj);
4463 Py_DECREF(obj);
4459 return;
4464 return;
4460 } else {
4465 } else {
4461 PyErr_Clear();
4466 PyErr_Clear();
4462 }
4467 }
4463 }
4468 }
4464 SocExplorerPlot::mouseDoubleClickEvent(arg__1);
4469 SocExplorerPlot::mouseDoubleClickEvent(arg__1);
4465 }
4470 }
4466 void PythonQtShell_SocExplorerPlot::mouseMoveEvent(QMouseEvent* arg__1)
4471 void PythonQtShell_SocExplorerPlot::mouseMoveEvent(QMouseEvent* arg__1)
4467 {
4472 {
4468 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4473 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4469 static PyObject* name = PyString_FromString("mouseMoveEvent");
4474 static PyObject* name = PyString_FromString("mouseMoveEvent");
4470 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4475 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4471 if (obj) {
4476 if (obj) {
4472 static const char* argumentList[] ={"" , "QMouseEvent*"};
4477 static const char* argumentList[] ={"" , "QMouseEvent*"};
4473 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4478 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4474 void* args[2] = {NULL, (void*)&arg__1};
4479 void* args[2] = {NULL, (void*)&arg__1};
4475 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4480 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4476 if (result) { Py_DECREF(result); }
4481 if (result) { Py_DECREF(result); }
4477 Py_DECREF(obj);
4482 Py_DECREF(obj);
4478 return;
4483 return;
4479 } else {
4484 } else {
4480 PyErr_Clear();
4485 PyErr_Clear();
4481 }
4486 }
4482 }
4487 }
4483 SocExplorerPlot::mouseMoveEvent(arg__1);
4488 SocExplorerPlot::mouseMoveEvent(arg__1);
4484 }
4489 }
4485 void PythonQtShell_SocExplorerPlot::mousePressEvent(QMouseEvent* arg__1)
4490 void PythonQtShell_SocExplorerPlot::mousePressEvent(QMouseEvent* arg__1)
4486 {
4491 {
4487 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4492 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4488 static PyObject* name = PyString_FromString("mousePressEvent");
4493 static PyObject* name = PyString_FromString("mousePressEvent");
4489 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4494 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4490 if (obj) {
4495 if (obj) {
4491 static const char* argumentList[] ={"" , "QMouseEvent*"};
4496 static const char* argumentList[] ={"" , "QMouseEvent*"};
4492 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4497 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4493 void* args[2] = {NULL, (void*)&arg__1};
4498 void* args[2] = {NULL, (void*)&arg__1};
4494 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4499 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4495 if (result) { Py_DECREF(result); }
4500 if (result) { Py_DECREF(result); }
4496 Py_DECREF(obj);
4501 Py_DECREF(obj);
4497 return;
4502 return;
4498 } else {
4503 } else {
4499 PyErr_Clear();
4504 PyErr_Clear();
4500 }
4505 }
4501 }
4506 }
4502 SocExplorerPlot::mousePressEvent(arg__1);
4507 SocExplorerPlot::mousePressEvent(arg__1);
4503 }
4508 }
4504 void PythonQtShell_SocExplorerPlot::mouseReleaseEvent(QMouseEvent* arg__1)
4509 void PythonQtShell_SocExplorerPlot::mouseReleaseEvent(QMouseEvent* arg__1)
4505 {
4510 {
4506 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4511 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4507 static PyObject* name = PyString_FromString("mouseReleaseEvent");
4512 static PyObject* name = PyString_FromString("mouseReleaseEvent");
4508 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4513 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4509 if (obj) {
4514 if (obj) {
4510 static const char* argumentList[] ={"" , "QMouseEvent*"};
4515 static const char* argumentList[] ={"" , "QMouseEvent*"};
4511 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4516 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4512 void* args[2] = {NULL, (void*)&arg__1};
4517 void* args[2] = {NULL, (void*)&arg__1};
4513 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4518 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4514 if (result) { Py_DECREF(result); }
4519 if (result) { Py_DECREF(result); }
4515 Py_DECREF(obj);
4520 Py_DECREF(obj);
4516 return;
4521 return;
4517 } else {
4522 } else {
4518 PyErr_Clear();
4523 PyErr_Clear();
4519 }
4524 }
4520 }
4525 }
4521 SocExplorerPlot::mouseReleaseEvent(arg__1);
4526 SocExplorerPlot::mouseReleaseEvent(arg__1);
4522 }
4527 }
4523 void PythonQtShell_SocExplorerPlot::moveEvent(QMoveEvent* arg__1)
4528 void PythonQtShell_SocExplorerPlot::moveEvent(QMoveEvent* arg__1)
4524 {
4529 {
4525 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4530 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4526 static PyObject* name = PyString_FromString("moveEvent");
4531 static PyObject* name = PyString_FromString("moveEvent");
4527 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4532 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4528 if (obj) {
4533 if (obj) {
4529 static const char* argumentList[] ={"" , "QMoveEvent*"};
4534 static const char* argumentList[] ={"" , "QMoveEvent*"};
4530 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4535 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4531 void* args[2] = {NULL, (void*)&arg__1};
4536 void* args[2] = {NULL, (void*)&arg__1};
4532 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4537 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4533 if (result) { Py_DECREF(result); }
4538 if (result) { Py_DECREF(result); }
4534 Py_DECREF(obj);
4539 Py_DECREF(obj);
4535 return;
4540 return;
4536 } else {
4541 } else {
4537 PyErr_Clear();
4542 PyErr_Clear();
4538 }
4543 }
4539 }
4544 }
4540 SocExplorerPlot::moveEvent(arg__1);
4545 SocExplorerPlot::moveEvent(arg__1);
4541 }
4546 }
4542 bool PythonQtShell_SocExplorerPlot::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
4547 bool PythonQtShell_SocExplorerPlot::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
4543 {
4548 {
4544 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4549 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4545 static PyObject* name = PyString_FromString("nativeEvent");
4550 static PyObject* name = PyString_FromString("nativeEvent");
4546 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4551 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4547 if (obj) {
4552 if (obj) {
4548 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
4553 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
4549 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
4554 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
4550 bool returnValue;
4555 bool returnValue;
4551 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
4556 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
4552 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4557 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4553 if (result) {
4558 if (result) {
4554 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4559 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4555 if (args[0]!=&returnValue) {
4560 if (args[0]!=&returnValue) {
4556 if (args[0]==NULL) {
4561 if (args[0]==NULL) {
4557 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
4562 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
4558 } else {
4563 } else {
4559 returnValue = *((bool*)args[0]);
4564 returnValue = *((bool*)args[0]);
4560 }
4565 }
4561 }
4566 }
4562 }
4567 }
4563 if (result) { Py_DECREF(result); }
4568 if (result) { Py_DECREF(result); }
4564 Py_DECREF(obj);
4569 Py_DECREF(obj);
4565 return returnValue;
4570 return returnValue;
4566 } else {
4571 } else {
4567 PyErr_Clear();
4572 PyErr_Clear();
4568 }
4573 }
4569 }
4574 }
4570 return SocExplorerPlot::nativeEvent(eventType0, message1, result2);
4575 return SocExplorerPlot::nativeEvent(eventType0, message1, result2);
4571 }
4576 }
4572 QPaintEngine* PythonQtShell_SocExplorerPlot::paintEngine() const
4577 QPaintEngine* PythonQtShell_SocExplorerPlot::paintEngine() const
4573 {
4578 {
4574 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4579 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4575 static PyObject* name = PyString_FromString("paintEngine");
4580 static PyObject* name = PyString_FromString("paintEngine");
4576 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4581 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4577 if (obj) {
4582 if (obj) {
4578 static const char* argumentList[] ={"QPaintEngine*"};
4583 static const char* argumentList[] ={"QPaintEngine*"};
4579 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4584 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4580 QPaintEngine* returnValue;
4585 QPaintEngine* returnValue;
4581 void* args[1] = {NULL};
4586 void* args[1] = {NULL};
4582 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4587 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4583 if (result) {
4588 if (result) {
4584 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4589 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4585 if (args[0]!=&returnValue) {
4590 if (args[0]!=&returnValue) {
4586 if (args[0]==NULL) {
4591 if (args[0]==NULL) {
4587 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
4592 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
4588 } else {
4593 } else {
4589 returnValue = *((QPaintEngine**)args[0]);
4594 returnValue = *((QPaintEngine**)args[0]);
4590 }
4595 }
4591 }
4596 }
4592 }
4597 }
4593 if (result) { Py_DECREF(result); }
4598 if (result) { Py_DECREF(result); }
4594 Py_DECREF(obj);
4599 Py_DECREF(obj);
4595 return returnValue;
4600 return returnValue;
4596 } else {
4601 } else {
4597 PyErr_Clear();
4602 PyErr_Clear();
4598 }
4603 }
4599 }
4604 }
4600 return SocExplorerPlot::paintEngine();
4605 return SocExplorerPlot::paintEngine();
4601 }
4606 }
4602 void PythonQtShell_SocExplorerPlot::paintEvent(QPaintEvent* arg__1)
4607 void PythonQtShell_SocExplorerPlot::paintEvent(QPaintEvent* arg__1)
4603 {
4608 {
4604 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4609 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4605 static PyObject* name = PyString_FromString("paintEvent");
4610 static PyObject* name = PyString_FromString("paintEvent");
4606 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4611 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4607 if (obj) {
4612 if (obj) {
4608 static const char* argumentList[] ={"" , "QPaintEvent*"};
4613 static const char* argumentList[] ={"" , "QPaintEvent*"};
4609 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4614 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4610 void* args[2] = {NULL, (void*)&arg__1};
4615 void* args[2] = {NULL, (void*)&arg__1};
4611 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4616 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4612 if (result) { Py_DECREF(result); }
4617 if (result) { Py_DECREF(result); }
4613 Py_DECREF(obj);
4618 Py_DECREF(obj);
4614 return;
4619 return;
4615 } else {
4620 } else {
4616 PyErr_Clear();
4621 PyErr_Clear();
4617 }
4622 }
4618 }
4623 }
4619 SocExplorerPlot::paintEvent(arg__1);
4624 SocExplorerPlot::paintEvent(arg__1);
4620 }
4625 }
4621 QPaintDevice* PythonQtShell_SocExplorerPlot::redirected(QPoint* offset0) const
4626 QPaintDevice* PythonQtShell_SocExplorerPlot::redirected(QPoint* offset0) const
4622 {
4627 {
4623 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4628 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4624 static PyObject* name = PyString_FromString("redirected");
4629 static PyObject* name = PyString_FromString("redirected");
4625 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4630 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4626 if (obj) {
4631 if (obj) {
4627 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
4632 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
4628 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4633 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4629 QPaintDevice* returnValue;
4634 QPaintDevice* returnValue;
4630 void* args[2] = {NULL, (void*)&offset0};
4635 void* args[2] = {NULL, (void*)&offset0};
4631 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4636 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4632 if (result) {
4637 if (result) {
4633 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4638 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4634 if (args[0]!=&returnValue) {
4639 if (args[0]!=&returnValue) {
4635 if (args[0]==NULL) {
4640 if (args[0]==NULL) {
4636 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
4641 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
4637 } else {
4642 } else {
4638 returnValue = *((QPaintDevice**)args[0]);
4643 returnValue = *((QPaintDevice**)args[0]);
4639 }
4644 }
4640 }
4645 }
4641 }
4646 }
4642 if (result) { Py_DECREF(result); }
4647 if (result) { Py_DECREF(result); }
4643 Py_DECREF(obj);
4648 Py_DECREF(obj);
4644 return returnValue;
4649 return returnValue;
4645 } else {
4650 } else {
4646 PyErr_Clear();
4651 PyErr_Clear();
4647 }
4652 }
4648 }
4653 }
4649 return SocExplorerPlot::redirected(offset0);
4654 return SocExplorerPlot::redirected(offset0);
4650 }
4655 }
4651 void PythonQtShell_SocExplorerPlot::resizeEvent(QResizeEvent* arg__1)
4656 void PythonQtShell_SocExplorerPlot::resizeEvent(QResizeEvent* arg__1)
4652 {
4657 {
4653 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4658 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4654 static PyObject* name = PyString_FromString("resizeEvent");
4659 static PyObject* name = PyString_FromString("resizeEvent");
4655 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4660 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4656 if (obj) {
4661 if (obj) {
4657 static const char* argumentList[] ={"" , "QResizeEvent*"};
4662 static const char* argumentList[] ={"" , "QResizeEvent*"};
4658 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4663 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4659 void* args[2] = {NULL, (void*)&arg__1};
4664 void* args[2] = {NULL, (void*)&arg__1};
4660 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4665 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4661 if (result) { Py_DECREF(result); }
4666 if (result) { Py_DECREF(result); }
4662 Py_DECREF(obj);
4667 Py_DECREF(obj);
4663 return;
4668 return;
4664 } else {
4669 } else {
4665 PyErr_Clear();
4670 PyErr_Clear();
4666 }
4671 }
4667 }
4672 }
4668 SocExplorerPlot::resizeEvent(arg__1);
4673 SocExplorerPlot::resizeEvent(arg__1);
4669 }
4674 }
4670 QPainter* PythonQtShell_SocExplorerPlot::sharedPainter() const
4675 QPainter* PythonQtShell_SocExplorerPlot::sharedPainter() const
4671 {
4676 {
4672 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4677 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4673 static PyObject* name = PyString_FromString("sharedPainter");
4678 static PyObject* name = PyString_FromString("sharedPainter");
4674 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4679 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4675 if (obj) {
4680 if (obj) {
4676 static const char* argumentList[] ={"QPainter*"};
4681 static const char* argumentList[] ={"QPainter*"};
4677 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4682 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4678 QPainter* returnValue;
4683 QPainter* returnValue;
4679 void* args[1] = {NULL};
4684 void* args[1] = {NULL};
4680 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4685 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4681 if (result) {
4686 if (result) {
4682 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4687 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4683 if (args[0]!=&returnValue) {
4688 if (args[0]!=&returnValue) {
4684 if (args[0]==NULL) {
4689 if (args[0]==NULL) {
4685 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
4690 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
4686 } else {
4691 } else {
4687 returnValue = *((QPainter**)args[0]);
4692 returnValue = *((QPainter**)args[0]);
4688 }
4693 }
4689 }
4694 }
4690 }
4695 }
4691 if (result) { Py_DECREF(result); }
4696 if (result) { Py_DECREF(result); }
4692 Py_DECREF(obj);
4697 Py_DECREF(obj);
4693 return returnValue;
4698 return returnValue;
4694 } else {
4699 } else {
4695 PyErr_Clear();
4700 PyErr_Clear();
4696 }
4701 }
4697 }
4702 }
4698 return SocExplorerPlot::sharedPainter();
4703 return SocExplorerPlot::sharedPainter();
4699 }
4704 }
4700 void PythonQtShell_SocExplorerPlot::showEvent(QShowEvent* arg__1)
4705 void PythonQtShell_SocExplorerPlot::showEvent(QShowEvent* arg__1)
4701 {
4706 {
4702 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4707 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4703 static PyObject* name = PyString_FromString("showEvent");
4708 static PyObject* name = PyString_FromString("showEvent");
4704 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4709 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4705 if (obj) {
4710 if (obj) {
4706 static const char* argumentList[] ={"" , "QShowEvent*"};
4711 static const char* argumentList[] ={"" , "QShowEvent*"};
4707 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4712 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4708 void* args[2] = {NULL, (void*)&arg__1};
4713 void* args[2] = {NULL, (void*)&arg__1};
4709 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4714 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4710 if (result) { Py_DECREF(result); }
4715 if (result) { Py_DECREF(result); }
4711 Py_DECREF(obj);
4716 Py_DECREF(obj);
4712 return;
4717 return;
4713 } else {
4718 } else {
4714 PyErr_Clear();
4719 PyErr_Clear();
4715 }
4720 }
4716 }
4721 }
4717 SocExplorerPlot::showEvent(arg__1);
4722 SocExplorerPlot::showEvent(arg__1);
4718 }
4723 }
4719 QSize PythonQtShell_SocExplorerPlot::sizeHint() const
4724 QSize PythonQtShell_SocExplorerPlot::sizeHint() const
4720 {
4725 {
4721 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4726 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4722 static PyObject* name = PyString_FromString("getSizeHint");
4727 static PyObject* name = PyString_FromString("getSizeHint");
4723 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4728 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4724 if (obj) {
4729 if (obj) {
4725 static const char* argumentList[] ={"QSize"};
4730 static const char* argumentList[] ={"QSize"};
4726 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4731 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4727 QSize returnValue;
4732 QSize returnValue;
4728 void* args[1] = {NULL};
4733 void* args[1] = {NULL};
4729 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4734 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4730 if (result) {
4735 if (result) {
4731 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4736 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4732 if (args[0]!=&returnValue) {
4737 if (args[0]!=&returnValue) {
4733 if (args[0]==NULL) {
4738 if (args[0]==NULL) {
4734 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
4739 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
4735 } else {
4740 } else {
4736 returnValue = *((QSize*)args[0]);
4741 returnValue = *((QSize*)args[0]);
4737 }
4742 }
4738 }
4743 }
4739 }
4744 }
4740 if (result) { Py_DECREF(result); }
4745 if (result) { Py_DECREF(result); }
4741 Py_DECREF(obj);
4746 Py_DECREF(obj);
4742 return returnValue;
4747 return returnValue;
4743 } else {
4748 } else {
4744 PyErr_Clear();
4749 PyErr_Clear();
4745 }
4750 }
4746 }
4751 }
4747 return SocExplorerPlot::sizeHint();
4752 return SocExplorerPlot::sizeHint();
4748 }
4753 }
4749 void PythonQtShell_SocExplorerPlot::tabletEvent(QTabletEvent* arg__1)
4754 void PythonQtShell_SocExplorerPlot::tabletEvent(QTabletEvent* arg__1)
4750 {
4755 {
4751 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4756 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4752 static PyObject* name = PyString_FromString("tabletEvent");
4757 static PyObject* name = PyString_FromString("tabletEvent");
4753 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4758 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4754 if (obj) {
4759 if (obj) {
4755 static const char* argumentList[] ={"" , "QTabletEvent*"};
4760 static const char* argumentList[] ={"" , "QTabletEvent*"};
4756 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4761 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4757 void* args[2] = {NULL, (void*)&arg__1};
4762 void* args[2] = {NULL, (void*)&arg__1};
4758 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4763 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4759 if (result) { Py_DECREF(result); }
4764 if (result) { Py_DECREF(result); }
4760 Py_DECREF(obj);
4765 Py_DECREF(obj);
4761 return;
4766 return;
4762 } else {
4767 } else {
4763 PyErr_Clear();
4768 PyErr_Clear();
4764 }
4769 }
4765 }
4770 }
4766 SocExplorerPlot::tabletEvent(arg__1);
4771 SocExplorerPlot::tabletEvent(arg__1);
4767 }
4772 }
4768 void PythonQtShell_SocExplorerPlot::timerEvent(QTimerEvent* arg__1)
4773 void PythonQtShell_SocExplorerPlot::timerEvent(QTimerEvent* arg__1)
4769 {
4774 {
4770 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4775 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4771 static PyObject* name = PyString_FromString("timerEvent");
4776 static PyObject* name = PyString_FromString("timerEvent");
4772 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4777 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4773 if (obj) {
4778 if (obj) {
4774 static const char* argumentList[] ={"" , "QTimerEvent*"};
4779 static const char* argumentList[] ={"" , "QTimerEvent*"};
4775 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4780 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4776 void* args[2] = {NULL, (void*)&arg__1};
4781 void* args[2] = {NULL, (void*)&arg__1};
4777 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4782 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4778 if (result) { Py_DECREF(result); }
4783 if (result) { Py_DECREF(result); }
4779 Py_DECREF(obj);
4784 Py_DECREF(obj);
4780 return;
4785 return;
4781 } else {
4786 } else {
4782 PyErr_Clear();
4787 PyErr_Clear();
4783 }
4788 }
4784 }
4789 }
4785 SocExplorerPlot::timerEvent(arg__1);
4790 SocExplorerPlot::timerEvent(arg__1);
4786 }
4791 }
4787 void PythonQtShell_SocExplorerPlot::wheelEvent(QWheelEvent* arg__1)
4792 void PythonQtShell_SocExplorerPlot::wheelEvent(QWheelEvent* arg__1)
4788 {
4793 {
4789 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4794 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4790 static PyObject* name = PyString_FromString("wheelEvent");
4795 static PyObject* name = PyString_FromString("wheelEvent");
4791 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4796 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4792 if (obj) {
4797 if (obj) {
4793 static const char* argumentList[] ={"" , "QWheelEvent*"};
4798 static const char* argumentList[] ={"" , "QWheelEvent*"};
4794 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4799 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4795 void* args[2] = {NULL, (void*)&arg__1};
4800 void* args[2] = {NULL, (void*)&arg__1};
4796 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4801 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4797 if (result) { Py_DECREF(result); }
4802 if (result) { Py_DECREF(result); }
4798 Py_DECREF(obj);
4803 Py_DECREF(obj);
4799 return;
4804 return;
4800 } else {
4805 } else {
4801 PyErr_Clear();
4806 PyErr_Clear();
4802 }
4807 }
4803 }
4808 }
4804 SocExplorerPlot::wheelEvent(arg__1);
4809 SocExplorerPlot::wheelEvent(arg__1);
4805 }
4810 }
4806 SocExplorerPlot* PythonQtWrapper_SocExplorerPlot::new_SocExplorerPlot(QWidget* parent)
4811 SocExplorerPlot* PythonQtWrapper_SocExplorerPlot::new_SocExplorerPlot(QWidget* parent)
4807 {
4812 {
4808 return new PythonQtShell_SocExplorerPlot(parent); }
4813 return new PythonQtShell_SocExplorerPlot(parent); }
4809
4814
4810 int PythonQtWrapper_SocExplorerPlot::addGraph(SocExplorerPlot* theWrappedObject)
4815 int PythonQtWrapper_SocExplorerPlot::addGraph(SocExplorerPlot* theWrappedObject)
4811 {
4816 {
4812 return ( theWrappedObject->addGraph());
4817 return ( theWrappedObject->addGraph());
4813 }
4818 }
4814
4819
4815 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4820 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4816 {
4821 {
4817 ( theWrappedObject->addGraphData(graphIndex, x, y));
4822 ( theWrappedObject->addGraphData(graphIndex, x, y));
4818 }
4823 }
4819
4824
4820 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y)
4825 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y)
4821 {
4826 {
4822 ( theWrappedObject->addGraphData(graphIndex, x, y));
4827 ( theWrappedObject->addGraphData(graphIndex, x, y));
4823 }
4828 }
4824
4829
4825 QPen PythonQtWrapper_SocExplorerPlot::getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex)
4830 QPen PythonQtWrapper_SocExplorerPlot::getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex)
4826 {
4831 {
4827 return ( theWrappedObject->getGraphPen(graphIndex));
4832 return ( theWrappedObject->getGraphPen(graphIndex));
4828 }
4833 }
4829
4834
4830 void PythonQtWrapper_SocExplorerPlot::keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4835 void PythonQtWrapper_SocExplorerPlot::keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4831 {
4836 {
4832 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyPressEvent(arg__1));
4837 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyPressEvent(arg__1));
4833 }
4838 }
4834
4839
4835 void PythonQtWrapper_SocExplorerPlot::keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4840 void PythonQtWrapper_SocExplorerPlot::keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4836 {
4841 {
4837 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyReleaseEvent(arg__1));
4842 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyReleaseEvent(arg__1));
4838 }
4843 }
4839
4844
4840 void PythonQtWrapper_SocExplorerPlot::mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4845 void PythonQtWrapper_SocExplorerPlot::mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4841 {
4846 {
4842 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseMoveEvent(arg__1));
4847 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseMoveEvent(arg__1));
4843 }
4848 }
4844
4849
4845 void PythonQtWrapper_SocExplorerPlot::mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4850 void PythonQtWrapper_SocExplorerPlot::mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4846 {
4851 {
4847 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mousePressEvent(arg__1));
4852 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mousePressEvent(arg__1));
4848 }
4853 }
4849
4854
4850 void PythonQtWrapper_SocExplorerPlot::mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4855 void PythonQtWrapper_SocExplorerPlot::mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4851 {
4856 {
4852 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseReleaseEvent(arg__1));
4857 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseReleaseEvent(arg__1));
4853 }
4858 }
4854
4859
4855 void PythonQtWrapper_SocExplorerPlot::removeAllGraphs(SocExplorerPlot* theWrappedObject)
4860 void PythonQtWrapper_SocExplorerPlot::removeAllGraphs(SocExplorerPlot* theWrappedObject)
4856 {
4861 {
4857 ( theWrappedObject->removeAllGraphs());
4862 ( theWrappedObject->removeAllGraphs());
4858 }
4863 }
4859
4864
4860 bool PythonQtWrapper_SocExplorerPlot::removeGraph(SocExplorerPlot* theWrappedObject, int graphIndex)
4865 bool PythonQtWrapper_SocExplorerPlot::removeGraph(SocExplorerPlot* theWrappedObject, int graphIndex)
4861 {
4866 {
4862 return ( theWrappedObject->removeGraph(graphIndex));
4867 return ( theWrappedObject->removeGraph(graphIndex));
4863 }
4868 }
4864
4869
4865 void PythonQtWrapper_SocExplorerPlot::replot(SocExplorerPlot* theWrappedObject)
4870 void PythonQtWrapper_SocExplorerPlot::replot(SocExplorerPlot* theWrappedObject)
4866 {
4871 {
4867 ( theWrappedObject->replot());
4872 ( theWrappedObject->replot());
4868 }
4873 }
4869
4874
4870 void PythonQtWrapper_SocExplorerPlot::rescaleAxis(SocExplorerPlot* theWrappedObject)
4875 void PythonQtWrapper_SocExplorerPlot::rescaleAxis(SocExplorerPlot* theWrappedObject)
4871 {
4876 {
4872 ( theWrappedObject->rescaleAxis());
4877 ( theWrappedObject->rescaleAxis());
4873 }
4878 }
4874
4879
4875 void PythonQtWrapper_SocExplorerPlot::setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable)
4880 void PythonQtWrapper_SocExplorerPlot::setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable)
4876 {
4881 {
4877 ( theWrappedObject->setAdaptativeSampling(graphIndex, enable));
4882 ( theWrappedObject->setAdaptativeSampling(graphIndex, enable));
4878 }
4883 }
4879
4884
4880 void PythonQtWrapper_SocExplorerPlot::setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4885 void PythonQtWrapper_SocExplorerPlot::setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4881 {
4886 {
4882 ( theWrappedObject->setGraphData(graphIndex, x, y));
4887 ( theWrappedObject->setGraphData(graphIndex, x, y));
4883 }
4888 }
4884
4889
4885 void PythonQtWrapper_SocExplorerPlot::setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle)
4890 void PythonQtWrapper_SocExplorerPlot::setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle)
4886 {
4891 {
4887 ( theWrappedObject->setGraphLineStyle(graphIndex, lineStyle));
4892 ( theWrappedObject->setGraphLineStyle(graphIndex, lineStyle));
4888 }
4893 }
4889
4894
4890 void PythonQtWrapper_SocExplorerPlot::setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name)
4895 void PythonQtWrapper_SocExplorerPlot::setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name)
4891 {
4896 {
4892 ( theWrappedObject->setGraphName(graphIndex, name));
4897 ( theWrappedObject->setGraphName(graphIndex, name));
4893 }
4898 }
4894
4899
4895 void PythonQtWrapper_SocExplorerPlot::setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen)
4900 void PythonQtWrapper_SocExplorerPlot::setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen)
4896 {
4901 {
4897 ( theWrappedObject->setGraphPen(graphIndex, pen));
4902 ( theWrappedObject->setGraphPen(graphIndex, pen));
4898 }
4903 }
4899
4904
4900 void PythonQtWrapper_SocExplorerPlot::setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle)
4905 void PythonQtWrapper_SocExplorerPlot::setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle)
4901 {
4906 {
4902 ( theWrappedObject->setGraphScatterStyle(graphIndex, scatterStyle));
4907 ( theWrappedObject->setGraphScatterStyle(graphIndex, scatterStyle));
4903 }
4908 }
4904
4909
4905 void PythonQtWrapper_SocExplorerPlot::setLegendFont(SocExplorerPlot* theWrappedObject, QFont font)
4910 void PythonQtWrapper_SocExplorerPlot::setLegendFont(SocExplorerPlot* theWrappedObject, QFont font)
4906 {
4911 {
4907 ( theWrappedObject->setLegendFont(font));
4912 ( theWrappedObject->setLegendFont(font));
4908 }
4913 }
4909
4914
4910 void PythonQtWrapper_SocExplorerPlot::setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font)
4915 void PythonQtWrapper_SocExplorerPlot::setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font)
4911 {
4916 {
4912 ( theWrappedObject->setLegendSelectedFont(font));
4917 ( theWrappedObject->setLegendSelectedFont(font));
4913 }
4918 }
4914
4919
4915 void PythonQtWrapper_SocExplorerPlot::setTitle(SocExplorerPlot* theWrappedObject, QString title)
4920 void PythonQtWrapper_SocExplorerPlot::setTitle(SocExplorerPlot* theWrappedObject, QString title)
4916 {
4921 {
4917 ( theWrappedObject->setTitle(title));
4922 ( theWrappedObject->setTitle(title));
4918 }
4923 }
4919
4924
4920 void PythonQtWrapper_SocExplorerPlot::setXaxisDateTimeFormat(SocExplorerPlot* theWrappedObject, const QString& format)
4925 void PythonQtWrapper_SocExplorerPlot::setXaxisDateTimeFormat(SocExplorerPlot* theWrappedObject, const QString& format)
4921 {
4926 {
4922 ( theWrappedObject->setXaxisDateTimeFormat(format));
4927 ( theWrappedObject->setXaxisDateTimeFormat(format));
4923 }
4928 }
4924
4929
4925 void PythonQtWrapper_SocExplorerPlot::setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4930 void PythonQtWrapper_SocExplorerPlot::setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4926 {
4931 {
4927 ( theWrappedObject->setXaxisLabel(label));
4932 ( theWrappedObject->setXaxisLabel(label));
4928 }
4933 }
4929
4934
4930 void PythonQtWrapper_SocExplorerPlot::setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4935 void PythonQtWrapper_SocExplorerPlot::setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4931 {
4936 {
4932 ( theWrappedObject->setXaxisRange(lower, upper));
4937 ( theWrappedObject->setXaxisRange(lower, upper));
4933 }
4938 }
4934
4939
4935 void PythonQtWrapper_SocExplorerPlot::setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4940 void PythonQtWrapper_SocExplorerPlot::setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4936 {
4941 {
4937 ( theWrappedObject->setYaxisLabel(label));
4942 ( theWrappedObject->setYaxisLabel(label));
4938 }
4943 }
4939
4944
4940 void PythonQtWrapper_SocExplorerPlot::setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4945 void PythonQtWrapper_SocExplorerPlot::setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4941 {
4946 {
4942 ( theWrappedObject->setYaxisRange(lower, upper));
4947 ( theWrappedObject->setYaxisRange(lower, upper));
4943 }
4948 }
4944
4949
4945 void PythonQtWrapper_SocExplorerPlot::show(SocExplorerPlot* theWrappedObject)
4950 void PythonQtWrapper_SocExplorerPlot::show(SocExplorerPlot* theWrappedObject)
4946 {
4951 {
4947 ( theWrappedObject->show());
4952 ( theWrappedObject->show());
4948 }
4953 }
4949
4954
4950 void PythonQtWrapper_SocExplorerPlot::wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1)
4955 void PythonQtWrapper_SocExplorerPlot::wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1)
4951 {
4956 {
4952 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_wheelEvent(arg__1));
4957 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_wheelEvent(arg__1));
4953 }
4958 }
4954
4959
4955
4960
4956
4961
4957 PythonQtShell_TCP_Terminal_Client::~PythonQtShell_TCP_Terminal_Client() {
4962 PythonQtShell_TCP_Terminal_Client::~PythonQtShell_TCP_Terminal_Client() {
4958 PythonQtPrivate* priv = PythonQt::priv();
4963 PythonQtPrivate* priv = PythonQt::priv();
4959 if (priv) { priv->shellClassDeleted(this); }
4964 if (priv) { priv->shellClassDeleted(this); }
4960 }
4965 }
4961 void PythonQtShell_TCP_Terminal_Client::childEvent(QChildEvent* arg__1)
4966 void PythonQtShell_TCP_Terminal_Client::childEvent(QChildEvent* arg__1)
4962 {
4967 {
4963 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4968 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4964 static PyObject* name = PyString_FromString("childEvent");
4969 static PyObject* name = PyString_FromString("childEvent");
4965 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4970 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4966 if (obj) {
4971 if (obj) {
4967 static const char* argumentList[] ={"" , "QChildEvent*"};
4972 static const char* argumentList[] ={"" , "QChildEvent*"};
4968 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4973 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4969 void* args[2] = {NULL, (void*)&arg__1};
4974 void* args[2] = {NULL, (void*)&arg__1};
4970 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4975 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4971 if (result) { Py_DECREF(result); }
4976 if (result) { Py_DECREF(result); }
4972 Py_DECREF(obj);
4977 Py_DECREF(obj);
4973 return;
4978 return;
4974 } else {
4979 } else {
4975 PyErr_Clear();
4980 PyErr_Clear();
4976 }
4981 }
4977 }
4982 }
4978 TCP_Terminal_Client::childEvent(arg__1);
4983 TCP_Terminal_Client::childEvent(arg__1);
4979 }
4984 }
4980 void PythonQtShell_TCP_Terminal_Client::customEvent(QEvent* arg__1)
4985 void PythonQtShell_TCP_Terminal_Client::customEvent(QEvent* arg__1)
4981 {
4986 {
4982 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4987 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
4983 static PyObject* name = PyString_FromString("customEvent");
4988 static PyObject* name = PyString_FromString("customEvent");
4984 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4989 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
4985 if (obj) {
4990 if (obj) {
4986 static const char* argumentList[] ={"" , "QEvent*"};
4991 static const char* argumentList[] ={"" , "QEvent*"};
4987 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4992 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4988 void* args[2] = {NULL, (void*)&arg__1};
4993 void* args[2] = {NULL, (void*)&arg__1};
4989 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4994 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4990 if (result) { Py_DECREF(result); }
4995 if (result) { Py_DECREF(result); }
4991 Py_DECREF(obj);
4996 Py_DECREF(obj);
4992 return;
4997 return;
4993 } else {
4998 } else {
4994 PyErr_Clear();
4999 PyErr_Clear();
4995 }
5000 }
4996 }
5001 }
4997 TCP_Terminal_Client::customEvent(arg__1);
5002 TCP_Terminal_Client::customEvent(arg__1);
4998 }
5003 }
4999 bool PythonQtShell_TCP_Terminal_Client::event(QEvent* arg__1)
5004 bool PythonQtShell_TCP_Terminal_Client::event(QEvent* arg__1)
5000 {
5005 {
5001 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5006 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5002 static PyObject* name = PyString_FromString("event");
5007 static PyObject* name = PyString_FromString("event");
5003 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5008 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5004 if (obj) {
5009 if (obj) {
5005 static const char* argumentList[] ={"bool" , "QEvent*"};
5010 static const char* argumentList[] ={"bool" , "QEvent*"};
5006 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5011 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5007 bool returnValue;
5012 bool returnValue;
5008 void* args[2] = {NULL, (void*)&arg__1};
5013 void* args[2] = {NULL, (void*)&arg__1};
5009 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5014 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5010 if (result) {
5015 if (result) {
5011 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5016 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5012 if (args[0]!=&returnValue) {
5017 if (args[0]!=&returnValue) {
5013 if (args[0]==NULL) {
5018 if (args[0]==NULL) {
5014 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
5019 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
5015 } else {
5020 } else {
5016 returnValue = *((bool*)args[0]);
5021 returnValue = *((bool*)args[0]);
5017 }
5022 }
5018 }
5023 }
5019 }
5024 }
5020 if (result) { Py_DECREF(result); }
5025 if (result) { Py_DECREF(result); }
5021 Py_DECREF(obj);
5026 Py_DECREF(obj);
5022 return returnValue;
5027 return returnValue;
5023 } else {
5028 } else {
5024 PyErr_Clear();
5029 PyErr_Clear();
5025 }
5030 }
5026 }
5031 }
5027 return TCP_Terminal_Client::event(arg__1);
5032 return TCP_Terminal_Client::event(arg__1);
5028 }
5033 }
5029 bool PythonQtShell_TCP_Terminal_Client::eventFilter(QObject* arg__1, QEvent* arg__2)
5034 bool PythonQtShell_TCP_Terminal_Client::eventFilter(QObject* arg__1, QEvent* arg__2)
5030 {
5035 {
5031 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5036 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5032 static PyObject* name = PyString_FromString("eventFilter");
5037 static PyObject* name = PyString_FromString("eventFilter");
5033 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5038 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5034 if (obj) {
5039 if (obj) {
5035 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5040 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5036 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5041 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5037 bool returnValue;
5042 bool returnValue;
5038 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
5043 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
5039 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5044 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5040 if (result) {
5045 if (result) {
5041 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5046 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5042 if (args[0]!=&returnValue) {
5047 if (args[0]!=&returnValue) {
5043 if (args[0]==NULL) {
5048 if (args[0]==NULL) {
5044 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
5049 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
5045 } else {
5050 } else {
5046 returnValue = *((bool*)args[0]);
5051 returnValue = *((bool*)args[0]);
5047 }
5052 }
5048 }
5053 }
5049 }
5054 }
5050 if (result) { Py_DECREF(result); }
5055 if (result) { Py_DECREF(result); }
5051 Py_DECREF(obj);
5056 Py_DECREF(obj);
5052 return returnValue;
5057 return returnValue;
5053 } else {
5058 } else {
5054 PyErr_Clear();
5059 PyErr_Clear();
5055 }
5060 }
5056 }
5061 }
5057 return TCP_Terminal_Client::eventFilter(arg__1, arg__2);
5062 return TCP_Terminal_Client::eventFilter(arg__1, arg__2);
5058 }
5063 }
5059 void PythonQtShell_TCP_Terminal_Client::timerEvent(QTimerEvent* arg__1)
5064 void PythonQtShell_TCP_Terminal_Client::timerEvent(QTimerEvent* arg__1)
5060 {
5065 {
5061 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5066 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5062 static PyObject* name = PyString_FromString("timerEvent");
5067 static PyObject* name = PyString_FromString("timerEvent");
5063 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5068 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5064 if (obj) {
5069 if (obj) {
5065 static const char* argumentList[] ={"" , "QTimerEvent*"};
5070 static const char* argumentList[] ={"" , "QTimerEvent*"};
5066 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5071 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5067 void* args[2] = {NULL, (void*)&arg__1};
5072 void* args[2] = {NULL, (void*)&arg__1};
5068 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5073 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5069 if (result) { Py_DECREF(result); }
5074 if (result) { Py_DECREF(result); }
5070 Py_DECREF(obj);
5075 Py_DECREF(obj);
5071 return;
5076 return;
5072 } else {
5077 } else {
5073 PyErr_Clear();
5078 PyErr_Clear();
5074 }
5079 }
5075 }
5080 }
5076 TCP_Terminal_Client::timerEvent(arg__1);
5081 TCP_Terminal_Client::timerEvent(arg__1);
5077 }
5082 }
5078 TCP_Terminal_Client* PythonQtWrapper_TCP_Terminal_Client::new_TCP_Terminal_Client(QObject* parent)
5083 TCP_Terminal_Client* PythonQtWrapper_TCP_Terminal_Client::new_TCP_Terminal_Client(QObject* parent)
5079 {
5084 {
5080 return new PythonQtShell_TCP_Terminal_Client(parent); }
5085 return new PythonQtShell_TCP_Terminal_Client(parent); }
5081
5086
5082 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject)
5087 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject)
5083 {
5088 {
5084 ( theWrappedObject->connectToServer());
5089 ( theWrappedObject->connectToServer());
5085 }
5090 }
5086
5091
5087 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port)
5092 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port)
5088 {
5093 {
5089 ( theWrappedObject->connectToServer(IP, port));
5094 ( theWrappedObject->connectToServer(IP, port));
5090 }
5095 }
5091
5096
5092 bool PythonQtWrapper_TCP_Terminal_Client::isConnected(TCP_Terminal_Client* theWrappedObject)
5097 bool PythonQtWrapper_TCP_Terminal_Client::isConnected(TCP_Terminal_Client* theWrappedObject)
5093 {
5098 {
5094 return ( theWrappedObject->isConnected());
5099 return ( theWrappedObject->isConnected());
5095 }
5100 }
5096
5101
5097 void PythonQtWrapper_TCP_Terminal_Client::sendText(TCP_Terminal_Client* theWrappedObject, const QString& text)
5102 void PythonQtWrapper_TCP_Terminal_Client::sendText(TCP_Terminal_Client* theWrappedObject, const QString& text)
5098 {
5103 {
5099 ( theWrappedObject->sendText(text));
5104 ( theWrappedObject->sendText(text));
5100 }
5105 }
5101
5106
5102 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject)
5107 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject)
5103 {
5108 {
5104 ( theWrappedObject->startServer());
5109 ( theWrappedObject->startServer());
5105 }
5110 }
5106
5111
5107 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject, int port)
5112 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject, int port)
5108 {
5113 {
5109 ( theWrappedObject->startServer(port));
5114 ( theWrappedObject->startServer(port));
5110 }
5115 }
5111
5116
5112
5117
5113
5118
5114 XByteArray* PythonQtWrapper_XByteArray::new_XByteArray()
5119 XByteArray* PythonQtWrapper_XByteArray::new_XByteArray()
5115 {
5120 {
5116 return new XByteArray(); }
5121 return new XByteArray(); }
5117
5122
5118 int PythonQtWrapper_XByteArray::addressOffset(XByteArray* theWrappedObject)
5123 int PythonQtWrapper_XByteArray::addressOffset(XByteArray* theWrappedObject)
5119 {
5124 {
5120 return ( theWrappedObject->addressOffset());
5125 return ( theWrappedObject->addressOffset());
5121 }
5126 }
5122
5127
5123 int PythonQtWrapper_XByteArray::addressWidth(XByteArray* theWrappedObject)
5128 int PythonQtWrapper_XByteArray::addressWidth(XByteArray* theWrappedObject)
5124 {
5129 {
5125 return ( theWrappedObject->addressWidth());
5130 return ( theWrappedObject->addressWidth());
5126 }
5131 }
5127
5132
5128 QChar PythonQtWrapper_XByteArray::asciiChar(XByteArray* theWrappedObject, int index)
5133 QChar PythonQtWrapper_XByteArray::asciiChar(XByteArray* theWrappedObject, int index)
5129 {
5134 {
5130 return ( theWrappedObject->asciiChar(index));
5135 return ( theWrappedObject->asciiChar(index));
5131 }
5136 }
5132
5137
5133 QByteArray* PythonQtWrapper_XByteArray::data(XByteArray* theWrappedObject)
5138 QByteArray* PythonQtWrapper_XByteArray::data(XByteArray* theWrappedObject)
5134 {
5139 {
5135 return &( theWrappedObject->data());
5140 return &( theWrappedObject->data());
5136 }
5141 }
5137
5142
5138 bool PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i)
5143 bool PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i)
5139 {
5144 {
5140 return ( theWrappedObject->dataChanged(i));
5145 return ( theWrappedObject->dataChanged(i));
5141 }
5146 }
5142
5147
5143 QByteArray PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i, int len)
5148 QByteArray PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i, int len)
5144 {
5149 {
5145 return ( theWrappedObject->dataChanged(i, len));
5150 return ( theWrappedObject->dataChanged(i, len));
5146 }
5151 }
5147
5152
5148 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, char ch)
5153 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, char ch)
5149 {
5154 {
5150 return &( theWrappedObject->insert(i, ch));
5155 return &( theWrappedObject->insert(i, ch));
5151 }
5156 }
5152
5157
5153 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, const QByteArray& ba)
5158 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, const QByteArray& ba)
5154 {
5159 {
5155 return &( theWrappedObject->insert(i, ba));
5160 return &( theWrappedObject->insert(i, ba));
5156 }
5161 }
5157
5162
5158 int PythonQtWrapper_XByteArray::realAddressNumbers(XByteArray* theWrappedObject)
5163 int PythonQtWrapper_XByteArray::realAddressNumbers(XByteArray* theWrappedObject)
5159 {
5164 {
5160 return ( theWrappedObject->realAddressNumbers());
5165 return ( theWrappedObject->realAddressNumbers());
5161 }
5166 }
5162
5167
5163 QByteArray* PythonQtWrapper_XByteArray::remove(XByteArray* theWrappedObject, int pos, int len)
5168 QByteArray* PythonQtWrapper_XByteArray::remove(XByteArray* theWrappedObject, int pos, int len)
5164 {
5169 {
5165 return &( theWrappedObject->remove(pos, len));
5170 return &( theWrappedObject->remove(pos, len));
5166 }
5171 }
5167
5172
5168 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, char ch)
5173 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, char ch)
5169 {
5174 {
5170 return &( theWrappedObject->replace(index, ch));
5175 return &( theWrappedObject->replace(index, ch));
5171 }
5176 }
5172
5177
5173 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, const QByteArray& ba)
5178 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, const QByteArray& ba)
5174 {
5179 {
5175 return &( theWrappedObject->replace(index, ba));
5180 return &( theWrappedObject->replace(index, ba));
5176 }
5181 }
5177
5182
5178 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba)
5183 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba)
5179 {
5184 {
5180 return &( theWrappedObject->replace(index, length, ba));
5185 return &( theWrappedObject->replace(index, length, ba));
5181 }
5186 }
5182
5187
5183 void PythonQtWrapper_XByteArray::setAddressOffset(XByteArray* theWrappedObject, int offset)
5188 void PythonQtWrapper_XByteArray::setAddressOffset(XByteArray* theWrappedObject, int offset)
5184 {
5189 {
5185 ( theWrappedObject->setAddressOffset(offset));
5190 ( theWrappedObject->setAddressOffset(offset));
5186 }
5191 }
5187
5192
5188 void PythonQtWrapper_XByteArray::setAddressWidth(XByteArray* theWrappedObject, int width)
5193 void PythonQtWrapper_XByteArray::setAddressWidth(XByteArray* theWrappedObject, int width)
5189 {
5194 {
5190 ( theWrappedObject->setAddressWidth(width));
5195 ( theWrappedObject->setAddressWidth(width));
5191 }
5196 }
5192
5197
5193 void PythonQtWrapper_XByteArray::setData(XByteArray* theWrappedObject, QByteArray data)
5198 void PythonQtWrapper_XByteArray::setData(XByteArray* theWrappedObject, QByteArray data)
5194 {
5199 {
5195 ( theWrappedObject->setData(data));
5200 ( theWrappedObject->setData(data));
5196 }
5201 }
5197
5202
5198 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, bool state)
5203 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, bool state)
5199 {
5204 {
5200 ( theWrappedObject->setDataChanged(i, state));
5205 ( theWrappedObject->setDataChanged(i, state));
5201 }
5206 }
5202
5207
5203 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state)
5208 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state)
5204 {
5209 {
5205 ( theWrappedObject->setDataChanged(i, state));
5210 ( theWrappedObject->setDataChanged(i, state));
5206 }
5211 }
5207
5212
5208 int PythonQtWrapper_XByteArray::size(XByteArray* theWrappedObject)
5213 int PythonQtWrapper_XByteArray::size(XByteArray* theWrappedObject)
5209 {
5214 {
5210 return ( theWrappedObject->size());
5215 return ( theWrappedObject->size());
5211 }
5216 }
5212
5217
5213 QString PythonQtWrapper_XByteArray::toRedableString(XByteArray* theWrappedObject, int start, int end)
5218 QString PythonQtWrapper_XByteArray::toRedableString(XByteArray* theWrappedObject, int start, int end)
5214 {
5219 {
5215 return ( theWrappedObject->toRedableString(start, end));
5220 return ( theWrappedObject->toRedableString(start, end));
5216 }
5221 }
5217
5222
5218
5223
5219
5224
5220 PythonQtShell_abstractBinFile::~PythonQtShell_abstractBinFile() {
5225 PythonQtShell_abstractBinFile::~PythonQtShell_abstractBinFile() {
5221 PythonQtPrivate* priv = PythonQt::priv();
5226 PythonQtPrivate* priv = PythonQt::priv();
5222 if (priv) { priv->shellClassDeleted(this); }
5227 if (priv) { priv->shellClassDeleted(this); }
5223 }
5228 }
5224 void PythonQtShell_abstractBinFile::childEvent(QChildEvent* arg__1)
5229 void PythonQtShell_abstractBinFile::childEvent(QChildEvent* arg__1)
5225 {
5230 {
5226 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5231 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5227 static PyObject* name = PyString_FromString("childEvent");
5232 static PyObject* name = PyString_FromString("childEvent");
5228 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5233 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5229 if (obj) {
5234 if (obj) {
5230 static const char* argumentList[] ={"" , "QChildEvent*"};
5235 static const char* argumentList[] ={"" , "QChildEvent*"};
5231 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5236 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5232 void* args[2] = {NULL, (void*)&arg__1};
5237 void* args[2] = {NULL, (void*)&arg__1};
5233 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5238 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5234 if (result) { Py_DECREF(result); }
5239 if (result) { Py_DECREF(result); }
5235 Py_DECREF(obj);
5240 Py_DECREF(obj);
5236 return;
5241 return;
5237 } else {
5242 } else {
5238 PyErr_Clear();
5243 PyErr_Clear();
5239 }
5244 }
5240 }
5245 }
5241 abstractBinFile::childEvent(arg__1);
5246 abstractBinFile::childEvent(arg__1);
5242 }
5247 }
5243 int PythonQtShell_abstractBinFile::closeFile()
5248 int PythonQtShell_abstractBinFile::closeFile()
5244 {
5249 {
5245 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5250 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5246 static PyObject* name = PyString_FromString("closeFile");
5251 static PyObject* name = PyString_FromString("closeFile");
5247 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5252 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5248 if (obj) {
5253 if (obj) {
5249 static const char* argumentList[] ={"int"};
5254 static const char* argumentList[] ={"int"};
5250 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5255 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5251 int returnValue;
5256 int returnValue;
5252 void* args[1] = {NULL};
5257 void* args[1] = {NULL};
5253 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5258 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5254 if (result) {
5259 if (result) {
5255 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5260 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5256 if (args[0]!=&returnValue) {
5261 if (args[0]!=&returnValue) {
5257 if (args[0]==NULL) {
5262 if (args[0]==NULL) {
5258 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
5263 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
5259 } else {
5264 } else {
5260 returnValue = *((int*)args[0]);
5265 returnValue = *((int*)args[0]);
5261 }
5266 }
5262 }
5267 }
5263 }
5268 }
5264 if (result) { Py_DECREF(result); }
5269 if (result) { Py_DECREF(result); }
5265 Py_DECREF(obj);
5270 Py_DECREF(obj);
5266 return returnValue;
5271 return returnValue;
5267 } else {
5272 } else {
5268 PyErr_Clear();
5273 PyErr_Clear();
5269 }
5274 }
5270 }
5275 }
5271 return int();
5276 return int();
5272 }
5277 }
5273 void PythonQtShell_abstractBinFile::customEvent(QEvent* arg__1)
5278 void PythonQtShell_abstractBinFile::customEvent(QEvent* arg__1)
5274 {
5279 {
5275 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5280 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5276 static PyObject* name = PyString_FromString("customEvent");
5281 static PyObject* name = PyString_FromString("customEvent");
5277 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5282 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5278 if (obj) {
5283 if (obj) {
5279 static const char* argumentList[] ={"" , "QEvent*"};
5284 static const char* argumentList[] ={"" , "QEvent*"};
5280 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5285 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5281 void* args[2] = {NULL, (void*)&arg__1};
5286 void* args[2] = {NULL, (void*)&arg__1};
5282 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5287 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5283 if (result) { Py_DECREF(result); }
5288 if (result) { Py_DECREF(result); }
5284 Py_DECREF(obj);
5289 Py_DECREF(obj);
5285 return;
5290 return;
5286 } else {
5291 } else {
5287 PyErr_Clear();
5292 PyErr_Clear();
5288 }
5293 }
5289 }
5294 }
5290 abstractBinFile::customEvent(arg__1);
5295 abstractBinFile::customEvent(arg__1);
5291 }
5296 }
5292 bool PythonQtShell_abstractBinFile::event(QEvent* arg__1)
5297 bool PythonQtShell_abstractBinFile::event(QEvent* arg__1)
5293 {
5298 {
5294 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5299 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5295 static PyObject* name = PyString_FromString("event");
5300 static PyObject* name = PyString_FromString("event");
5296 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5301 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5297 if (obj) {
5302 if (obj) {
5298 static const char* argumentList[] ={"bool" , "QEvent*"};
5303 static const char* argumentList[] ={"bool" , "QEvent*"};
5299 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5304 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5300 bool returnValue;
5305 bool returnValue;
5301 void* args[2] = {NULL, (void*)&arg__1};
5306 void* args[2] = {NULL, (void*)&arg__1};
5302 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5307 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5303 if (result) {
5308 if (result) {
5304 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5309 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5305 if (args[0]!=&returnValue) {
5310 if (args[0]!=&returnValue) {
5306 if (args[0]==NULL) {
5311 if (args[0]==NULL) {
5307 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
5312 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
5308 } else {
5313 } else {
5309 returnValue = *((bool*)args[0]);
5314 returnValue = *((bool*)args[0]);
5310 }
5315 }
5311 }
5316 }
5312 }
5317 }
5313 if (result) { Py_DECREF(result); }
5318 if (result) { Py_DECREF(result); }
5314 Py_DECREF(obj);
5319 Py_DECREF(obj);
5315 return returnValue;
5320 return returnValue;
5316 } else {
5321 } else {
5317 PyErr_Clear();
5322 PyErr_Clear();
5318 }
5323 }
5319 }
5324 }
5320 return abstractBinFile::event(arg__1);
5325 return abstractBinFile::event(arg__1);
5321 }
5326 }
5322 bool PythonQtShell_abstractBinFile::eventFilter(QObject* arg__1, QEvent* arg__2)
5327 bool PythonQtShell_abstractBinFile::eventFilter(QObject* arg__1, QEvent* arg__2)
5323 {
5328 {
5324 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5329 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5325 static PyObject* name = PyString_FromString("eventFilter");
5330 static PyObject* name = PyString_FromString("eventFilter");
5326 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5331 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5327 if (obj) {
5332 if (obj) {
5328 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5333 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5329 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5334 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5330 bool returnValue;
5335 bool returnValue;
5331 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
5336 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
5332 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5337 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5333 if (result) {
5338 if (result) {
5334 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5339 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5335 if (args[0]!=&returnValue) {
5340 if (args[0]!=&returnValue) {
5336 if (args[0]==NULL) {
5341 if (args[0]==NULL) {
5337 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
5342 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
5338 } else {
5343 } else {
5339 returnValue = *((bool*)args[0]);
5344 returnValue = *((bool*)args[0]);
5340 }
5345 }
5341 }
5346 }
5342 }
5347 }
5343 if (result) { Py_DECREF(result); }
5348 if (result) { Py_DECREF(result); }
5344 Py_DECREF(obj);
5349 Py_DECREF(obj);
5345 return returnValue;
5350 return returnValue;
5346 } else {
5351 } else {
5347 PyErr_Clear();
5352 PyErr_Clear();
5348 }
5353 }
5349 }
5354 }
5350 return abstractBinFile::eventFilter(arg__1, arg__2);
5355 return abstractBinFile::eventFilter(arg__1, arg__2);
5351 }
5356 }
5352 QList<codeFragment* > PythonQtShell_abstractBinFile::getFragments()
5357 QList<codeFragment* > PythonQtShell_abstractBinFile::getFragments()
5353 {
5358 {
5354 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5359 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5355 static PyObject* name = PyString_FromString("getFragments");
5360 static PyObject* name = PyString_FromString("getFragments");
5356 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5361 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5357 if (obj) {
5362 if (obj) {
5358 static const char* argumentList[] ={"QList<codeFragment* >"};
5363 static const char* argumentList[] ={"QList<codeFragment* >"};
5359 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5364 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5360 QList<codeFragment* > returnValue;
5365 QList<codeFragment* > returnValue;
5361 void* args[1] = {NULL};
5366 void* args[1] = {NULL};
5362 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5367 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5363 if (result) {
5368 if (result) {
5364 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5369 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5365 if (args[0]!=&returnValue) {
5370 if (args[0]!=&returnValue) {
5366 if (args[0]==NULL) {
5371 if (args[0]==NULL) {
5367 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
5372 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
5368 } else {
5373 } else {
5369 returnValue = *((QList<codeFragment* >*)args[0]);
5374 returnValue = *((QList<codeFragment* >*)args[0]);
5370 }
5375 }
5371 }
5376 }
5372 }
5377 }
5373 if (result) { Py_DECREF(result); }
5378 if (result) { Py_DECREF(result); }
5374 Py_DECREF(obj);
5379 Py_DECREF(obj);
5375 return returnValue;
5380 return returnValue;
5376 } else {
5381 } else {
5377 PyErr_Clear();
5382 PyErr_Clear();
5378 }
5383 }
5379 }
5384 }
5380 return QList<codeFragment* >();
5385 return QList<codeFragment* >();
5381 }
5386 }
5382 bool PythonQtShell_abstractBinFile::isopened()
5387 bool PythonQtShell_abstractBinFile::isopened()
5383 {
5388 {
5384 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5389 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5385 static PyObject* name = PyString_FromString("isopened");
5390 static PyObject* name = PyString_FromString("isopened");
5386 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5391 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5387 if (obj) {
5392 if (obj) {
5388 static const char* argumentList[] ={"bool"};
5393 static const char* argumentList[] ={"bool"};
5389 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5394 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5390 bool returnValue;
5395 bool returnValue;
5391 void* args[1] = {NULL};
5396 void* args[1] = {NULL};
5392 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5397 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5393 if (result) {
5398 if (result) {
5394 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5399 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5395 if (args[0]!=&returnValue) {
5400 if (args[0]!=&returnValue) {
5396 if (args[0]==NULL) {
5401 if (args[0]==NULL) {
5397 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
5402 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
5398 } else {
5403 } else {
5399 returnValue = *((bool*)args[0]);
5404 returnValue = *((bool*)args[0]);
5400 }
5405 }
5401 }
5406 }
5402 }
5407 }
5403 if (result) { Py_DECREF(result); }
5408 if (result) { Py_DECREF(result); }
5404 Py_DECREF(obj);
5409 Py_DECREF(obj);
5405 return returnValue;
5410 return returnValue;
5406 } else {
5411 } else {
5407 PyErr_Clear();
5412 PyErr_Clear();
5408 }
5413 }
5409 }
5414 }
5410 return bool();
5415 return bool();
5411 }
5416 }
5412 bool PythonQtShell_abstractBinFile::openFile(const QString& File0)
5417 bool PythonQtShell_abstractBinFile::openFile(const QString& File0)
5413 {
5418 {
5414 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5419 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5415 static PyObject* name = PyString_FromString("openFile");
5420 static PyObject* name = PyString_FromString("openFile");
5416 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5421 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5417 if (obj) {
5422 if (obj) {
5418 static const char* argumentList[] ={"bool" , "const QString&"};
5423 static const char* argumentList[] ={"bool" , "const QString&"};
5419 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5424 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5420 bool returnValue;
5425 bool returnValue;
5421 void* args[2] = {NULL, (void*)&File0};
5426 void* args[2] = {NULL, (void*)&File0};
5422 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5427 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5423 if (result) {
5428 if (result) {
5424 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5429 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5425 if (args[0]!=&returnValue) {
5430 if (args[0]!=&returnValue) {
5426 if (args[0]==NULL) {
5431 if (args[0]==NULL) {
5427 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
5432 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
5428 } else {
5433 } else {
5429 returnValue = *((bool*)args[0]);
5434 returnValue = *((bool*)args[0]);
5430 }
5435 }
5431 }
5436 }
5432 }
5437 }
5433 if (result) { Py_DECREF(result); }
5438 if (result) { Py_DECREF(result); }
5434 Py_DECREF(obj);
5439 Py_DECREF(obj);
5435 return returnValue;
5440 return returnValue;
5436 } else {
5441 } else {
5437 PyErr_Clear();
5442 PyErr_Clear();
5438 }
5443 }
5439 }
5444 }
5440 return bool();
5445 return bool();
5441 }
5446 }
5442 void PythonQtShell_abstractBinFile::timerEvent(QTimerEvent* arg__1)
5447 void PythonQtShell_abstractBinFile::timerEvent(QTimerEvent* arg__1)
5443 {
5448 {
5444 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5449 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5445 static PyObject* name = PyString_FromString("timerEvent");
5450 static PyObject* name = PyString_FromString("timerEvent");
5446 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5451 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5447 if (obj) {
5452 if (obj) {
5448 static const char* argumentList[] ={"" , "QTimerEvent*"};
5453 static const char* argumentList[] ={"" , "QTimerEvent*"};
5449 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5454 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5450 void* args[2] = {NULL, (void*)&arg__1};
5455 void* args[2] = {NULL, (void*)&arg__1};
5451 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5456 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5452 if (result) { Py_DECREF(result); }
5457 if (result) { Py_DECREF(result); }
5453 Py_DECREF(obj);
5458 Py_DECREF(obj);
5454 return;
5459 return;
5455 } else {
5460 } else {
5456 PyErr_Clear();
5461 PyErr_Clear();
5457 }
5462 }
5458 }
5463 }
5459 abstractBinFile::timerEvent(arg__1);
5464 abstractBinFile::timerEvent(arg__1);
5460 }
5465 }
5461 bool PythonQtShell_abstractBinFile::toBinary(const QString& File0)
5466 bool PythonQtShell_abstractBinFile::toBinary(const QString& File0)
5462 {
5467 {
5463 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5468 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5464 static PyObject* name = PyString_FromString("toBinary");
5469 static PyObject* name = PyString_FromString("toBinary");
5465 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5470 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5466 if (obj) {
5471 if (obj) {
5467 static const char* argumentList[] ={"bool" , "const QString&"};
5472 static const char* argumentList[] ={"bool" , "const QString&"};
5468 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5473 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5469 bool returnValue;
5474 bool returnValue;
5470 void* args[2] = {NULL, (void*)&File0};
5475 void* args[2] = {NULL, (void*)&File0};
5471 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5476 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5472 if (result) {
5477 if (result) {
5473 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5478 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5474 if (args[0]!=&returnValue) {
5479 if (args[0]!=&returnValue) {
5475 if (args[0]==NULL) {
5480 if (args[0]==NULL) {
5476 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
5481 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
5477 } else {
5482 } else {
5478 returnValue = *((bool*)args[0]);
5483 returnValue = *((bool*)args[0]);
5479 }
5484 }
5480 }
5485 }
5481 }
5486 }
5482 if (result) { Py_DECREF(result); }
5487 if (result) { Py_DECREF(result); }
5483 Py_DECREF(obj);
5488 Py_DECREF(obj);
5484 return returnValue;
5489 return returnValue;
5485 } else {
5490 } else {
5486 PyErr_Clear();
5491 PyErr_Clear();
5487 }
5492 }
5488 }
5493 }
5489 return bool();
5494 return bool();
5490 }
5495 }
5491 bool PythonQtShell_abstractBinFile::toSrec(const QString& File0)
5496 bool PythonQtShell_abstractBinFile::toSrec(const QString& File0)
5492 {
5497 {
5493 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5498 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5494 static PyObject* name = PyString_FromString("toSrec");
5499 static PyObject* name = PyString_FromString("toSrec");
5495 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5500 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5496 if (obj) {
5501 if (obj) {
5497 static const char* argumentList[] ={"bool" , "const QString&"};
5502 static const char* argumentList[] ={"bool" , "const QString&"};
5498 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5503 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5499 bool returnValue;
5504 bool returnValue;
5500 void* args[2] = {NULL, (void*)&File0};
5505 void* args[2] = {NULL, (void*)&File0};
5501 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5506 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5502 if (result) {
5507 if (result) {
5503 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5508 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5504 if (args[0]!=&returnValue) {
5509 if (args[0]!=&returnValue) {
5505 if (args[0]==NULL) {
5510 if (args[0]==NULL) {
5506 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
5511 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
5507 } else {
5512 } else {
5508 returnValue = *((bool*)args[0]);
5513 returnValue = *((bool*)args[0]);
5509 }
5514 }
5510 }
5515 }
5511 }
5516 }
5512 if (result) { Py_DECREF(result); }
5517 if (result) { Py_DECREF(result); }
5513 Py_DECREF(obj);
5518 Py_DECREF(obj);
5514 return returnValue;
5519 return returnValue;
5515 } else {
5520 } else {
5516 PyErr_Clear();
5521 PyErr_Clear();
5517 }
5522 }
5518 }
5523 }
5519 return bool();
5524 return bool();
5520 }
5525 }
5521 abstractBinFile* PythonQtWrapper_abstractBinFile::new_abstractBinFile()
5526 abstractBinFile* PythonQtWrapper_abstractBinFile::new_abstractBinFile()
5522 {
5527 {
5523 return new PythonQtShell_abstractBinFile(); }
5528 return new PythonQtShell_abstractBinFile(); }
5524
5529
5525 int PythonQtWrapper_abstractBinFile::closeFile(abstractBinFile* theWrappedObject)
5530 int PythonQtWrapper_abstractBinFile::closeFile(abstractBinFile* theWrappedObject)
5526 {
5531 {
5527 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_closeFile());
5532 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_closeFile());
5528 }
5533 }
5529
5534
5530 QList<codeFragment* > PythonQtWrapper_abstractBinFile::getFragments(abstractBinFile* theWrappedObject)
5535 QList<codeFragment* > PythonQtWrapper_abstractBinFile::getFragments(abstractBinFile* theWrappedObject)
5531 {
5536 {
5532 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_getFragments());
5537 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_getFragments());
5533 }
5538 }
5534
5539
5535 bool PythonQtWrapper_abstractBinFile::isopened(abstractBinFile* theWrappedObject)
5540 bool PythonQtWrapper_abstractBinFile::isopened(abstractBinFile* theWrappedObject)
5536 {
5541 {
5537 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_isopened());
5542 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_isopened());
5538 }
5543 }
5539
5544
5540 bool PythonQtWrapper_abstractBinFile::openFile(abstractBinFile* theWrappedObject, const QString& File)
5545 bool PythonQtWrapper_abstractBinFile::openFile(abstractBinFile* theWrappedObject, const QString& File)
5541 {
5546 {
5542 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_openFile(File));
5547 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_openFile(File));
5543 }
5548 }
5544
5549
5545 bool PythonQtWrapper_abstractBinFile::toBinary(abstractBinFile* theWrappedObject, const QString& File)
5550 bool PythonQtWrapper_abstractBinFile::toBinary(abstractBinFile* theWrappedObject, const QString& File)
5546 {
5551 {
5547 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_toBinary(File));
5552 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_toBinary(File));
5548 }
5553 }
5549
5554
5550 bool PythonQtWrapper_abstractBinFile::toSrec(abstractBinFile* theWrappedObject, const QString& File)
5555 bool PythonQtWrapper_abstractBinFile::toSrec(abstractBinFile* theWrappedObject, const QString& File)
5551 {
5556 {
5552 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_toSrec(File));
5557 return ( ((PythonQtPublicPromoter_abstractBinFile*)theWrappedObject)->promoted_toSrec(File));
5553 }
5558 }
5554
5559
5555
5560
5556
5561
5557 PythonQtShell_abstractBinFileWidget::~PythonQtShell_abstractBinFileWidget() {
5562 PythonQtShell_abstractBinFileWidget::~PythonQtShell_abstractBinFileWidget() {
5558 PythonQtPrivate* priv = PythonQt::priv();
5563 PythonQtPrivate* priv = PythonQt::priv();
5559 if (priv) { priv->shellClassDeleted(this); }
5564 if (priv) { priv->shellClassDeleted(this); }
5560 }
5565 }
5561 void PythonQtShell_abstractBinFileWidget::actionEvent(QActionEvent* arg__1)
5566 void PythonQtShell_abstractBinFileWidget::actionEvent(QActionEvent* arg__1)
5562 {
5567 {
5563 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5568 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5564 static PyObject* name = PyString_FromString("actionEvent");
5569 static PyObject* name = PyString_FromString("actionEvent");
5565 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5570 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5566 if (obj) {
5571 if (obj) {
5567 static const char* argumentList[] ={"" , "QActionEvent*"};
5572 static const char* argumentList[] ={"" , "QActionEvent*"};
5568 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5573 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5569 void* args[2] = {NULL, (void*)&arg__1};
5574 void* args[2] = {NULL, (void*)&arg__1};
5570 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5575 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5571 if (result) { Py_DECREF(result); }
5576 if (result) { Py_DECREF(result); }
5572 Py_DECREF(obj);
5577 Py_DECREF(obj);
5573 return;
5578 return;
5574 } else {
5579 } else {
5575 PyErr_Clear();
5580 PyErr_Clear();
5576 }
5581 }
5577 }
5582 }
5578 abstractBinFileWidget::actionEvent(arg__1);
5583 abstractBinFileWidget::actionEvent(arg__1);
5579 }
5584 }
5580 void PythonQtShell_abstractBinFileWidget::changeEvent(QEvent* arg__1)
5585 void PythonQtShell_abstractBinFileWidget::changeEvent(QEvent* arg__1)
5581 {
5586 {
5582 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5587 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5583 static PyObject* name = PyString_FromString("changeEvent");
5588 static PyObject* name = PyString_FromString("changeEvent");
5584 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5589 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5585 if (obj) {
5590 if (obj) {
5586 static const char* argumentList[] ={"" , "QEvent*"};
5591 static const char* argumentList[] ={"" , "QEvent*"};
5587 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5592 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5588 void* args[2] = {NULL, (void*)&arg__1};
5593 void* args[2] = {NULL, (void*)&arg__1};
5589 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5594 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5590 if (result) { Py_DECREF(result); }
5595 if (result) { Py_DECREF(result); }
5591 Py_DECREF(obj);
5596 Py_DECREF(obj);
5592 return;
5597 return;
5593 } else {
5598 } else {
5594 PyErr_Clear();
5599 PyErr_Clear();
5595 }
5600 }
5596 }
5601 }
5597 abstractBinFileWidget::changeEvent(arg__1);
5602 abstractBinFileWidget::changeEvent(arg__1);
5598 }
5603 }
5599 void PythonQtShell_abstractBinFileWidget::childEvent(QChildEvent* arg__1)
5604 void PythonQtShell_abstractBinFileWidget::childEvent(QChildEvent* arg__1)
5600 {
5605 {
5601 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5606 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5602 static PyObject* name = PyString_FromString("childEvent");
5607 static PyObject* name = PyString_FromString("childEvent");
5603 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5608 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5604 if (obj) {
5609 if (obj) {
5605 static const char* argumentList[] ={"" , "QChildEvent*"};
5610 static const char* argumentList[] ={"" , "QChildEvent*"};
5606 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5611 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5607 void* args[2] = {NULL, (void*)&arg__1};
5612 void* args[2] = {NULL, (void*)&arg__1};
5608 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5613 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5609 if (result) { Py_DECREF(result); }
5614 if (result) { Py_DECREF(result); }
5610 Py_DECREF(obj);
5615 Py_DECREF(obj);
5611 return;
5616 return;
5612 } else {
5617 } else {
5613 PyErr_Clear();
5618 PyErr_Clear();
5614 }
5619 }
5615 }
5620 }
5616 abstractBinFileWidget::childEvent(arg__1);
5621 abstractBinFileWidget::childEvent(arg__1);
5617 }
5622 }
5618 void PythonQtShell_abstractBinFileWidget::closeEvent(QCloseEvent* arg__1)
5623 void PythonQtShell_abstractBinFileWidget::closeEvent(QCloseEvent* arg__1)
5619 {
5624 {
5620 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5625 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5621 static PyObject* name = PyString_FromString("closeEvent");
5626 static PyObject* name = PyString_FromString("closeEvent");
5622 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5627 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5623 if (obj) {
5628 if (obj) {
5624 static const char* argumentList[] ={"" , "QCloseEvent*"};
5629 static const char* argumentList[] ={"" , "QCloseEvent*"};
5625 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5630 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5626 void* args[2] = {NULL, (void*)&arg__1};
5631 void* args[2] = {NULL, (void*)&arg__1};
5627 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5632 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5628 if (result) { Py_DECREF(result); }
5633 if (result) { Py_DECREF(result); }
5629 Py_DECREF(obj);
5634 Py_DECREF(obj);
5630 return;
5635 return;
5631 } else {
5636 } else {
5632 PyErr_Clear();
5637 PyErr_Clear();
5633 }
5638 }
5634 }
5639 }
5635 abstractBinFileWidget::closeEvent(arg__1);
5640 abstractBinFileWidget::closeEvent(arg__1);
5636 }
5641 }
5637 void PythonQtShell_abstractBinFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
5642 void PythonQtShell_abstractBinFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
5638 {
5643 {
5639 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5644 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5640 static PyObject* name = PyString_FromString("contextMenuEvent");
5645 static PyObject* name = PyString_FromString("contextMenuEvent");
5641 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5646 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5642 if (obj) {
5647 if (obj) {
5643 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
5648 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
5644 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5649 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5645 void* args[2] = {NULL, (void*)&arg__1};
5650 void* args[2] = {NULL, (void*)&arg__1};
5646 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5651 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5647 if (result) { Py_DECREF(result); }
5652 if (result) { Py_DECREF(result); }
5648 Py_DECREF(obj);
5653 Py_DECREF(obj);
5649 return;
5654 return;
5650 } else {
5655 } else {
5651 PyErr_Clear();
5656 PyErr_Clear();
5652 }
5657 }
5653 }
5658 }
5654 abstractBinFileWidget::contextMenuEvent(arg__1);
5659 abstractBinFileWidget::contextMenuEvent(arg__1);
5655 }
5660 }
5656 void PythonQtShell_abstractBinFileWidget::customEvent(QEvent* arg__1)
5661 void PythonQtShell_abstractBinFileWidget::customEvent(QEvent* arg__1)
5657 {
5662 {
5658 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5663 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5659 static PyObject* name = PyString_FromString("customEvent");
5664 static PyObject* name = PyString_FromString("customEvent");
5660 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5665 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5661 if (obj) {
5666 if (obj) {
5662 static const char* argumentList[] ={"" , "QEvent*"};
5667 static const char* argumentList[] ={"" , "QEvent*"};
5663 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5668 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5664 void* args[2] = {NULL, (void*)&arg__1};
5669 void* args[2] = {NULL, (void*)&arg__1};
5665 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5670 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5666 if (result) { Py_DECREF(result); }
5671 if (result) { Py_DECREF(result); }
5667 Py_DECREF(obj);
5672 Py_DECREF(obj);
5668 return;
5673 return;
5669 } else {
5674 } else {
5670 PyErr_Clear();
5675 PyErr_Clear();
5671 }
5676 }
5672 }
5677 }
5673 abstractBinFileWidget::customEvent(arg__1);
5678 abstractBinFileWidget::customEvent(arg__1);
5674 }
5679 }
5675 int PythonQtShell_abstractBinFileWidget::devType() const
5680 int PythonQtShell_abstractBinFileWidget::devType() const
5676 {
5681 {
5677 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5682 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5678 static PyObject* name = PyString_FromString("devType");
5683 static PyObject* name = PyString_FromString("devType");
5679 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5684 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5680 if (obj) {
5685 if (obj) {
5681 static const char* argumentList[] ={"int"};
5686 static const char* argumentList[] ={"int"};
5682 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5687 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5683 int returnValue;
5688 int returnValue;
5684 void* args[1] = {NULL};
5689 void* args[1] = {NULL};
5685 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5690 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5686 if (result) {
5691 if (result) {
5687 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5692 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5688 if (args[0]!=&returnValue) {
5693 if (args[0]!=&returnValue) {
5689 if (args[0]==NULL) {
5694 if (args[0]==NULL) {
5690 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
5695 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
5691 } else {
5696 } else {
5692 returnValue = *((int*)args[0]);
5697 returnValue = *((int*)args[0]);
5693 }
5698 }
5694 }
5699 }
5695 }
5700 }
5696 if (result) { Py_DECREF(result); }
5701 if (result) { Py_DECREF(result); }
5697 Py_DECREF(obj);
5702 Py_DECREF(obj);
5698 return returnValue;
5703 return returnValue;
5699 } else {
5704 } else {
5700 PyErr_Clear();
5705 PyErr_Clear();
5701 }
5706 }
5702 }
5707 }
5703 return abstractBinFileWidget::devType();
5708 return abstractBinFileWidget::devType();
5704 }
5709 }
5705 void PythonQtShell_abstractBinFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
5710 void PythonQtShell_abstractBinFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
5706 {
5711 {
5707 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5712 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5708 static PyObject* name = PyString_FromString("dragEnterEvent");
5713 static PyObject* name = PyString_FromString("dragEnterEvent");
5709 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5714 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5710 if (obj) {
5715 if (obj) {
5711 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
5716 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
5712 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5717 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5713 void* args[2] = {NULL, (void*)&arg__1};
5718 void* args[2] = {NULL, (void*)&arg__1};
5714 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5719 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5715 if (result) { Py_DECREF(result); }
5720 if (result) { Py_DECREF(result); }
5716 Py_DECREF(obj);
5721 Py_DECREF(obj);
5717 return;
5722 return;
5718 } else {
5723 } else {
5719 PyErr_Clear();
5724 PyErr_Clear();
5720 }
5725 }
5721 }
5726 }
5722 abstractBinFileWidget::dragEnterEvent(arg__1);
5727 abstractBinFileWidget::dragEnterEvent(arg__1);
5723 }
5728 }
5724 void PythonQtShell_abstractBinFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
5729 void PythonQtShell_abstractBinFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
5725 {
5730 {
5726 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5731 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5727 static PyObject* name = PyString_FromString("dragLeaveEvent");
5732 static PyObject* name = PyString_FromString("dragLeaveEvent");
5728 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5733 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5729 if (obj) {
5734 if (obj) {
5730 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
5735 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
5731 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5736 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5732 void* args[2] = {NULL, (void*)&arg__1};
5737 void* args[2] = {NULL, (void*)&arg__1};
5733 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5738 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5734 if (result) { Py_DECREF(result); }
5739 if (result) { Py_DECREF(result); }
5735 Py_DECREF(obj);
5740 Py_DECREF(obj);
5736 return;
5741 return;
5737 } else {
5742 } else {
5738 PyErr_Clear();
5743 PyErr_Clear();
5739 }
5744 }
5740 }
5745 }
5741 abstractBinFileWidget::dragLeaveEvent(arg__1);
5746 abstractBinFileWidget::dragLeaveEvent(arg__1);
5742 }
5747 }
5743 void PythonQtShell_abstractBinFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
5748 void PythonQtShell_abstractBinFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
5744 {
5749 {
5745 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5750 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5746 static PyObject* name = PyString_FromString("dragMoveEvent");
5751 static PyObject* name = PyString_FromString("dragMoveEvent");
5747 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5752 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5748 if (obj) {
5753 if (obj) {
5749 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
5754 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
5750 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5755 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5751 void* args[2] = {NULL, (void*)&arg__1};
5756 void* args[2] = {NULL, (void*)&arg__1};
5752 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5757 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5753 if (result) { Py_DECREF(result); }
5758 if (result) { Py_DECREF(result); }
5754 Py_DECREF(obj);
5759 Py_DECREF(obj);
5755 return;
5760 return;
5756 } else {
5761 } else {
5757 PyErr_Clear();
5762 PyErr_Clear();
5758 }
5763 }
5759 }
5764 }
5760 abstractBinFileWidget::dragMoveEvent(arg__1);
5765 abstractBinFileWidget::dragMoveEvent(arg__1);
5761 }
5766 }
5762 void PythonQtShell_abstractBinFileWidget::dropEvent(QDropEvent* arg__1)
5767 void PythonQtShell_abstractBinFileWidget::dropEvent(QDropEvent* arg__1)
5763 {
5768 {
5764 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5769 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5765 static PyObject* name = PyString_FromString("dropEvent");
5770 static PyObject* name = PyString_FromString("dropEvent");
5766 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5771 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5767 if (obj) {
5772 if (obj) {
5768 static const char* argumentList[] ={"" , "QDropEvent*"};
5773 static const char* argumentList[] ={"" , "QDropEvent*"};
5769 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5774 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5770 void* args[2] = {NULL, (void*)&arg__1};
5775 void* args[2] = {NULL, (void*)&arg__1};
5771 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5776 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5772 if (result) { Py_DECREF(result); }
5777 if (result) { Py_DECREF(result); }
5773 Py_DECREF(obj);
5778 Py_DECREF(obj);
5774 return;
5779 return;
5775 } else {
5780 } else {
5776 PyErr_Clear();
5781 PyErr_Clear();
5777 }
5782 }
5778 }
5783 }
5779 abstractBinFileWidget::dropEvent(arg__1);
5784 abstractBinFileWidget::dropEvent(arg__1);
5780 }
5785 }
5781 void PythonQtShell_abstractBinFileWidget::enterEvent(QEvent* arg__1)
5786 void PythonQtShell_abstractBinFileWidget::enterEvent(QEvent* arg__1)
5782 {
5787 {
5783 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5788 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5784 static PyObject* name = PyString_FromString("enterEvent");
5789 static PyObject* name = PyString_FromString("enterEvent");
5785 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5790 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5786 if (obj) {
5791 if (obj) {
5787 static const char* argumentList[] ={"" , "QEvent*"};
5792 static const char* argumentList[] ={"" , "QEvent*"};
5788 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5793 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5789 void* args[2] = {NULL, (void*)&arg__1};
5794 void* args[2] = {NULL, (void*)&arg__1};
5790 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5795 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5791 if (result) { Py_DECREF(result); }
5796 if (result) { Py_DECREF(result); }
5792 Py_DECREF(obj);
5797 Py_DECREF(obj);
5793 return;
5798 return;
5794 } else {
5799 } else {
5795 PyErr_Clear();
5800 PyErr_Clear();
5796 }
5801 }
5797 }
5802 }
5798 abstractBinFileWidget::enterEvent(arg__1);
5803 abstractBinFileWidget::enterEvent(arg__1);
5799 }
5804 }
5800 bool PythonQtShell_abstractBinFileWidget::event(QEvent* arg__1)
5805 bool PythonQtShell_abstractBinFileWidget::event(QEvent* arg__1)
5801 {
5806 {
5802 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5807 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5803 static PyObject* name = PyString_FromString("event");
5808 static PyObject* name = PyString_FromString("event");
5804 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5809 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5805 if (obj) {
5810 if (obj) {
5806 static const char* argumentList[] ={"bool" , "QEvent*"};
5811 static const char* argumentList[] ={"bool" , "QEvent*"};
5807 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5812 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5808 bool returnValue;
5813 bool returnValue;
5809 void* args[2] = {NULL, (void*)&arg__1};
5814 void* args[2] = {NULL, (void*)&arg__1};
5810 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5815 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5811 if (result) {
5816 if (result) {
5812 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5817 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5813 if (args[0]!=&returnValue) {
5818 if (args[0]!=&returnValue) {
5814 if (args[0]==NULL) {
5819 if (args[0]==NULL) {
5815 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
5820 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
5816 } else {
5821 } else {
5817 returnValue = *((bool*)args[0]);
5822 returnValue = *((bool*)args[0]);
5818 }
5823 }
5819 }
5824 }
5820 }
5825 }
5821 if (result) { Py_DECREF(result); }
5826 if (result) { Py_DECREF(result); }
5822 Py_DECREF(obj);
5827 Py_DECREF(obj);
5823 return returnValue;
5828 return returnValue;
5824 } else {
5829 } else {
5825 PyErr_Clear();
5830 PyErr_Clear();
5826 }
5831 }
5827 }
5832 }
5828 return abstractBinFileWidget::event(arg__1);
5833 return abstractBinFileWidget::event(arg__1);
5829 }
5834 }
5830 bool PythonQtShell_abstractBinFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
5835 bool PythonQtShell_abstractBinFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
5831 {
5836 {
5832 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5837 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5833 static PyObject* name = PyString_FromString("eventFilter");
5838 static PyObject* name = PyString_FromString("eventFilter");
5834 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5839 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5835 if (obj) {
5840 if (obj) {
5836 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5841 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5837 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5842 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5838 bool returnValue;
5843 bool returnValue;
5839 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
5844 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
5840 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5845 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5841 if (result) {
5846 if (result) {
5842 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5847 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5843 if (args[0]!=&returnValue) {
5848 if (args[0]!=&returnValue) {
5844 if (args[0]==NULL) {
5849 if (args[0]==NULL) {
5845 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
5850 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
5846 } else {
5851 } else {
5847 returnValue = *((bool*)args[0]);
5852 returnValue = *((bool*)args[0]);
5848 }
5853 }
5849 }
5854 }
5850 }
5855 }
5851 if (result) { Py_DECREF(result); }
5856 if (result) { Py_DECREF(result); }
5852 Py_DECREF(obj);
5857 Py_DECREF(obj);
5853 return returnValue;
5858 return returnValue;
5854 } else {
5859 } else {
5855 PyErr_Clear();
5860 PyErr_Clear();
5856 }
5861 }
5857 }
5862 }
5858 return abstractBinFileWidget::eventFilter(arg__1, arg__2);
5863 return abstractBinFileWidget::eventFilter(arg__1, arg__2);
5859 }
5864 }
5860 void PythonQtShell_abstractBinFileWidget::focusInEvent(QFocusEvent* arg__1)
5865 void PythonQtShell_abstractBinFileWidget::focusInEvent(QFocusEvent* arg__1)
5861 {
5866 {
5862 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5867 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5863 static PyObject* name = PyString_FromString("focusInEvent");
5868 static PyObject* name = PyString_FromString("focusInEvent");
5864 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5869 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5865 if (obj) {
5870 if (obj) {
5866 static const char* argumentList[] ={"" , "QFocusEvent*"};
5871 static const char* argumentList[] ={"" , "QFocusEvent*"};
5867 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5872 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5868 void* args[2] = {NULL, (void*)&arg__1};
5873 void* args[2] = {NULL, (void*)&arg__1};
5869 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5874 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5870 if (result) { Py_DECREF(result); }
5875 if (result) { Py_DECREF(result); }
5871 Py_DECREF(obj);
5876 Py_DECREF(obj);
5872 return;
5877 return;
5873 } else {
5878 } else {
5874 PyErr_Clear();
5879 PyErr_Clear();
5875 }
5880 }
5876 }
5881 }
5877 abstractBinFileWidget::focusInEvent(arg__1);
5882 abstractBinFileWidget::focusInEvent(arg__1);
5878 }
5883 }
5879 bool PythonQtShell_abstractBinFileWidget::focusNextPrevChild(bool next0)
5884 bool PythonQtShell_abstractBinFileWidget::focusNextPrevChild(bool next0)
5880 {
5885 {
5881 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5886 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5882 static PyObject* name = PyString_FromString("focusNextPrevChild");
5887 static PyObject* name = PyString_FromString("focusNextPrevChild");
5883 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5888 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5884 if (obj) {
5889 if (obj) {
5885 static const char* argumentList[] ={"bool" , "bool"};
5890 static const char* argumentList[] ={"bool" , "bool"};
5886 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5891 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5887 bool returnValue;
5892 bool returnValue;
5888 void* args[2] = {NULL, (void*)&next0};
5893 void* args[2] = {NULL, (void*)&next0};
5889 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5894 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5890 if (result) {
5895 if (result) {
5891 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5896 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5892 if (args[0]!=&returnValue) {
5897 if (args[0]!=&returnValue) {
5893 if (args[0]==NULL) {
5898 if (args[0]==NULL) {
5894 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
5899 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
5895 } else {
5900 } else {
5896 returnValue = *((bool*)args[0]);
5901 returnValue = *((bool*)args[0]);
5897 }
5902 }
5898 }
5903 }
5899 }
5904 }
5900 if (result) { Py_DECREF(result); }
5905 if (result) { Py_DECREF(result); }
5901 Py_DECREF(obj);
5906 Py_DECREF(obj);
5902 return returnValue;
5907 return returnValue;
5903 } else {
5908 } else {
5904 PyErr_Clear();
5909 PyErr_Clear();
5905 }
5910 }
5906 }
5911 }
5907 return abstractBinFileWidget::focusNextPrevChild(next0);
5912 return abstractBinFileWidget::focusNextPrevChild(next0);
5908 }
5913 }
5909 void PythonQtShell_abstractBinFileWidget::focusOutEvent(QFocusEvent* arg__1)
5914 void PythonQtShell_abstractBinFileWidget::focusOutEvent(QFocusEvent* arg__1)
5910 {
5915 {
5911 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5916 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5912 static PyObject* name = PyString_FromString("focusOutEvent");
5917 static PyObject* name = PyString_FromString("focusOutEvent");
5913 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5918 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5914 if (obj) {
5919 if (obj) {
5915 static const char* argumentList[] ={"" , "QFocusEvent*"};
5920 static const char* argumentList[] ={"" , "QFocusEvent*"};
5916 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5921 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5917 void* args[2] = {NULL, (void*)&arg__1};
5922 void* args[2] = {NULL, (void*)&arg__1};
5918 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5923 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5919 if (result) { Py_DECREF(result); }
5924 if (result) { Py_DECREF(result); }
5920 Py_DECREF(obj);
5925 Py_DECREF(obj);
5921 return;
5926 return;
5922 } else {
5927 } else {
5923 PyErr_Clear();
5928 PyErr_Clear();
5924 }
5929 }
5925 }
5930 }
5926 abstractBinFileWidget::focusOutEvent(arg__1);
5931 abstractBinFileWidget::focusOutEvent(arg__1);
5927 }
5932 }
5928 bool PythonQtShell_abstractBinFileWidget::hasHeightForWidth() const
5933 bool PythonQtShell_abstractBinFileWidget::hasHeightForWidth() const
5929 {
5934 {
5930 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5935 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5931 static PyObject* name = PyString_FromString("hasHeightForWidth");
5936 static PyObject* name = PyString_FromString("hasHeightForWidth");
5932 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5937 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5933 if (obj) {
5938 if (obj) {
5934 static const char* argumentList[] ={"bool"};
5939 static const char* argumentList[] ={"bool"};
5935 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5940 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5936 bool returnValue;
5941 bool returnValue;
5937 void* args[1] = {NULL};
5942 void* args[1] = {NULL};
5938 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5943 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5939 if (result) {
5944 if (result) {
5940 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5945 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5941 if (args[0]!=&returnValue) {
5946 if (args[0]!=&returnValue) {
5942 if (args[0]==NULL) {
5947 if (args[0]==NULL) {
5943 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
5948 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
5944 } else {
5949 } else {
5945 returnValue = *((bool*)args[0]);
5950 returnValue = *((bool*)args[0]);
5946 }
5951 }
5947 }
5952 }
5948 }
5953 }
5949 if (result) { Py_DECREF(result); }
5954 if (result) { Py_DECREF(result); }
5950 Py_DECREF(obj);
5955 Py_DECREF(obj);
5951 return returnValue;
5956 return returnValue;
5952 } else {
5957 } else {
5953 PyErr_Clear();
5958 PyErr_Clear();
5954 }
5959 }
5955 }
5960 }
5956 return abstractBinFileWidget::hasHeightForWidth();
5961 return abstractBinFileWidget::hasHeightForWidth();
5957 }
5962 }
5958 int PythonQtShell_abstractBinFileWidget::heightForWidth(int arg__1) const
5963 int PythonQtShell_abstractBinFileWidget::heightForWidth(int arg__1) const
5959 {
5964 {
5960 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5965 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5961 static PyObject* name = PyString_FromString("heightForWidth");
5966 static PyObject* name = PyString_FromString("heightForWidth");
5962 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5967 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5963 if (obj) {
5968 if (obj) {
5964 static const char* argumentList[] ={"int" , "int"};
5969 static const char* argumentList[] ={"int" , "int"};
5965 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5970 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5966 int returnValue;
5971 int returnValue;
5967 void* args[2] = {NULL, (void*)&arg__1};
5972 void* args[2] = {NULL, (void*)&arg__1};
5968 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5973 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5969 if (result) {
5974 if (result) {
5970 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5975 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5971 if (args[0]!=&returnValue) {
5976 if (args[0]!=&returnValue) {
5972 if (args[0]==NULL) {
5977 if (args[0]==NULL) {
5973 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
5978 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
5974 } else {
5979 } else {
5975 returnValue = *((int*)args[0]);
5980 returnValue = *((int*)args[0]);
5976 }
5981 }
5977 }
5982 }
5978 }
5983 }
5979 if (result) { Py_DECREF(result); }
5984 if (result) { Py_DECREF(result); }
5980 Py_DECREF(obj);
5985 Py_DECREF(obj);
5981 return returnValue;
5986 return returnValue;
5982 } else {
5987 } else {
5983 PyErr_Clear();
5988 PyErr_Clear();
5984 }
5989 }
5985 }
5990 }
5986 return abstractBinFileWidget::heightForWidth(arg__1);
5991 return abstractBinFileWidget::heightForWidth(arg__1);
5987 }
5992 }
5988 void PythonQtShell_abstractBinFileWidget::hideEvent(QHideEvent* arg__1)
5993 void PythonQtShell_abstractBinFileWidget::hideEvent(QHideEvent* arg__1)
5989 {
5994 {
5990 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5995 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
5991 static PyObject* name = PyString_FromString("hideEvent");
5996 static PyObject* name = PyString_FromString("hideEvent");
5992 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5997 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
5993 if (obj) {
5998 if (obj) {
5994 static const char* argumentList[] ={"" , "QHideEvent*"};
5999 static const char* argumentList[] ={"" , "QHideEvent*"};
5995 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6000 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5996 void* args[2] = {NULL, (void*)&arg__1};
6001 void* args[2] = {NULL, (void*)&arg__1};
5997 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6002 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5998 if (result) { Py_DECREF(result); }
6003 if (result) { Py_DECREF(result); }
5999 Py_DECREF(obj);
6004 Py_DECREF(obj);
6000 return;
6005 return;
6001 } else {
6006 } else {
6002 PyErr_Clear();
6007 PyErr_Clear();
6003 }
6008 }
6004 }
6009 }
6005 abstractBinFileWidget::hideEvent(arg__1);
6010 abstractBinFileWidget::hideEvent(arg__1);
6006 }
6011 }
6007 void PythonQtShell_abstractBinFileWidget::initPainter(QPainter* painter0) const
6012 void PythonQtShell_abstractBinFileWidget::initPainter(QPainter* painter0) const
6008 {
6013 {
6009 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6014 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6010 static PyObject* name = PyString_FromString("initPainter");
6015 static PyObject* name = PyString_FromString("initPainter");
6011 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6016 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6012 if (obj) {
6017 if (obj) {
6013 static const char* argumentList[] ={"" , "QPainter*"};
6018 static const char* argumentList[] ={"" , "QPainter*"};
6014 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6019 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6015 void* args[2] = {NULL, (void*)&painter0};
6020 void* args[2] = {NULL, (void*)&painter0};
6016 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6021 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6017 if (result) { Py_DECREF(result); }
6022 if (result) { Py_DECREF(result); }
6018 Py_DECREF(obj);
6023 Py_DECREF(obj);
6019 return;
6024 return;
6020 } else {
6025 } else {
6021 PyErr_Clear();
6026 PyErr_Clear();
6022 }
6027 }
6023 }
6028 }
6024 abstractBinFileWidget::initPainter(painter0);
6029 abstractBinFileWidget::initPainter(painter0);
6025 }
6030 }
6026 void PythonQtShell_abstractBinFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
6031 void PythonQtShell_abstractBinFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
6027 {
6032 {
6028 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6033 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6029 static PyObject* name = PyString_FromString("inputMethodEvent");
6034 static PyObject* name = PyString_FromString("inputMethodEvent");
6030 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6035 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6031 if (obj) {
6036 if (obj) {
6032 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
6037 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
6033 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6038 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6034 void* args[2] = {NULL, (void*)&arg__1};
6039 void* args[2] = {NULL, (void*)&arg__1};
6035 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6040 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6036 if (result) { Py_DECREF(result); }
6041 if (result) { Py_DECREF(result); }
6037 Py_DECREF(obj);
6042 Py_DECREF(obj);
6038 return;
6043 return;
6039 } else {
6044 } else {
6040 PyErr_Clear();
6045 PyErr_Clear();
6041 }
6046 }
6042 }
6047 }
6043 abstractBinFileWidget::inputMethodEvent(arg__1);
6048 abstractBinFileWidget::inputMethodEvent(arg__1);
6044 }
6049 }
6045 QVariant PythonQtShell_abstractBinFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
6050 QVariant PythonQtShell_abstractBinFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
6046 {
6051 {
6047 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6052 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6048 static PyObject* name = PyString_FromString("inputMethodQuery");
6053 static PyObject* name = PyString_FromString("inputMethodQuery");
6049 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6054 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6050 if (obj) {
6055 if (obj) {
6051 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
6056 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
6052 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6057 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6053 QVariant returnValue;
6058 QVariant returnValue;
6054 void* args[2] = {NULL, (void*)&arg__1};
6059 void* args[2] = {NULL, (void*)&arg__1};
6055 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6060 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6056 if (result) {
6061 if (result) {
6057 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6062 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6058 if (args[0]!=&returnValue) {
6063 if (args[0]!=&returnValue) {
6059 if (args[0]==NULL) {
6064 if (args[0]==NULL) {
6060 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
6065 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
6061 } else {
6066 } else {
6062 returnValue = *((QVariant*)args[0]);
6067 returnValue = *((QVariant*)args[0]);
6063 }
6068 }
6064 }
6069 }
6065 }
6070 }
6066 if (result) { Py_DECREF(result); }
6071 if (result) { Py_DECREF(result); }
6067 Py_DECREF(obj);
6072 Py_DECREF(obj);
6068 return returnValue;
6073 return returnValue;
6069 } else {
6074 } else {
6070 PyErr_Clear();
6075 PyErr_Clear();
6071 }
6076 }
6072 }
6077 }
6073 return abstractBinFileWidget::inputMethodQuery(arg__1);
6078 return abstractBinFileWidget::inputMethodQuery(arg__1);
6074 }
6079 }
6075 void PythonQtShell_abstractBinFileWidget::keyPressEvent(QKeyEvent* arg__1)
6080 void PythonQtShell_abstractBinFileWidget::keyPressEvent(QKeyEvent* arg__1)
6076 {
6081 {
6077 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6082 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6078 static PyObject* name = PyString_FromString("keyPressEvent");
6083 static PyObject* name = PyString_FromString("keyPressEvent");
6079 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6084 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6080 if (obj) {
6085 if (obj) {
6081 static const char* argumentList[] ={"" , "QKeyEvent*"};
6086 static const char* argumentList[] ={"" , "QKeyEvent*"};
6082 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6087 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6083 void* args[2] = {NULL, (void*)&arg__1};
6088 void* args[2] = {NULL, (void*)&arg__1};
6084 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6089 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6085 if (result) { Py_DECREF(result); }
6090 if (result) { Py_DECREF(result); }
6086 Py_DECREF(obj);
6091 Py_DECREF(obj);
6087 return;
6092 return;
6088 } else {
6093 } else {
6089 PyErr_Clear();
6094 PyErr_Clear();
6090 }
6095 }
6091 }
6096 }
6092 abstractBinFileWidget::keyPressEvent(arg__1);
6097 abstractBinFileWidget::keyPressEvent(arg__1);
6093 }
6098 }
6094 void PythonQtShell_abstractBinFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
6099 void PythonQtShell_abstractBinFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
6095 {
6100 {
6096 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6101 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6097 static PyObject* name = PyString_FromString("keyReleaseEvent");
6102 static PyObject* name = PyString_FromString("keyReleaseEvent");
6098 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6103 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6099 if (obj) {
6104 if (obj) {
6100 static const char* argumentList[] ={"" , "QKeyEvent*"};
6105 static const char* argumentList[] ={"" , "QKeyEvent*"};
6101 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6106 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6102 void* args[2] = {NULL, (void*)&arg__1};
6107 void* args[2] = {NULL, (void*)&arg__1};
6103 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6108 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6104 if (result) { Py_DECREF(result); }
6109 if (result) { Py_DECREF(result); }
6105 Py_DECREF(obj);
6110 Py_DECREF(obj);
6106 return;
6111 return;
6107 } else {
6112 } else {
6108 PyErr_Clear();
6113 PyErr_Clear();
6109 }
6114 }
6110 }
6115 }
6111 abstractBinFileWidget::keyReleaseEvent(arg__1);
6116 abstractBinFileWidget::keyReleaseEvent(arg__1);
6112 }
6117 }
6113 void PythonQtShell_abstractBinFileWidget::leaveEvent(QEvent* arg__1)
6118 void PythonQtShell_abstractBinFileWidget::leaveEvent(QEvent* arg__1)
6114 {
6119 {
6115 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6120 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6116 static PyObject* name = PyString_FromString("leaveEvent");
6121 static PyObject* name = PyString_FromString("leaveEvent");
6117 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6122 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6118 if (obj) {
6123 if (obj) {
6119 static const char* argumentList[] ={"" , "QEvent*"};
6124 static const char* argumentList[] ={"" , "QEvent*"};
6120 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6125 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6121 void* args[2] = {NULL, (void*)&arg__1};
6126 void* args[2] = {NULL, (void*)&arg__1};
6122 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6127 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6123 if (result) { Py_DECREF(result); }
6128 if (result) { Py_DECREF(result); }
6124 Py_DECREF(obj);
6129 Py_DECREF(obj);
6125 return;
6130 return;
6126 } else {
6131 } else {
6127 PyErr_Clear();
6132 PyErr_Clear();
6128 }
6133 }
6129 }
6134 }
6130 abstractBinFileWidget::leaveEvent(arg__1);
6135 abstractBinFileWidget::leaveEvent(arg__1);
6131 }
6136 }
6132 int PythonQtShell_abstractBinFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
6137 int PythonQtShell_abstractBinFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
6133 {
6138 {
6134 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6139 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6135 static PyObject* name = PyString_FromString("metric");
6140 static PyObject* name = PyString_FromString("metric");
6136 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6141 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6137 if (obj) {
6142 if (obj) {
6138 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
6143 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
6139 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6144 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6140 int returnValue;
6145 int returnValue;
6141 void* args[2] = {NULL, (void*)&arg__1};
6146 void* args[2] = {NULL, (void*)&arg__1};
6142 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6147 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6143 if (result) {
6148 if (result) {
6144 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6149 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6145 if (args[0]!=&returnValue) {
6150 if (args[0]!=&returnValue) {
6146 if (args[0]==NULL) {
6151 if (args[0]==NULL) {
6147 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
6152 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
6148 } else {
6153 } else {
6149 returnValue = *((int*)args[0]);
6154 returnValue = *((int*)args[0]);
6150 }
6155 }
6151 }
6156 }
6152 }
6157 }
6153 if (result) { Py_DECREF(result); }
6158 if (result) { Py_DECREF(result); }
6154 Py_DECREF(obj);
6159 Py_DECREF(obj);
6155 return returnValue;
6160 return returnValue;
6156 } else {
6161 } else {
6157 PyErr_Clear();
6162 PyErr_Clear();
6158 }
6163 }
6159 }
6164 }
6160 return abstractBinFileWidget::metric(arg__1);
6165 return abstractBinFileWidget::metric(arg__1);
6161 }
6166 }
6162 QSize PythonQtShell_abstractBinFileWidget::minimumSizeHint() const
6167 QSize PythonQtShell_abstractBinFileWidget::minimumSizeHint() const
6163 {
6168 {
6164 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6169 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6165 static PyObject* name = PyString_FromString("getMinimumSizeHint");
6170 static PyObject* name = PyString_FromString("getMinimumSizeHint");
6166 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6171 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6167 if (obj) {
6172 if (obj) {
6168 static const char* argumentList[] ={"QSize"};
6173 static const char* argumentList[] ={"QSize"};
6169 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6174 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6170 QSize returnValue;
6175 QSize returnValue;
6171 void* args[1] = {NULL};
6176 void* args[1] = {NULL};
6172 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6177 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6173 if (result) {
6178 if (result) {
6174 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6179 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6175 if (args[0]!=&returnValue) {
6180 if (args[0]!=&returnValue) {
6176 if (args[0]==NULL) {
6181 if (args[0]==NULL) {
6177 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
6182 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
6178 } else {
6183 } else {
6179 returnValue = *((QSize*)args[0]);
6184 returnValue = *((QSize*)args[0]);
6180 }
6185 }
6181 }
6186 }
6182 }
6187 }
6183 if (result) { Py_DECREF(result); }
6188 if (result) { Py_DECREF(result); }
6184 Py_DECREF(obj);
6189 Py_DECREF(obj);
6185 return returnValue;
6190 return returnValue;
6186 } else {
6191 } else {
6187 PyErr_Clear();
6192 PyErr_Clear();
6188 }
6193 }
6189 }
6194 }
6190 return abstractBinFileWidget::minimumSizeHint();
6195 return abstractBinFileWidget::minimumSizeHint();
6191 }
6196 }
6192 void PythonQtShell_abstractBinFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
6197 void PythonQtShell_abstractBinFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
6193 {
6198 {
6194 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6199 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6195 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
6200 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
6196 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6201 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6197 if (obj) {
6202 if (obj) {
6198 static const char* argumentList[] ={"" , "QMouseEvent*"};
6203 static const char* argumentList[] ={"" , "QMouseEvent*"};
6199 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6204 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6200 void* args[2] = {NULL, (void*)&arg__1};
6205 void* args[2] = {NULL, (void*)&arg__1};
6201 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6206 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6202 if (result) { Py_DECREF(result); }
6207 if (result) { Py_DECREF(result); }
6203 Py_DECREF(obj);
6208 Py_DECREF(obj);
6204 return;
6209 return;
6205 } else {
6210 } else {
6206 PyErr_Clear();
6211 PyErr_Clear();
6207 }
6212 }
6208 }
6213 }
6209 abstractBinFileWidget::mouseDoubleClickEvent(arg__1);
6214 abstractBinFileWidget::mouseDoubleClickEvent(arg__1);
6210 }
6215 }
6211 void PythonQtShell_abstractBinFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
6216 void PythonQtShell_abstractBinFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
6212 {
6217 {
6213 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6218 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6214 static PyObject* name = PyString_FromString("mouseMoveEvent");
6219 static PyObject* name = PyString_FromString("mouseMoveEvent");
6215 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6220 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6216 if (obj) {
6221 if (obj) {
6217 static const char* argumentList[] ={"" , "QMouseEvent*"};
6222 static const char* argumentList[] ={"" , "QMouseEvent*"};
6218 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6223 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6219 void* args[2] = {NULL, (void*)&arg__1};
6224 void* args[2] = {NULL, (void*)&arg__1};
6220 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6225 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6221 if (result) { Py_DECREF(result); }
6226 if (result) { Py_DECREF(result); }
6222 Py_DECREF(obj);
6227 Py_DECREF(obj);
6223 return;
6228 return;
6224 } else {
6229 } else {
6225 PyErr_Clear();
6230 PyErr_Clear();
6226 }
6231 }
6227 }
6232 }
6228 abstractBinFileWidget::mouseMoveEvent(arg__1);
6233 abstractBinFileWidget::mouseMoveEvent(arg__1);
6229 }
6234 }
6230 void PythonQtShell_abstractBinFileWidget::mousePressEvent(QMouseEvent* arg__1)
6235 void PythonQtShell_abstractBinFileWidget::mousePressEvent(QMouseEvent* arg__1)
6231 {
6236 {
6232 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6237 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6233 static PyObject* name = PyString_FromString("mousePressEvent");
6238 static PyObject* name = PyString_FromString("mousePressEvent");
6234 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6239 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6235 if (obj) {
6240 if (obj) {
6236 static const char* argumentList[] ={"" , "QMouseEvent*"};
6241 static const char* argumentList[] ={"" , "QMouseEvent*"};
6237 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6242 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6238 void* args[2] = {NULL, (void*)&arg__1};
6243 void* args[2] = {NULL, (void*)&arg__1};
6239 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6244 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6240 if (result) { Py_DECREF(result); }
6245 if (result) { Py_DECREF(result); }
6241 Py_DECREF(obj);
6246 Py_DECREF(obj);
6242 return;
6247 return;
6243 } else {
6248 } else {
6244 PyErr_Clear();
6249 PyErr_Clear();
6245 }
6250 }
6246 }
6251 }
6247 abstractBinFileWidget::mousePressEvent(arg__1);
6252 abstractBinFileWidget::mousePressEvent(arg__1);
6248 }
6253 }
6249 void PythonQtShell_abstractBinFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
6254 void PythonQtShell_abstractBinFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
6250 {
6255 {
6251 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6256 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6252 static PyObject* name = PyString_FromString("mouseReleaseEvent");
6257 static PyObject* name = PyString_FromString("mouseReleaseEvent");
6253 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6258 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6254 if (obj) {
6259 if (obj) {
6255 static const char* argumentList[] ={"" , "QMouseEvent*"};
6260 static const char* argumentList[] ={"" , "QMouseEvent*"};
6256 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6261 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6257 void* args[2] = {NULL, (void*)&arg__1};
6262 void* args[2] = {NULL, (void*)&arg__1};
6258 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6263 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6259 if (result) { Py_DECREF(result); }
6264 if (result) { Py_DECREF(result); }
6260 Py_DECREF(obj);
6265 Py_DECREF(obj);
6261 return;
6266 return;
6262 } else {
6267 } else {
6263 PyErr_Clear();
6268 PyErr_Clear();
6264 }
6269 }
6265 }
6270 }
6266 abstractBinFileWidget::mouseReleaseEvent(arg__1);
6271 abstractBinFileWidget::mouseReleaseEvent(arg__1);
6267 }
6272 }
6268 void PythonQtShell_abstractBinFileWidget::moveEvent(QMoveEvent* arg__1)
6273 void PythonQtShell_abstractBinFileWidget::moveEvent(QMoveEvent* arg__1)
6269 {
6274 {
6270 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6275 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6271 static PyObject* name = PyString_FromString("moveEvent");
6276 static PyObject* name = PyString_FromString("moveEvent");
6272 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6277 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6273 if (obj) {
6278 if (obj) {
6274 static const char* argumentList[] ={"" , "QMoveEvent*"};
6279 static const char* argumentList[] ={"" , "QMoveEvent*"};
6275 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6280 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6276 void* args[2] = {NULL, (void*)&arg__1};
6281 void* args[2] = {NULL, (void*)&arg__1};
6277 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6282 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6278 if (result) { Py_DECREF(result); }
6283 if (result) { Py_DECREF(result); }
6279 Py_DECREF(obj);
6284 Py_DECREF(obj);
6280 return;
6285 return;
6281 } else {
6286 } else {
6282 PyErr_Clear();
6287 PyErr_Clear();
6283 }
6288 }
6284 }
6289 }
6285 abstractBinFileWidget::moveEvent(arg__1);
6290 abstractBinFileWidget::moveEvent(arg__1);
6286 }
6291 }
6287 bool PythonQtShell_abstractBinFileWidget::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
6292 bool PythonQtShell_abstractBinFileWidget::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
6288 {
6293 {
6289 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6294 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6290 static PyObject* name = PyString_FromString("nativeEvent");
6295 static PyObject* name = PyString_FromString("nativeEvent");
6291 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6296 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6292 if (obj) {
6297 if (obj) {
6293 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
6298 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
6294 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
6299 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
6295 bool returnValue;
6300 bool returnValue;
6296 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
6301 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
6297 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6302 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6298 if (result) {
6303 if (result) {
6299 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6304 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6300 if (args[0]!=&returnValue) {
6305 if (args[0]!=&returnValue) {
6301 if (args[0]==NULL) {
6306 if (args[0]==NULL) {
6302 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
6307 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
6303 } else {
6308 } else {
6304 returnValue = *((bool*)args[0]);
6309 returnValue = *((bool*)args[0]);
6305 }
6310 }
6306 }
6311 }
6307 }
6312 }
6308 if (result) { Py_DECREF(result); }
6313 if (result) { Py_DECREF(result); }
6309 Py_DECREF(obj);
6314 Py_DECREF(obj);
6310 return returnValue;
6315 return returnValue;
6311 } else {
6316 } else {
6312 PyErr_Clear();
6317 PyErr_Clear();
6313 }
6318 }
6314 }
6319 }
6315 return abstractBinFileWidget::nativeEvent(eventType0, message1, result2);
6320 return abstractBinFileWidget::nativeEvent(eventType0, message1, result2);
6316 }
6321 }
6317 QPaintEngine* PythonQtShell_abstractBinFileWidget::paintEngine() const
6322 QPaintEngine* PythonQtShell_abstractBinFileWidget::paintEngine() const
6318 {
6323 {
6319 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6324 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6320 static PyObject* name = PyString_FromString("paintEngine");
6325 static PyObject* name = PyString_FromString("paintEngine");
6321 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6326 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6322 if (obj) {
6327 if (obj) {
6323 static const char* argumentList[] ={"QPaintEngine*"};
6328 static const char* argumentList[] ={"QPaintEngine*"};
6324 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6329 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6325 QPaintEngine* returnValue;
6330 QPaintEngine* returnValue;
6326 void* args[1] = {NULL};
6331 void* args[1] = {NULL};
6327 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6332 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6328 if (result) {
6333 if (result) {
6329 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6334 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6330 if (args[0]!=&returnValue) {
6335 if (args[0]!=&returnValue) {
6331 if (args[0]==NULL) {
6336 if (args[0]==NULL) {
6332 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
6337 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
6333 } else {
6338 } else {
6334 returnValue = *((QPaintEngine**)args[0]);
6339 returnValue = *((QPaintEngine**)args[0]);
6335 }
6340 }
6336 }
6341 }
6337 }
6342 }
6338 if (result) { Py_DECREF(result); }
6343 if (result) { Py_DECREF(result); }
6339 Py_DECREF(obj);
6344 Py_DECREF(obj);
6340 return returnValue;
6345 return returnValue;
6341 } else {
6346 } else {
6342 PyErr_Clear();
6347 PyErr_Clear();
6343 }
6348 }
6344 }
6349 }
6345 return abstractBinFileWidget::paintEngine();
6350 return abstractBinFileWidget::paintEngine();
6346 }
6351 }
6347 void PythonQtShell_abstractBinFileWidget::paintEvent(QPaintEvent* arg__1)
6352 void PythonQtShell_abstractBinFileWidget::paintEvent(QPaintEvent* arg__1)
6348 {
6353 {
6349 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6354 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6350 static PyObject* name = PyString_FromString("paintEvent");
6355 static PyObject* name = PyString_FromString("paintEvent");
6351 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6356 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6352 if (obj) {
6357 if (obj) {
6353 static const char* argumentList[] ={"" , "QPaintEvent*"};
6358 static const char* argumentList[] ={"" , "QPaintEvent*"};
6354 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6359 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6355 void* args[2] = {NULL, (void*)&arg__1};
6360 void* args[2] = {NULL, (void*)&arg__1};
6356 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6361 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6357 if (result) { Py_DECREF(result); }
6362 if (result) { Py_DECREF(result); }
6358 Py_DECREF(obj);
6363 Py_DECREF(obj);
6359 return;
6364 return;
6360 } else {
6365 } else {
6361 PyErr_Clear();
6366 PyErr_Clear();
6362 }
6367 }
6363 }
6368 }
6364 abstractBinFileWidget::paintEvent(arg__1);
6369 abstractBinFileWidget::paintEvent(arg__1);
6365 }
6370 }
6366 QPaintDevice* PythonQtShell_abstractBinFileWidget::redirected(QPoint* offset0) const
6371 QPaintDevice* PythonQtShell_abstractBinFileWidget::redirected(QPoint* offset0) const
6367 {
6372 {
6368 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6373 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6369 static PyObject* name = PyString_FromString("redirected");
6374 static PyObject* name = PyString_FromString("redirected");
6370 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6375 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6371 if (obj) {
6376 if (obj) {
6372 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
6377 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
6373 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6378 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6374 QPaintDevice* returnValue;
6379 QPaintDevice* returnValue;
6375 void* args[2] = {NULL, (void*)&offset0};
6380 void* args[2] = {NULL, (void*)&offset0};
6376 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6381 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6377 if (result) {
6382 if (result) {
6378 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6383 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6379 if (args[0]!=&returnValue) {
6384 if (args[0]!=&returnValue) {
6380 if (args[0]==NULL) {
6385 if (args[0]==NULL) {
6381 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
6386 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
6382 } else {
6387 } else {
6383 returnValue = *((QPaintDevice**)args[0]);
6388 returnValue = *((QPaintDevice**)args[0]);
6384 }
6389 }
6385 }
6390 }
6386 }
6391 }
6387 if (result) { Py_DECREF(result); }
6392 if (result) { Py_DECREF(result); }
6388 Py_DECREF(obj);
6393 Py_DECREF(obj);
6389 return returnValue;
6394 return returnValue;
6390 } else {
6395 } else {
6391 PyErr_Clear();
6396 PyErr_Clear();
6392 }
6397 }
6393 }
6398 }
6394 return abstractBinFileWidget::redirected(offset0);
6399 return abstractBinFileWidget::redirected(offset0);
6395 }
6400 }
6396 void PythonQtShell_abstractBinFileWidget::reloadFile()
6401 void PythonQtShell_abstractBinFileWidget::reloadFile()
6397 {
6402 {
6398 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6403 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6399 static PyObject* name = PyString_FromString("reloadFile");
6404 static PyObject* name = PyString_FromString("reloadFile");
6400 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6405 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6401 if (obj) {
6406 if (obj) {
6402 static const char* argumentList[] ={""};
6407 static const char* argumentList[] ={""};
6403 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6408 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6404 void* args[1] = {NULL};
6409 void* args[1] = {NULL};
6405 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6410 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6406 if (result) { Py_DECREF(result); }
6411 if (result) { Py_DECREF(result); }
6407 Py_DECREF(obj);
6412 Py_DECREF(obj);
6408 return;
6413 return;
6409 } else {
6414 } else {
6410 PyErr_Clear();
6415 PyErr_Clear();
6411 }
6416 }
6412 }
6417 }
6413
6418
6414 }
6419 }
6415 void PythonQtShell_abstractBinFileWidget::resizeEvent(QResizeEvent* arg__1)
6420 void PythonQtShell_abstractBinFileWidget::resizeEvent(QResizeEvent* arg__1)
6416 {
6421 {
6417 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6422 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6418 static PyObject* name = PyString_FromString("resizeEvent");
6423 static PyObject* name = PyString_FromString("resizeEvent");
6419 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6424 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6420 if (obj) {
6425 if (obj) {
6421 static const char* argumentList[] ={"" , "QResizeEvent*"};
6426 static const char* argumentList[] ={"" , "QResizeEvent*"};
6422 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6427 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6423 void* args[2] = {NULL, (void*)&arg__1};
6428 void* args[2] = {NULL, (void*)&arg__1};
6424 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6429 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6425 if (result) { Py_DECREF(result); }
6430 if (result) { Py_DECREF(result); }
6426 Py_DECREF(obj);
6431 Py_DECREF(obj);
6427 return;
6432 return;
6428 } else {
6433 } else {
6429 PyErr_Clear();
6434 PyErr_Clear();
6430 }
6435 }
6431 }
6436 }
6432 abstractBinFileWidget::resizeEvent(arg__1);
6437 abstractBinFileWidget::resizeEvent(arg__1);
6433 }
6438 }
6434 void PythonQtShell_abstractBinFileWidget::setFile(abstractBinFile* file0)
6439 void PythonQtShell_abstractBinFileWidget::setFile(abstractBinFile* file0)
6435 {
6440 {
6436 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6441 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6437 static PyObject* name = PyString_FromString("setFile");
6442 static PyObject* name = PyString_FromString("setFile");
6438 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6443 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6439 if (obj) {
6444 if (obj) {
6440 static const char* argumentList[] ={"" , "abstractBinFile*"};
6445 static const char* argumentList[] ={"" , "abstractBinFile*"};
6441 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6446 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6442 void* args[2] = {NULL, (void*)&file0};
6447 void* args[2] = {NULL, (void*)&file0};
6443 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6448 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6444 if (result) { Py_DECREF(result); }
6449 if (result) { Py_DECREF(result); }
6445 Py_DECREF(obj);
6450 Py_DECREF(obj);
6446 return;
6451 return;
6447 } else {
6452 } else {
6448 PyErr_Clear();
6453 PyErr_Clear();
6449 }
6454 }
6450 }
6455 }
6451
6456
6452 }
6457 }
6453 QPainter* PythonQtShell_abstractBinFileWidget::sharedPainter() const
6458 QPainter* PythonQtShell_abstractBinFileWidget::sharedPainter() const
6454 {
6459 {
6455 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6460 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6456 static PyObject* name = PyString_FromString("sharedPainter");
6461 static PyObject* name = PyString_FromString("sharedPainter");
6457 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6462 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6458 if (obj) {
6463 if (obj) {
6459 static const char* argumentList[] ={"QPainter*"};
6464 static const char* argumentList[] ={"QPainter*"};
6460 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6465 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6461 QPainter* returnValue;
6466 QPainter* returnValue;
6462 void* args[1] = {NULL};
6467 void* args[1] = {NULL};
6463 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6468 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6464 if (result) {
6469 if (result) {
6465 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6470 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6466 if (args[0]!=&returnValue) {
6471 if (args[0]!=&returnValue) {
6467 if (args[0]==NULL) {
6472 if (args[0]==NULL) {
6468 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
6473 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
6469 } else {
6474 } else {
6470 returnValue = *((QPainter**)args[0]);
6475 returnValue = *((QPainter**)args[0]);
6471 }
6476 }
6472 }
6477 }
6473 }
6478 }
6474 if (result) { Py_DECREF(result); }
6479 if (result) { Py_DECREF(result); }
6475 Py_DECREF(obj);
6480 Py_DECREF(obj);
6476 return returnValue;
6481 return returnValue;
6477 } else {
6482 } else {
6478 PyErr_Clear();
6483 PyErr_Clear();
6479 }
6484 }
6480 }
6485 }
6481 return abstractBinFileWidget::sharedPainter();
6486 return abstractBinFileWidget::sharedPainter();
6482 }
6487 }
6483 void PythonQtShell_abstractBinFileWidget::showEvent(QShowEvent* arg__1)
6488 void PythonQtShell_abstractBinFileWidget::showEvent(QShowEvent* arg__1)
6484 {
6489 {
6485 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6490 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6486 static PyObject* name = PyString_FromString("showEvent");
6491 static PyObject* name = PyString_FromString("showEvent");
6487 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6492 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6488 if (obj) {
6493 if (obj) {
6489 static const char* argumentList[] ={"" , "QShowEvent*"};
6494 static const char* argumentList[] ={"" , "QShowEvent*"};
6490 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6495 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6491 void* args[2] = {NULL, (void*)&arg__1};
6496 void* args[2] = {NULL, (void*)&arg__1};
6492 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6497 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6493 if (result) { Py_DECREF(result); }
6498 if (result) { Py_DECREF(result); }
6494 Py_DECREF(obj);
6499 Py_DECREF(obj);
6495 return;
6500 return;
6496 } else {
6501 } else {
6497 PyErr_Clear();
6502 PyErr_Clear();
6498 }
6503 }
6499 }
6504 }
6500 abstractBinFileWidget::showEvent(arg__1);
6505 abstractBinFileWidget::showEvent(arg__1);
6501 }
6506 }
6502 QSize PythonQtShell_abstractBinFileWidget::sizeHint() const
6507 QSize PythonQtShell_abstractBinFileWidget::sizeHint() const
6503 {
6508 {
6504 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6509 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6505 static PyObject* name = PyString_FromString("getSizeHint");
6510 static PyObject* name = PyString_FromString("getSizeHint");
6506 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6511 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6507 if (obj) {
6512 if (obj) {
6508 static const char* argumentList[] ={"QSize"};
6513 static const char* argumentList[] ={"QSize"};
6509 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6514 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6510 QSize returnValue;
6515 QSize returnValue;
6511 void* args[1] = {NULL};
6516 void* args[1] = {NULL};
6512 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6517 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6513 if (result) {
6518 if (result) {
6514 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6519 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6515 if (args[0]!=&returnValue) {
6520 if (args[0]!=&returnValue) {
6516 if (args[0]==NULL) {
6521 if (args[0]==NULL) {
6517 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
6522 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
6518 } else {
6523 } else {
6519 returnValue = *((QSize*)args[0]);
6524 returnValue = *((QSize*)args[0]);
6520 }
6525 }
6521 }
6526 }
6522 }
6527 }
6523 if (result) { Py_DECREF(result); }
6528 if (result) { Py_DECREF(result); }
6524 Py_DECREF(obj);
6529 Py_DECREF(obj);
6525 return returnValue;
6530 return returnValue;
6526 } else {
6531 } else {
6527 PyErr_Clear();
6532 PyErr_Clear();
6528 }
6533 }
6529 }
6534 }
6530 return abstractBinFileWidget::sizeHint();
6535 return abstractBinFileWidget::sizeHint();
6531 }
6536 }
6532 void PythonQtShell_abstractBinFileWidget::tabletEvent(QTabletEvent* arg__1)
6537 void PythonQtShell_abstractBinFileWidget::tabletEvent(QTabletEvent* arg__1)
6533 {
6538 {
6534 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6539 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6535 static PyObject* name = PyString_FromString("tabletEvent");
6540 static PyObject* name = PyString_FromString("tabletEvent");
6536 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6541 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6537 if (obj) {
6542 if (obj) {
6538 static const char* argumentList[] ={"" , "QTabletEvent*"};
6543 static const char* argumentList[] ={"" , "QTabletEvent*"};
6539 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6544 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6540 void* args[2] = {NULL, (void*)&arg__1};
6545 void* args[2] = {NULL, (void*)&arg__1};
6541 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6546 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6542 if (result) { Py_DECREF(result); }
6547 if (result) { Py_DECREF(result); }
6543 Py_DECREF(obj);
6548 Py_DECREF(obj);
6544 return;
6549 return;
6545 } else {
6550 } else {
6546 PyErr_Clear();
6551 PyErr_Clear();
6547 }
6552 }
6548 }
6553 }
6549 abstractBinFileWidget::tabletEvent(arg__1);
6554 abstractBinFileWidget::tabletEvent(arg__1);
6550 }
6555 }
6551 void PythonQtShell_abstractBinFileWidget::timerEvent(QTimerEvent* arg__1)
6556 void PythonQtShell_abstractBinFileWidget::timerEvent(QTimerEvent* arg__1)
6552 {
6557 {
6553 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6558 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6554 static PyObject* name = PyString_FromString("timerEvent");
6559 static PyObject* name = PyString_FromString("timerEvent");
6555 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6560 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6556 if (obj) {
6561 if (obj) {
6557 static const char* argumentList[] ={"" , "QTimerEvent*"};
6562 static const char* argumentList[] ={"" , "QTimerEvent*"};
6558 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6563 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6559 void* args[2] = {NULL, (void*)&arg__1};
6564 void* args[2] = {NULL, (void*)&arg__1};
6560 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6565 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6561 if (result) { Py_DECREF(result); }
6566 if (result) { Py_DECREF(result); }
6562 Py_DECREF(obj);
6567 Py_DECREF(obj);
6563 return;
6568 return;
6564 } else {
6569 } else {
6565 PyErr_Clear();
6570 PyErr_Clear();
6566 }
6571 }
6567 }
6572 }
6568 abstractBinFileWidget::timerEvent(arg__1);
6573 abstractBinFileWidget::timerEvent(arg__1);
6569 }
6574 }
6570 void PythonQtShell_abstractBinFileWidget::wheelEvent(QWheelEvent* arg__1)
6575 void PythonQtShell_abstractBinFileWidget::wheelEvent(QWheelEvent* arg__1)
6571 {
6576 {
6572 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6577 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6573 static PyObject* name = PyString_FromString("wheelEvent");
6578 static PyObject* name = PyString_FromString("wheelEvent");
6574 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6579 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6575 if (obj) {
6580 if (obj) {
6576 static const char* argumentList[] ={"" , "QWheelEvent*"};
6581 static const char* argumentList[] ={"" , "QWheelEvent*"};
6577 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6582 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6578 void* args[2] = {NULL, (void*)&arg__1};
6583 void* args[2] = {NULL, (void*)&arg__1};
6579 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6584 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6580 if (result) { Py_DECREF(result); }
6585 if (result) { Py_DECREF(result); }
6581 Py_DECREF(obj);
6586 Py_DECREF(obj);
6582 return;
6587 return;
6583 } else {
6588 } else {
6584 PyErr_Clear();
6589 PyErr_Clear();
6585 }
6590 }
6586 }
6591 }
6587 abstractBinFileWidget::wheelEvent(arg__1);
6592 abstractBinFileWidget::wheelEvent(arg__1);
6588 }
6593 }
6589 abstractBinFileWidget* PythonQtWrapper_abstractBinFileWidget::new_abstractBinFileWidget(QWidget* parent)
6594 abstractBinFileWidget* PythonQtWrapper_abstractBinFileWidget::new_abstractBinFileWidget(QWidget* parent)
6590 {
6595 {
6591 return new PythonQtShell_abstractBinFileWidget(parent); }
6596 return new PythonQtShell_abstractBinFileWidget(parent); }
6592
6597
6593 void PythonQtWrapper_abstractBinFileWidget::reloadFile(abstractBinFileWidget* theWrappedObject)
6598 void PythonQtWrapper_abstractBinFileWidget::reloadFile(abstractBinFileWidget* theWrappedObject)
6594 {
6599 {
6595 ( ((PythonQtPublicPromoter_abstractBinFileWidget*)theWrappedObject)->promoted_reloadFile());
6600 ( ((PythonQtPublicPromoter_abstractBinFileWidget*)theWrappedObject)->promoted_reloadFile());
6596 }
6601 }
6597
6602
6598 void PythonQtWrapper_abstractBinFileWidget::setFile(abstractBinFileWidget* theWrappedObject, abstractBinFile* file)
6603 void PythonQtWrapper_abstractBinFileWidget::setFile(abstractBinFileWidget* theWrappedObject, abstractBinFile* file)
6599 {
6604 {
6600 ( ((PythonQtPublicPromoter_abstractBinFileWidget*)theWrappedObject)->promoted_setFile(file));
6605 ( ((PythonQtPublicPromoter_abstractBinFileWidget*)theWrappedObject)->promoted_setFile(file));
6601 }
6606 }
6602
6607
6603
6608
6604
6609
6605 PythonQtShell_binaryFile::~PythonQtShell_binaryFile() {
6610 PythonQtShell_binaryFile::~PythonQtShell_binaryFile() {
6606 PythonQtPrivate* priv = PythonQt::priv();
6611 PythonQtPrivate* priv = PythonQt::priv();
6607 if (priv) { priv->shellClassDeleted(this); }
6612 if (priv) { priv->shellClassDeleted(this); }
6608 }
6613 }
6609 int PythonQtShell_binaryFile::closeFile()
6614 int PythonQtShell_binaryFile::closeFile()
6610 {
6615 {
6611 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6616 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6612 static PyObject* name = PyString_FromString("closeFile");
6617 static PyObject* name = PyString_FromString("closeFile");
6613 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6618 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6614 if (obj) {
6619 if (obj) {
6615 static const char* argumentList[] ={"int"};
6620 static const char* argumentList[] ={"int"};
6616 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6621 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6617 int returnValue;
6622 int returnValue;
6618 void* args[1] = {NULL};
6623 void* args[1] = {NULL};
6619 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6624 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6620 if (result) {
6625 if (result) {
6621 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6626 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6622 if (args[0]!=&returnValue) {
6627 if (args[0]!=&returnValue) {
6623 if (args[0]==NULL) {
6628 if (args[0]==NULL) {
6624 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
6629 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
6625 } else {
6630 } else {
6626 returnValue = *((int*)args[0]);
6631 returnValue = *((int*)args[0]);
6627 }
6632 }
6628 }
6633 }
6629 }
6634 }
6630 if (result) { Py_DECREF(result); }
6635 if (result) { Py_DECREF(result); }
6631 Py_DECREF(obj);
6636 Py_DECREF(obj);
6632 return returnValue;
6637 return returnValue;
6633 } else {
6638 } else {
6634 PyErr_Clear();
6639 PyErr_Clear();
6635 }
6640 }
6636 }
6641 }
6637 return binaryFile::closeFile();
6642 return binaryFile::closeFile();
6638 }
6643 }
6639 QList<codeFragment* > PythonQtShell_binaryFile::getFragments()
6644 QList<codeFragment* > PythonQtShell_binaryFile::getFragments()
6640 {
6645 {
6641 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6646 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6642 static PyObject* name = PyString_FromString("getFragments");
6647 static PyObject* name = PyString_FromString("getFragments");
6643 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6648 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6644 if (obj) {
6649 if (obj) {
6645 static const char* argumentList[] ={"QList<codeFragment* >"};
6650 static const char* argumentList[] ={"QList<codeFragment* >"};
6646 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6651 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6647 QList<codeFragment* > returnValue;
6652 QList<codeFragment* > returnValue;
6648 void* args[1] = {NULL};
6653 void* args[1] = {NULL};
6649 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6654 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6650 if (result) {
6655 if (result) {
6651 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6656 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6652 if (args[0]!=&returnValue) {
6657 if (args[0]!=&returnValue) {
6653 if (args[0]==NULL) {
6658 if (args[0]==NULL) {
6654 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
6659 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
6655 } else {
6660 } else {
6656 returnValue = *((QList<codeFragment* >*)args[0]);
6661 returnValue = *((QList<codeFragment* >*)args[0]);
6657 }
6662 }
6658 }
6663 }
6659 }
6664 }
6660 if (result) { Py_DECREF(result); }
6665 if (result) { Py_DECREF(result); }
6661 Py_DECREF(obj);
6666 Py_DECREF(obj);
6662 return returnValue;
6667 return returnValue;
6663 } else {
6668 } else {
6664 PyErr_Clear();
6669 PyErr_Clear();
6665 }
6670 }
6666 }
6671 }
6667 return binaryFile::getFragments();
6672 return binaryFile::getFragments();
6668 }
6673 }
6669 bool PythonQtShell_binaryFile::isopened()
6674 bool PythonQtShell_binaryFile::isopened()
6670 {
6675 {
6671 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6676 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6672 static PyObject* name = PyString_FromString("isopened");
6677 static PyObject* name = PyString_FromString("isopened");
6673 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6678 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6674 if (obj) {
6679 if (obj) {
6675 static const char* argumentList[] ={"bool"};
6680 static const char* argumentList[] ={"bool"};
6676 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6681 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6677 bool returnValue;
6682 bool returnValue;
6678 void* args[1] = {NULL};
6683 void* args[1] = {NULL};
6679 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6684 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6680 if (result) {
6685 if (result) {
6681 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6686 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6682 if (args[0]!=&returnValue) {
6687 if (args[0]!=&returnValue) {
6683 if (args[0]==NULL) {
6688 if (args[0]==NULL) {
6684 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
6689 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
6685 } else {
6690 } else {
6686 returnValue = *((bool*)args[0]);
6691 returnValue = *((bool*)args[0]);
6687 }
6692 }
6688 }
6693 }
6689 }
6694 }
6690 if (result) { Py_DECREF(result); }
6695 if (result) { Py_DECREF(result); }
6691 Py_DECREF(obj);
6696 Py_DECREF(obj);
6692 return returnValue;
6697 return returnValue;
6693 } else {
6698 } else {
6694 PyErr_Clear();
6699 PyErr_Clear();
6695 }
6700 }
6696 }
6701 }
6697 return binaryFile::isopened();
6702 return binaryFile::isopened();
6698 }
6703 }
6699 bool PythonQtShell_binaryFile::openFile(const QString& File0)
6704 bool PythonQtShell_binaryFile::openFile(const QString& File0)
6700 {
6705 {
6701 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6706 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6702 static PyObject* name = PyString_FromString("openFile");
6707 static PyObject* name = PyString_FromString("openFile");
6703 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6708 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6704 if (obj) {
6709 if (obj) {
6705 static const char* argumentList[] ={"bool" , "const QString&"};
6710 static const char* argumentList[] ={"bool" , "const QString&"};
6706 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6711 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6707 bool returnValue;
6712 bool returnValue;
6708 void* args[2] = {NULL, (void*)&File0};
6713 void* args[2] = {NULL, (void*)&File0};
6709 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6714 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6710 if (result) {
6715 if (result) {
6711 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6716 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6712 if (args[0]!=&returnValue) {
6717 if (args[0]!=&returnValue) {
6713 if (args[0]==NULL) {
6718 if (args[0]==NULL) {
6714 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
6719 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
6715 } else {
6720 } else {
6716 returnValue = *((bool*)args[0]);
6721 returnValue = *((bool*)args[0]);
6717 }
6722 }
6718 }
6723 }
6719 }
6724 }
6720 if (result) { Py_DECREF(result); }
6725 if (result) { Py_DECREF(result); }
6721 Py_DECREF(obj);
6726 Py_DECREF(obj);
6722 return returnValue;
6727 return returnValue;
6723 } else {
6728 } else {
6724 PyErr_Clear();
6729 PyErr_Clear();
6725 }
6730 }
6726 }
6731 }
6727 return binaryFile::openFile(File0);
6732 return binaryFile::openFile(File0);
6728 }
6733 }
6729 bool PythonQtShell_binaryFile::toBinary(const QString& fileName0)
6734 bool PythonQtShell_binaryFile::toBinary(const QString& fileName0)
6730 {
6735 {
6731 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6736 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6732 static PyObject* name = PyString_FromString("toBinary");
6737 static PyObject* name = PyString_FromString("toBinary");
6733 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6738 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6734 if (obj) {
6739 if (obj) {
6735 static const char* argumentList[] ={"bool" , "const QString&"};
6740 static const char* argumentList[] ={"bool" , "const QString&"};
6736 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6741 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6737 bool returnValue;
6742 bool returnValue;
6738 void* args[2] = {NULL, (void*)&fileName0};
6743 void* args[2] = {NULL, (void*)&fileName0};
6739 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6744 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6740 if (result) {
6745 if (result) {
6741 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6746 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6742 if (args[0]!=&returnValue) {
6747 if (args[0]!=&returnValue) {
6743 if (args[0]==NULL) {
6748 if (args[0]==NULL) {
6744 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
6749 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
6745 } else {
6750 } else {
6746 returnValue = *((bool*)args[0]);
6751 returnValue = *((bool*)args[0]);
6747 }
6752 }
6748 }
6753 }
6749 }
6754 }
6750 if (result) { Py_DECREF(result); }
6755 if (result) { Py_DECREF(result); }
6751 Py_DECREF(obj);
6756 Py_DECREF(obj);
6752 return returnValue;
6757 return returnValue;
6753 } else {
6758 } else {
6754 PyErr_Clear();
6759 PyErr_Clear();
6755 }
6760 }
6756 }
6761 }
6757 return binaryFile::toBinary(fileName0);
6762 return binaryFile::toBinary(fileName0);
6758 }
6763 }
6759 bool PythonQtShell_binaryFile::toSrec(const QString& fileName0)
6764 bool PythonQtShell_binaryFile::toSrec(const QString& fileName0)
6760 {
6765 {
6761 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6766 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6762 static PyObject* name = PyString_FromString("toSrec");
6767 static PyObject* name = PyString_FromString("toSrec");
6763 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6768 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6764 if (obj) {
6769 if (obj) {
6765 static const char* argumentList[] ={"bool" , "const QString&"};
6770 static const char* argumentList[] ={"bool" , "const QString&"};
6766 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6771 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6767 bool returnValue;
6772 bool returnValue;
6768 void* args[2] = {NULL, (void*)&fileName0};
6773 void* args[2] = {NULL, (void*)&fileName0};
6769 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6774 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6770 if (result) {
6775 if (result) {
6771 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6776 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6772 if (args[0]!=&returnValue) {
6777 if (args[0]!=&returnValue) {
6773 if (args[0]==NULL) {
6778 if (args[0]==NULL) {
6774 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
6779 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
6775 } else {
6780 } else {
6776 returnValue = *((bool*)args[0]);
6781 returnValue = *((bool*)args[0]);
6777 }
6782 }
6778 }
6783 }
6779 }
6784 }
6780 if (result) { Py_DECREF(result); }
6785 if (result) { Py_DECREF(result); }
6781 Py_DECREF(obj);
6786 Py_DECREF(obj);
6782 return returnValue;
6787 return returnValue;
6783 } else {
6788 } else {
6784 PyErr_Clear();
6789 PyErr_Clear();
6785 }
6790 }
6786 }
6791 }
6787 return binaryFile::toSrec(fileName0);
6792 return binaryFile::toSrec(fileName0);
6788 }
6793 }
6789 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile()
6794 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile()
6790 {
6795 {
6791 return new PythonQtShell_binaryFile(); }
6796 return new PythonQtShell_binaryFile(); }
6792
6797
6793 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile(const QString& File)
6798 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile(const QString& File)
6794 {
6799 {
6795 return new PythonQtShell_binaryFile(File); }
6800 return new PythonQtShell_binaryFile(File); }
6796
6801
6797 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile(const QStringList& Files)
6802 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile(const QStringList& Files)
6798 {
6803 {
6799 return new PythonQtShell_binaryFile(Files); }
6804 return new PythonQtShell_binaryFile(Files); }
6800
6805
6801 int PythonQtWrapper_binaryFile::closeFile(binaryFile* theWrappedObject)
6806 int PythonQtWrapper_binaryFile::closeFile(binaryFile* theWrappedObject)
6802 {
6807 {
6803 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_closeFile());
6808 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_closeFile());
6804 }
6809 }
6805
6810
6806 codeFragment* PythonQtWrapper_binaryFile::getFragment(binaryFile* theWrappedObject, int index)
6811 codeFragment* PythonQtWrapper_binaryFile::getFragment(binaryFile* theWrappedObject, int index)
6807 {
6812 {
6808 return ( theWrappedObject->getFragment(index));
6813 return ( theWrappedObject->getFragment(index));
6809 }
6814 }
6810
6815
6811 int PythonQtWrapper_binaryFile::getFragmentAddress(binaryFile* theWrappedObject, int index)
6816 int PythonQtWrapper_binaryFile::getFragmentAddress(binaryFile* theWrappedObject, int index)
6812 {
6817 {
6813 return ( theWrappedObject->getFragmentAddress(index));
6818 return ( theWrappedObject->getFragmentAddress(index));
6814 }
6819 }
6815
6820
6816 bool PythonQtWrapper_binaryFile::getFragmentData(binaryFile* theWrappedObject, int index, char** buffer)
6821 bool PythonQtWrapper_binaryFile::getFragmentData(binaryFile* theWrappedObject, int index, char** buffer)
6817 {
6822 {
6818 return ( theWrappedObject->getFragmentData(index, buffer));
6823 return ( theWrappedObject->getFragmentData(index, buffer));
6819 }
6824 }
6820
6825
6821 QString PythonQtWrapper_binaryFile::getFragmentHeader(binaryFile* theWrappedObject, int index)
6826 QString PythonQtWrapper_binaryFile::getFragmentHeader(binaryFile* theWrappedObject, int index)
6822 {
6827 {
6823 return ( theWrappedObject->getFragmentHeader(index));
6828 return ( theWrappedObject->getFragmentHeader(index));
6824 }
6829 }
6825
6830
6826 int PythonQtWrapper_binaryFile::getFragmentSize(binaryFile* theWrappedObject, int index)
6831 int PythonQtWrapper_binaryFile::getFragmentSize(binaryFile* theWrappedObject, int index)
6827 {
6832 {
6828 return ( theWrappedObject->getFragmentSize(index));
6833 return ( theWrappedObject->getFragmentSize(index));
6829 }
6834 }
6830
6835
6831 QList<codeFragment* > PythonQtWrapper_binaryFile::getFragments(binaryFile* theWrappedObject)
6836 QList<codeFragment* > PythonQtWrapper_binaryFile::getFragments(binaryFile* theWrappedObject)
6832 {
6837 {
6833 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_getFragments());
6838 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_getFragments());
6834 }
6839 }
6835
6840
6836 int PythonQtWrapper_binaryFile::getFragmentsCount(binaryFile* theWrappedObject)
6841 int PythonQtWrapper_binaryFile::getFragmentsCount(binaryFile* theWrappedObject)
6837 {
6842 {
6838 return ( theWrappedObject->getFragmentsCount());
6843 return ( theWrappedObject->getFragmentsCount());
6839 }
6844 }
6840
6845
6841 bool PythonQtWrapper_binaryFile::isopened(binaryFile* theWrappedObject)
6846 bool PythonQtWrapper_binaryFile::isopened(binaryFile* theWrappedObject)
6842 {
6847 {
6843 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_isopened());
6848 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_isopened());
6844 }
6849 }
6845
6850
6846 bool PythonQtWrapper_binaryFile::openFile(binaryFile* theWrappedObject, const QString& File)
6851 bool PythonQtWrapper_binaryFile::openFile(binaryFile* theWrappedObject, const QString& File)
6847 {
6852 {
6848 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_openFile(File));
6853 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_openFile(File));
6849 }
6854 }
6850
6855
6851 bool PythonQtWrapper_binaryFile::openFiles(binaryFile* theWrappedObject, const QStringList& Files)
6856 bool PythonQtWrapper_binaryFile::openFiles(binaryFile* theWrappedObject, const QStringList& Files)
6852 {
6857 {
6853 return ( theWrappedObject->openFiles(Files));
6858 return ( theWrappedObject->openFiles(Files));
6854 }
6859 }
6855
6860
6856 bool PythonQtWrapper_binaryFile::static_binaryFile_toBinary(QList<codeFragment* > fragments, const QString& File)
6861 bool PythonQtWrapper_binaryFile::static_binaryFile_toBinary(QList<codeFragment* > fragments, const QString& File)
6857 {
6862 {
6858 return (binaryFile::toBinary(fragments, File));
6863 return (binaryFile::toBinary(fragments, File));
6859 }
6864 }
6860
6865
6861 bool PythonQtWrapper_binaryFile::toBinary(binaryFile* theWrappedObject, const QString& fileName)
6866 bool PythonQtWrapper_binaryFile::toBinary(binaryFile* theWrappedObject, const QString& fileName)
6862 {
6867 {
6863 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_toBinary(fileName));
6868 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_toBinary(fileName));
6864 }
6869 }
6865
6870
6866 bool PythonQtWrapper_binaryFile::toSrec(binaryFile* theWrappedObject, const QString& fileName)
6871 bool PythonQtWrapper_binaryFile::toSrec(binaryFile* theWrappedObject, const QString& fileName)
6867 {
6872 {
6868 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_toSrec(fileName));
6873 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_toSrec(fileName));
6869 }
6874 }
6870
6875
6871
6876
6872
6877
6873 PythonQtShell_binaryFileWidget::~PythonQtShell_binaryFileWidget() {
6878 PythonQtShell_binaryFileWidget::~PythonQtShell_binaryFileWidget() {
6874 PythonQtPrivate* priv = PythonQt::priv();
6879 PythonQtPrivate* priv = PythonQt::priv();
6875 if (priv) { priv->shellClassDeleted(this); }
6880 if (priv) { priv->shellClassDeleted(this); }
6876 }
6881 }
6877 void PythonQtShell_binaryFileWidget::reloadFile()
6882 void PythonQtShell_binaryFileWidget::reloadFile()
6878 {
6883 {
6879 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6884 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6880 static PyObject* name = PyString_FromString("reloadFile");
6885 static PyObject* name = PyString_FromString("reloadFile");
6881 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6886 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6882 if (obj) {
6887 if (obj) {
6883 static const char* argumentList[] ={""};
6888 static const char* argumentList[] ={""};
6884 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6889 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6885 void* args[1] = {NULL};
6890 void* args[1] = {NULL};
6886 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6891 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6887 if (result) { Py_DECREF(result); }
6892 if (result) { Py_DECREF(result); }
6888 Py_DECREF(obj);
6893 Py_DECREF(obj);
6889 return;
6894 return;
6890 } else {
6895 } else {
6891 PyErr_Clear();
6896 PyErr_Clear();
6892 }
6897 }
6893 }
6898 }
6894 binaryFileWidget::reloadFile();
6899 binaryFileWidget::reloadFile();
6895 }
6900 }
6896 void PythonQtShell_binaryFileWidget::setFile(abstractBinFile* file0)
6901 void PythonQtShell_binaryFileWidget::setFile(abstractBinFile* file0)
6897 {
6902 {
6898 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6903 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6899 static PyObject* name = PyString_FromString("setFile");
6904 static PyObject* name = PyString_FromString("setFile");
6900 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6905 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6901 if (obj) {
6906 if (obj) {
6902 static const char* argumentList[] ={"" , "abstractBinFile*"};
6907 static const char* argumentList[] ={"" , "abstractBinFile*"};
6903 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6908 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6904 void* args[2] = {NULL, (void*)&file0};
6909 void* args[2] = {NULL, (void*)&file0};
6905 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6910 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6906 if (result) { Py_DECREF(result); }
6911 if (result) { Py_DECREF(result); }
6907 Py_DECREF(obj);
6912 Py_DECREF(obj);
6908 return;
6913 return;
6909 } else {
6914 } else {
6910 PyErr_Clear();
6915 PyErr_Clear();
6911 }
6916 }
6912 }
6917 }
6913 binaryFileWidget::setFile(file0);
6918 binaryFileWidget::setFile(file0);
6914 }
6919 }
6915 binaryFileWidget* PythonQtWrapper_binaryFileWidget::new_binaryFileWidget(QWidget* parent)
6920 binaryFileWidget* PythonQtWrapper_binaryFileWidget::new_binaryFileWidget(QWidget* parent)
6916 {
6921 {
6917 return new PythonQtShell_binaryFileWidget(parent); }
6922 return new PythonQtShell_binaryFileWidget(parent); }
6918
6923
6919 void PythonQtWrapper_binaryFileWidget::reloadFile(binaryFileWidget* theWrappedObject)
6924 void PythonQtWrapper_binaryFileWidget::reloadFile(binaryFileWidget* theWrappedObject)
6920 {
6925 {
6921 ( ((PythonQtPublicPromoter_binaryFileWidget*)theWrappedObject)->promoted_reloadFile());
6926 ( ((PythonQtPublicPromoter_binaryFileWidget*)theWrappedObject)->promoted_reloadFile());
6922 }
6927 }
6923
6928
6924 void PythonQtWrapper_binaryFileWidget::setFile(binaryFileWidget* theWrappedObject, abstractBinFile* file)
6929 void PythonQtWrapper_binaryFileWidget::setFile(binaryFileWidget* theWrappedObject, abstractBinFile* file)
6925 {
6930 {
6926 ( ((PythonQtPublicPromoter_binaryFileWidget*)theWrappedObject)->promoted_setFile(file));
6931 ( ((PythonQtPublicPromoter_binaryFileWidget*)theWrappedObject)->promoted_setFile(file));
6927 }
6932 }
6928
6933
6929
6934
6930
6935
6931 PythonQtShell_codeFragment::~PythonQtShell_codeFragment() {
6936 PythonQtShell_codeFragment::~PythonQtShell_codeFragment() {
6932 PythonQtPrivate* priv = PythonQt::priv();
6937 PythonQtPrivate* priv = PythonQt::priv();
6933 if (priv) { priv->shellClassDeleted(this); }
6938 if (priv) { priv->shellClassDeleted(this); }
6934 }
6939 }
6935 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment()
6940 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment()
6936 {
6941 {
6937 return new PythonQtShell_codeFragment(); }
6942 return new PythonQtShell_codeFragment(); }
6938
6943
6939 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment(char* data, quint64 size, quint64 address)
6944 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment(char* data, quint64 size, quint64 address)
6940 {
6945 {
6941 return new PythonQtShell_codeFragment(data, size, address); }
6946 return new PythonQtShell_codeFragment(data, size, address); }
6942
6947
6943
6948
6944
6949
6945 PythonQtShell_elfFileWidget::~PythonQtShell_elfFileWidget() {
6950 PythonQtShell_elfFileWidget::~PythonQtShell_elfFileWidget() {
6946 PythonQtPrivate* priv = PythonQt::priv();
6951 PythonQtPrivate* priv = PythonQt::priv();
6947 if (priv) { priv->shellClassDeleted(this); }
6952 if (priv) { priv->shellClassDeleted(this); }
6948 }
6953 }
6949 void PythonQtShell_elfFileWidget::reloadFile()
6954 void PythonQtShell_elfFileWidget::reloadFile()
6950 {
6955 {
6951 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6956 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6952 static PyObject* name = PyString_FromString("reloadFile");
6957 static PyObject* name = PyString_FromString("reloadFile");
6953 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6958 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6954 if (obj) {
6959 if (obj) {
6955 static const char* argumentList[] ={""};
6960 static const char* argumentList[] ={""};
6956 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6961 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6957 void* args[1] = {NULL};
6962 void* args[1] = {NULL};
6958 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6963 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6959 if (result) { Py_DECREF(result); }
6964 if (result) { Py_DECREF(result); }
6960 Py_DECREF(obj);
6965 Py_DECREF(obj);
6961 return;
6966 return;
6962 } else {
6967 } else {
6963 PyErr_Clear();
6968 PyErr_Clear();
6964 }
6969 }
6965 }
6970 }
6966 elfFileWidget::reloadFile();
6971 elfFileWidget::reloadFile();
6967 }
6972 }
6968 void PythonQtShell_elfFileWidget::setFile(abstractBinFile* file0)
6973 void PythonQtShell_elfFileWidget::setFile(abstractBinFile* file0)
6969 {
6974 {
6970 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6975 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
6971 static PyObject* name = PyString_FromString("setFile");
6976 static PyObject* name = PyString_FromString("setFile");
6972 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6977 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
6973 if (obj) {
6978 if (obj) {
6974 static const char* argumentList[] ={"" , "abstractBinFile*"};
6979 static const char* argumentList[] ={"" , "abstractBinFile*"};
6975 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6980 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6976 void* args[2] = {NULL, (void*)&file0};
6981 void* args[2] = {NULL, (void*)&file0};
6977 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6982 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6978 if (result) { Py_DECREF(result); }
6983 if (result) { Py_DECREF(result); }
6979 Py_DECREF(obj);
6984 Py_DECREF(obj);
6980 return;
6985 return;
6981 } else {
6986 } else {
6982 PyErr_Clear();
6987 PyErr_Clear();
6983 }
6988 }
6984 }
6989 }
6985 elfFileWidget::setFile(file0);
6990 elfFileWidget::setFile(file0);
6986 }
6991 }
6987 elfFileWidget* PythonQtWrapper_elfFileWidget::new_elfFileWidget(QWidget* parent)
6992 elfFileWidget* PythonQtWrapper_elfFileWidget::new_elfFileWidget(QWidget* parent)
6988 {
6993 {
6989 return new PythonQtShell_elfFileWidget(parent); }
6994 return new PythonQtShell_elfFileWidget(parent); }
6990
6995
6991 void PythonQtWrapper_elfFileWidget::reloadFile(elfFileWidget* theWrappedObject)
6996 void PythonQtWrapper_elfFileWidget::reloadFile(elfFileWidget* theWrappedObject)
6992 {
6997 {
6993 ( ((PythonQtPublicPromoter_elfFileWidget*)theWrappedObject)->promoted_reloadFile());
6998 ( ((PythonQtPublicPromoter_elfFileWidget*)theWrappedObject)->promoted_reloadFile());
6994 }
6999 }
6995
7000
6996 void PythonQtWrapper_elfFileWidget::setFile(elfFileWidget* theWrappedObject, abstractBinFile* file)
7001 void PythonQtWrapper_elfFileWidget::setFile(elfFileWidget* theWrappedObject, abstractBinFile* file)
6997 {
7002 {
6998 ( ((PythonQtPublicPromoter_elfFileWidget*)theWrappedObject)->promoted_setFile(file));
7003 ( ((PythonQtPublicPromoter_elfFileWidget*)theWrappedObject)->promoted_setFile(file));
6999 }
7004 }
7000
7005
7001
7006
7002
7007
7003 PythonQtShell_elfInfoWdgt::~PythonQtShell_elfInfoWdgt() {
7008 PythonQtShell_elfInfoWdgt::~PythonQtShell_elfInfoWdgt() {
7004 PythonQtPrivate* priv = PythonQt::priv();
7009 PythonQtPrivate* priv = PythonQt::priv();
7005 if (priv) { priv->shellClassDeleted(this); }
7010 if (priv) { priv->shellClassDeleted(this); }
7006 }
7011 }
7007 void PythonQtShell_elfInfoWdgt::actionEvent(QActionEvent* arg__1)
7012 void PythonQtShell_elfInfoWdgt::actionEvent(QActionEvent* arg__1)
7008 {
7013 {
7009 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7014 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7010 static PyObject* name = PyString_FromString("actionEvent");
7015 static PyObject* name = PyString_FromString("actionEvent");
7011 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7016 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7012 if (obj) {
7017 if (obj) {
7013 static const char* argumentList[] ={"" , "QActionEvent*"};
7018 static const char* argumentList[] ={"" , "QActionEvent*"};
7014 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7019 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7015 void* args[2] = {NULL, (void*)&arg__1};
7020 void* args[2] = {NULL, (void*)&arg__1};
7016 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7021 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7017 if (result) { Py_DECREF(result); }
7022 if (result) { Py_DECREF(result); }
7018 Py_DECREF(obj);
7023 Py_DECREF(obj);
7019 return;
7024 return;
7020 } else {
7025 } else {
7021 PyErr_Clear();
7026 PyErr_Clear();
7022 }
7027 }
7023 }
7028 }
7024 elfInfoWdgt::actionEvent(arg__1);
7029 elfInfoWdgt::actionEvent(arg__1);
7025 }
7030 }
7026 void PythonQtShell_elfInfoWdgt::changeEvent(QEvent* arg__1)
7031 void PythonQtShell_elfInfoWdgt::changeEvent(QEvent* arg__1)
7027 {
7032 {
7028 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7033 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7029 static PyObject* name = PyString_FromString("changeEvent");
7034 static PyObject* name = PyString_FromString("changeEvent");
7030 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7035 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7031 if (obj) {
7036 if (obj) {
7032 static const char* argumentList[] ={"" , "QEvent*"};
7037 static const char* argumentList[] ={"" , "QEvent*"};
7033 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7038 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7034 void* args[2] = {NULL, (void*)&arg__1};
7039 void* args[2] = {NULL, (void*)&arg__1};
7035 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7040 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7036 if (result) { Py_DECREF(result); }
7041 if (result) { Py_DECREF(result); }
7037 Py_DECREF(obj);
7042 Py_DECREF(obj);
7038 return;
7043 return;
7039 } else {
7044 } else {
7040 PyErr_Clear();
7045 PyErr_Clear();
7041 }
7046 }
7042 }
7047 }
7043 elfInfoWdgt::changeEvent(arg__1);
7048 elfInfoWdgt::changeEvent(arg__1);
7044 }
7049 }
7045 void PythonQtShell_elfInfoWdgt::childEvent(QChildEvent* arg__1)
7050 void PythonQtShell_elfInfoWdgt::childEvent(QChildEvent* arg__1)
7046 {
7051 {
7047 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7052 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7048 static PyObject* name = PyString_FromString("childEvent");
7053 static PyObject* name = PyString_FromString("childEvent");
7049 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7054 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7050 if (obj) {
7055 if (obj) {
7051 static const char* argumentList[] ={"" , "QChildEvent*"};
7056 static const char* argumentList[] ={"" , "QChildEvent*"};
7052 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7057 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7053 void* args[2] = {NULL, (void*)&arg__1};
7058 void* args[2] = {NULL, (void*)&arg__1};
7054 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7059 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7055 if (result) { Py_DECREF(result); }
7060 if (result) { Py_DECREF(result); }
7056 Py_DECREF(obj);
7061 Py_DECREF(obj);
7057 return;
7062 return;
7058 } else {
7063 } else {
7059 PyErr_Clear();
7064 PyErr_Clear();
7060 }
7065 }
7061 }
7066 }
7062 elfInfoWdgt::childEvent(arg__1);
7067 elfInfoWdgt::childEvent(arg__1);
7063 }
7068 }
7064 void PythonQtShell_elfInfoWdgt::closeEvent(QCloseEvent* arg__1)
7069 void PythonQtShell_elfInfoWdgt::closeEvent(QCloseEvent* arg__1)
7065 {
7070 {
7066 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7071 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7067 static PyObject* name = PyString_FromString("closeEvent");
7072 static PyObject* name = PyString_FromString("closeEvent");
7068 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7073 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7069 if (obj) {
7074 if (obj) {
7070 static const char* argumentList[] ={"" , "QCloseEvent*"};
7075 static const char* argumentList[] ={"" , "QCloseEvent*"};
7071 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7076 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7072 void* args[2] = {NULL, (void*)&arg__1};
7077 void* args[2] = {NULL, (void*)&arg__1};
7073 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7078 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7074 if (result) { Py_DECREF(result); }
7079 if (result) { Py_DECREF(result); }
7075 Py_DECREF(obj);
7080 Py_DECREF(obj);
7076 return;
7081 return;
7077 } else {
7082 } else {
7078 PyErr_Clear();
7083 PyErr_Clear();
7079 }
7084 }
7080 }
7085 }
7081 elfInfoWdgt::closeEvent(arg__1);
7086 elfInfoWdgt::closeEvent(arg__1);
7082 }
7087 }
7083 void PythonQtShell_elfInfoWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
7088 void PythonQtShell_elfInfoWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
7084 {
7089 {
7085 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7090 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7086 static PyObject* name = PyString_FromString("contextMenuEvent");
7091 static PyObject* name = PyString_FromString("contextMenuEvent");
7087 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7092 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7088 if (obj) {
7093 if (obj) {
7089 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
7094 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
7090 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7095 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7091 void* args[2] = {NULL, (void*)&arg__1};
7096 void* args[2] = {NULL, (void*)&arg__1};
7092 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7097 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7093 if (result) { Py_DECREF(result); }
7098 if (result) { Py_DECREF(result); }
7094 Py_DECREF(obj);
7099 Py_DECREF(obj);
7095 return;
7100 return;
7096 } else {
7101 } else {
7097 PyErr_Clear();
7102 PyErr_Clear();
7098 }
7103 }
7099 }
7104 }
7100 elfInfoWdgt::contextMenuEvent(arg__1);
7105 elfInfoWdgt::contextMenuEvent(arg__1);
7101 }
7106 }
7102 void PythonQtShell_elfInfoWdgt::customEvent(QEvent* arg__1)
7107 void PythonQtShell_elfInfoWdgt::customEvent(QEvent* arg__1)
7103 {
7108 {
7104 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7109 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7105 static PyObject* name = PyString_FromString("customEvent");
7110 static PyObject* name = PyString_FromString("customEvent");
7106 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7111 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7107 if (obj) {
7112 if (obj) {
7108 static const char* argumentList[] ={"" , "QEvent*"};
7113 static const char* argumentList[] ={"" , "QEvent*"};
7109 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7114 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7110 void* args[2] = {NULL, (void*)&arg__1};
7115 void* args[2] = {NULL, (void*)&arg__1};
7111 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7116 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7112 if (result) { Py_DECREF(result); }
7117 if (result) { Py_DECREF(result); }
7113 Py_DECREF(obj);
7118 Py_DECREF(obj);
7114 return;
7119 return;
7115 } else {
7120 } else {
7116 PyErr_Clear();
7121 PyErr_Clear();
7117 }
7122 }
7118 }
7123 }
7119 elfInfoWdgt::customEvent(arg__1);
7124 elfInfoWdgt::customEvent(arg__1);
7120 }
7125 }
7121 int PythonQtShell_elfInfoWdgt::devType() const
7126 int PythonQtShell_elfInfoWdgt::devType() const
7122 {
7127 {
7123 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7128 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7124 static PyObject* name = PyString_FromString("devType");
7129 static PyObject* name = PyString_FromString("devType");
7125 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7130 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7126 if (obj) {
7131 if (obj) {
7127 static const char* argumentList[] ={"int"};
7132 static const char* argumentList[] ={"int"};
7128 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7133 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7129 int returnValue;
7134 int returnValue;
7130 void* args[1] = {NULL};
7135 void* args[1] = {NULL};
7131 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7136 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7132 if (result) {
7137 if (result) {
7133 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7138 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7134 if (args[0]!=&returnValue) {
7139 if (args[0]!=&returnValue) {
7135 if (args[0]==NULL) {
7140 if (args[0]==NULL) {
7136 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
7141 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
7137 } else {
7142 } else {
7138 returnValue = *((int*)args[0]);
7143 returnValue = *((int*)args[0]);
7139 }
7144 }
7140 }
7145 }
7141 }
7146 }
7142 if (result) { Py_DECREF(result); }
7147 if (result) { Py_DECREF(result); }
7143 Py_DECREF(obj);
7148 Py_DECREF(obj);
7144 return returnValue;
7149 return returnValue;
7145 } else {
7150 } else {
7146 PyErr_Clear();
7151 PyErr_Clear();
7147 }
7152 }
7148 }
7153 }
7149 return elfInfoWdgt::devType();
7154 return elfInfoWdgt::devType();
7150 }
7155 }
7151 void PythonQtShell_elfInfoWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
7156 void PythonQtShell_elfInfoWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
7152 {
7157 {
7153 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7158 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7154 static PyObject* name = PyString_FromString("dragEnterEvent");
7159 static PyObject* name = PyString_FromString("dragEnterEvent");
7155 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7160 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7156 if (obj) {
7161 if (obj) {
7157 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
7162 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
7158 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7163 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7159 void* args[2] = {NULL, (void*)&arg__1};
7164 void* args[2] = {NULL, (void*)&arg__1};
7160 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7165 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7161 if (result) { Py_DECREF(result); }
7166 if (result) { Py_DECREF(result); }
7162 Py_DECREF(obj);
7167 Py_DECREF(obj);
7163 return;
7168 return;
7164 } else {
7169 } else {
7165 PyErr_Clear();
7170 PyErr_Clear();
7166 }
7171 }
7167 }
7172 }
7168 elfInfoWdgt::dragEnterEvent(arg__1);
7173 elfInfoWdgt::dragEnterEvent(arg__1);
7169 }
7174 }
7170 void PythonQtShell_elfInfoWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
7175 void PythonQtShell_elfInfoWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
7171 {
7176 {
7172 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7177 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7173 static PyObject* name = PyString_FromString("dragLeaveEvent");
7178 static PyObject* name = PyString_FromString("dragLeaveEvent");
7174 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7179 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7175 if (obj) {
7180 if (obj) {
7176 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
7181 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
7177 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7182 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7178 void* args[2] = {NULL, (void*)&arg__1};
7183 void* args[2] = {NULL, (void*)&arg__1};
7179 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7184 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7180 if (result) { Py_DECREF(result); }
7185 if (result) { Py_DECREF(result); }
7181 Py_DECREF(obj);
7186 Py_DECREF(obj);
7182 return;
7187 return;
7183 } else {
7188 } else {
7184 PyErr_Clear();
7189 PyErr_Clear();
7185 }
7190 }
7186 }
7191 }
7187 elfInfoWdgt::dragLeaveEvent(arg__1);
7192 elfInfoWdgt::dragLeaveEvent(arg__1);
7188 }
7193 }
7189 void PythonQtShell_elfInfoWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
7194 void PythonQtShell_elfInfoWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
7190 {
7195 {
7191 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7196 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7192 static PyObject* name = PyString_FromString("dragMoveEvent");
7197 static PyObject* name = PyString_FromString("dragMoveEvent");
7193 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7198 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7194 if (obj) {
7199 if (obj) {
7195 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
7200 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
7196 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7201 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7197 void* args[2] = {NULL, (void*)&arg__1};
7202 void* args[2] = {NULL, (void*)&arg__1};
7198 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7203 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7199 if (result) { Py_DECREF(result); }
7204 if (result) { Py_DECREF(result); }
7200 Py_DECREF(obj);
7205 Py_DECREF(obj);
7201 return;
7206 return;
7202 } else {
7207 } else {
7203 PyErr_Clear();
7208 PyErr_Clear();
7204 }
7209 }
7205 }
7210 }
7206 elfInfoWdgt::dragMoveEvent(arg__1);
7211 elfInfoWdgt::dragMoveEvent(arg__1);
7207 }
7212 }
7208 void PythonQtShell_elfInfoWdgt::dropEvent(QDropEvent* arg__1)
7213 void PythonQtShell_elfInfoWdgt::dropEvent(QDropEvent* arg__1)
7209 {
7214 {
7210 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7215 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7211 static PyObject* name = PyString_FromString("dropEvent");
7216 static PyObject* name = PyString_FromString("dropEvent");
7212 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7217 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7213 if (obj) {
7218 if (obj) {
7214 static const char* argumentList[] ={"" , "QDropEvent*"};
7219 static const char* argumentList[] ={"" , "QDropEvent*"};
7215 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7220 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7216 void* args[2] = {NULL, (void*)&arg__1};
7221 void* args[2] = {NULL, (void*)&arg__1};
7217 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7222 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7218 if (result) { Py_DECREF(result); }
7223 if (result) { Py_DECREF(result); }
7219 Py_DECREF(obj);
7224 Py_DECREF(obj);
7220 return;
7225 return;
7221 } else {
7226 } else {
7222 PyErr_Clear();
7227 PyErr_Clear();
7223 }
7228 }
7224 }
7229 }
7225 elfInfoWdgt::dropEvent(arg__1);
7230 elfInfoWdgt::dropEvent(arg__1);
7226 }
7231 }
7227 void PythonQtShell_elfInfoWdgt::enterEvent(QEvent* arg__1)
7232 void PythonQtShell_elfInfoWdgt::enterEvent(QEvent* arg__1)
7228 {
7233 {
7229 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7234 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7230 static PyObject* name = PyString_FromString("enterEvent");
7235 static PyObject* name = PyString_FromString("enterEvent");
7231 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7236 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7232 if (obj) {
7237 if (obj) {
7233 static const char* argumentList[] ={"" , "QEvent*"};
7238 static const char* argumentList[] ={"" , "QEvent*"};
7234 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7239 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7235 void* args[2] = {NULL, (void*)&arg__1};
7240 void* args[2] = {NULL, (void*)&arg__1};
7236 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7241 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7237 if (result) { Py_DECREF(result); }
7242 if (result) { Py_DECREF(result); }
7238 Py_DECREF(obj);
7243 Py_DECREF(obj);
7239 return;
7244 return;
7240 } else {
7245 } else {
7241 PyErr_Clear();
7246 PyErr_Clear();
7242 }
7247 }
7243 }
7248 }
7244 elfInfoWdgt::enterEvent(arg__1);
7249 elfInfoWdgt::enterEvent(arg__1);
7245 }
7250 }
7246 bool PythonQtShell_elfInfoWdgt::event(QEvent* arg__1)
7251 bool PythonQtShell_elfInfoWdgt::event(QEvent* arg__1)
7247 {
7252 {
7248 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7253 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7249 static PyObject* name = PyString_FromString("event");
7254 static PyObject* name = PyString_FromString("event");
7250 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7255 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7251 if (obj) {
7256 if (obj) {
7252 static const char* argumentList[] ={"bool" , "QEvent*"};
7257 static const char* argumentList[] ={"bool" , "QEvent*"};
7253 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7258 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7254 bool returnValue;
7259 bool returnValue;
7255 void* args[2] = {NULL, (void*)&arg__1};
7260 void* args[2] = {NULL, (void*)&arg__1};
7256 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7261 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7257 if (result) {
7262 if (result) {
7258 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7263 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7259 if (args[0]!=&returnValue) {
7264 if (args[0]!=&returnValue) {
7260 if (args[0]==NULL) {
7265 if (args[0]==NULL) {
7261 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
7266 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
7262 } else {
7267 } else {
7263 returnValue = *((bool*)args[0]);
7268 returnValue = *((bool*)args[0]);
7264 }
7269 }
7265 }
7270 }
7266 }
7271 }
7267 if (result) { Py_DECREF(result); }
7272 if (result) { Py_DECREF(result); }
7268 Py_DECREF(obj);
7273 Py_DECREF(obj);
7269 return returnValue;
7274 return returnValue;
7270 } else {
7275 } else {
7271 PyErr_Clear();
7276 PyErr_Clear();
7272 }
7277 }
7273 }
7278 }
7274 return elfInfoWdgt::event(arg__1);
7279 return elfInfoWdgt::event(arg__1);
7275 }
7280 }
7276 bool PythonQtShell_elfInfoWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
7281 bool PythonQtShell_elfInfoWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
7277 {
7282 {
7278 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7283 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7279 static PyObject* name = PyString_FromString("eventFilter");
7284 static PyObject* name = PyString_FromString("eventFilter");
7280 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7285 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7281 if (obj) {
7286 if (obj) {
7282 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
7287 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
7283 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
7288 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
7284 bool returnValue;
7289 bool returnValue;
7285 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
7290 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
7286 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7291 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7287 if (result) {
7292 if (result) {
7288 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7293 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7289 if (args[0]!=&returnValue) {
7294 if (args[0]!=&returnValue) {
7290 if (args[0]==NULL) {
7295 if (args[0]==NULL) {
7291 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
7296 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
7292 } else {
7297 } else {
7293 returnValue = *((bool*)args[0]);
7298 returnValue = *((bool*)args[0]);
7294 }
7299 }
7295 }
7300 }
7296 }
7301 }
7297 if (result) { Py_DECREF(result); }
7302 if (result) { Py_DECREF(result); }
7298 Py_DECREF(obj);
7303 Py_DECREF(obj);
7299 return returnValue;
7304 return returnValue;
7300 } else {
7305 } else {
7301 PyErr_Clear();
7306 PyErr_Clear();
7302 }
7307 }
7303 }
7308 }
7304 return elfInfoWdgt::eventFilter(arg__1, arg__2);
7309 return elfInfoWdgt::eventFilter(arg__1, arg__2);
7305 }
7310 }
7306 void PythonQtShell_elfInfoWdgt::focusInEvent(QFocusEvent* arg__1)
7311 void PythonQtShell_elfInfoWdgt::focusInEvent(QFocusEvent* arg__1)
7307 {
7312 {
7308 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7313 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7309 static PyObject* name = PyString_FromString("focusInEvent");
7314 static PyObject* name = PyString_FromString("focusInEvent");
7310 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7315 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7311 if (obj) {
7316 if (obj) {
7312 static const char* argumentList[] ={"" , "QFocusEvent*"};
7317 static const char* argumentList[] ={"" , "QFocusEvent*"};
7313 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7318 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7314 void* args[2] = {NULL, (void*)&arg__1};
7319 void* args[2] = {NULL, (void*)&arg__1};
7315 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7320 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7316 if (result) { Py_DECREF(result); }
7321 if (result) { Py_DECREF(result); }
7317 Py_DECREF(obj);
7322 Py_DECREF(obj);
7318 return;
7323 return;
7319 } else {
7324 } else {
7320 PyErr_Clear();
7325 PyErr_Clear();
7321 }
7326 }
7322 }
7327 }
7323 elfInfoWdgt::focusInEvent(arg__1);
7328 elfInfoWdgt::focusInEvent(arg__1);
7324 }
7329 }
7325 bool PythonQtShell_elfInfoWdgt::focusNextPrevChild(bool next0)
7330 bool PythonQtShell_elfInfoWdgt::focusNextPrevChild(bool next0)
7326 {
7331 {
7327 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7332 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7328 static PyObject* name = PyString_FromString("focusNextPrevChild");
7333 static PyObject* name = PyString_FromString("focusNextPrevChild");
7329 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7334 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7330 if (obj) {
7335 if (obj) {
7331 static const char* argumentList[] ={"bool" , "bool"};
7336 static const char* argumentList[] ={"bool" , "bool"};
7332 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7337 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7333 bool returnValue;
7338 bool returnValue;
7334 void* args[2] = {NULL, (void*)&next0};
7339 void* args[2] = {NULL, (void*)&next0};
7335 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7340 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7336 if (result) {
7341 if (result) {
7337 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7342 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7338 if (args[0]!=&returnValue) {
7343 if (args[0]!=&returnValue) {
7339 if (args[0]==NULL) {
7344 if (args[0]==NULL) {
7340 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
7345 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
7341 } else {
7346 } else {
7342 returnValue = *((bool*)args[0]);
7347 returnValue = *((bool*)args[0]);
7343 }
7348 }
7344 }
7349 }
7345 }
7350 }
7346 if (result) { Py_DECREF(result); }
7351 if (result) { Py_DECREF(result); }
7347 Py_DECREF(obj);
7352 Py_DECREF(obj);
7348 return returnValue;
7353 return returnValue;
7349 } else {
7354 } else {
7350 PyErr_Clear();
7355 PyErr_Clear();
7351 }
7356 }
7352 }
7357 }
7353 return elfInfoWdgt::focusNextPrevChild(next0);
7358 return elfInfoWdgt::focusNextPrevChild(next0);
7354 }
7359 }
7355 void PythonQtShell_elfInfoWdgt::focusOutEvent(QFocusEvent* arg__1)
7360 void PythonQtShell_elfInfoWdgt::focusOutEvent(QFocusEvent* arg__1)
7356 {
7361 {
7357 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7362 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7358 static PyObject* name = PyString_FromString("focusOutEvent");
7363 static PyObject* name = PyString_FromString("focusOutEvent");
7359 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7364 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7360 if (obj) {
7365 if (obj) {
7361 static const char* argumentList[] ={"" , "QFocusEvent*"};
7366 static const char* argumentList[] ={"" , "QFocusEvent*"};
7362 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7367 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7363 void* args[2] = {NULL, (void*)&arg__1};
7368 void* args[2] = {NULL, (void*)&arg__1};
7364 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7369 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7365 if (result) { Py_DECREF(result); }
7370 if (result) { Py_DECREF(result); }
7366 Py_DECREF(obj);
7371 Py_DECREF(obj);
7367 return;
7372 return;
7368 } else {
7373 } else {
7369 PyErr_Clear();
7374 PyErr_Clear();
7370 }
7375 }
7371 }
7376 }
7372 elfInfoWdgt::focusOutEvent(arg__1);
7377 elfInfoWdgt::focusOutEvent(arg__1);
7373 }
7378 }
7374 bool PythonQtShell_elfInfoWdgt::hasHeightForWidth() const
7379 bool PythonQtShell_elfInfoWdgt::hasHeightForWidth() const
7375 {
7380 {
7376 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7381 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7377 static PyObject* name = PyString_FromString("hasHeightForWidth");
7382 static PyObject* name = PyString_FromString("hasHeightForWidth");
7378 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7383 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7379 if (obj) {
7384 if (obj) {
7380 static const char* argumentList[] ={"bool"};
7385 static const char* argumentList[] ={"bool"};
7381 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7386 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7382 bool returnValue;
7387 bool returnValue;
7383 void* args[1] = {NULL};
7388 void* args[1] = {NULL};
7384 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7389 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7385 if (result) {
7390 if (result) {
7386 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7391 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7387 if (args[0]!=&returnValue) {
7392 if (args[0]!=&returnValue) {
7388 if (args[0]==NULL) {
7393 if (args[0]==NULL) {
7389 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
7394 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
7390 } else {
7395 } else {
7391 returnValue = *((bool*)args[0]);
7396 returnValue = *((bool*)args[0]);
7392 }
7397 }
7393 }
7398 }
7394 }
7399 }
7395 if (result) { Py_DECREF(result); }
7400 if (result) { Py_DECREF(result); }
7396 Py_DECREF(obj);
7401 Py_DECREF(obj);
7397 return returnValue;
7402 return returnValue;
7398 } else {
7403 } else {
7399 PyErr_Clear();
7404 PyErr_Clear();
7400 }
7405 }
7401 }
7406 }
7402 return elfInfoWdgt::hasHeightForWidth();
7407 return elfInfoWdgt::hasHeightForWidth();
7403 }
7408 }
7404 int PythonQtShell_elfInfoWdgt::heightForWidth(int arg__1) const
7409 int PythonQtShell_elfInfoWdgt::heightForWidth(int arg__1) const
7405 {
7410 {
7406 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7411 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7407 static PyObject* name = PyString_FromString("heightForWidth");
7412 static PyObject* name = PyString_FromString("heightForWidth");
7408 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7413 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7409 if (obj) {
7414 if (obj) {
7410 static const char* argumentList[] ={"int" , "int"};
7415 static const char* argumentList[] ={"int" , "int"};
7411 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7416 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7412 int returnValue;
7417 int returnValue;
7413 void* args[2] = {NULL, (void*)&arg__1};
7418 void* args[2] = {NULL, (void*)&arg__1};
7414 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7419 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7415 if (result) {
7420 if (result) {
7416 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7421 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7417 if (args[0]!=&returnValue) {
7422 if (args[0]!=&returnValue) {
7418 if (args[0]==NULL) {
7423 if (args[0]==NULL) {
7419 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
7424 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
7420 } else {
7425 } else {
7421 returnValue = *((int*)args[0]);
7426 returnValue = *((int*)args[0]);
7422 }
7427 }
7423 }
7428 }
7424 }
7429 }
7425 if (result) { Py_DECREF(result); }
7430 if (result) { Py_DECREF(result); }
7426 Py_DECREF(obj);
7431 Py_DECREF(obj);
7427 return returnValue;
7432 return returnValue;
7428 } else {
7433 } else {
7429 PyErr_Clear();
7434 PyErr_Clear();
7430 }
7435 }
7431 }
7436 }
7432 return elfInfoWdgt::heightForWidth(arg__1);
7437 return elfInfoWdgt::heightForWidth(arg__1);
7433 }
7438 }
7434 void PythonQtShell_elfInfoWdgt::hideEvent(QHideEvent* arg__1)
7439 void PythonQtShell_elfInfoWdgt::hideEvent(QHideEvent* arg__1)
7435 {
7440 {
7436 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7441 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7437 static PyObject* name = PyString_FromString("hideEvent");
7442 static PyObject* name = PyString_FromString("hideEvent");
7438 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7443 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7439 if (obj) {
7444 if (obj) {
7440 static const char* argumentList[] ={"" , "QHideEvent*"};
7445 static const char* argumentList[] ={"" , "QHideEvent*"};
7441 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7446 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7442 void* args[2] = {NULL, (void*)&arg__1};
7447 void* args[2] = {NULL, (void*)&arg__1};
7443 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7448 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7444 if (result) { Py_DECREF(result); }
7449 if (result) { Py_DECREF(result); }
7445 Py_DECREF(obj);
7450 Py_DECREF(obj);
7446 return;
7451 return;
7447 } else {
7452 } else {
7448 PyErr_Clear();
7453 PyErr_Clear();
7449 }
7454 }
7450 }
7455 }
7451 elfInfoWdgt::hideEvent(arg__1);
7456 elfInfoWdgt::hideEvent(arg__1);
7452 }
7457 }
7453 void PythonQtShell_elfInfoWdgt::initPainter(QPainter* painter0) const
7458 void PythonQtShell_elfInfoWdgt::initPainter(QPainter* painter0) const
7454 {
7459 {
7455 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7460 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7456 static PyObject* name = PyString_FromString("initPainter");
7461 static PyObject* name = PyString_FromString("initPainter");
7457 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7462 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7458 if (obj) {
7463 if (obj) {
7459 static const char* argumentList[] ={"" , "QPainter*"};
7464 static const char* argumentList[] ={"" , "QPainter*"};
7460 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7465 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7461 void* args[2] = {NULL, (void*)&painter0};
7466 void* args[2] = {NULL, (void*)&painter0};
7462 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7467 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7463 if (result) { Py_DECREF(result); }
7468 if (result) { Py_DECREF(result); }
7464 Py_DECREF(obj);
7469 Py_DECREF(obj);
7465 return;
7470 return;
7466 } else {
7471 } else {
7467 PyErr_Clear();
7472 PyErr_Clear();
7468 }
7473 }
7469 }
7474 }
7470 elfInfoWdgt::initPainter(painter0);
7475 elfInfoWdgt::initPainter(painter0);
7471 }
7476 }
7472 void PythonQtShell_elfInfoWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
7477 void PythonQtShell_elfInfoWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
7473 {
7478 {
7474 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7479 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7475 static PyObject* name = PyString_FromString("inputMethodEvent");
7480 static PyObject* name = PyString_FromString("inputMethodEvent");
7476 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7481 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7477 if (obj) {
7482 if (obj) {
7478 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
7483 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
7479 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7484 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7480 void* args[2] = {NULL, (void*)&arg__1};
7485 void* args[2] = {NULL, (void*)&arg__1};
7481 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7486 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7482 if (result) { Py_DECREF(result); }
7487 if (result) { Py_DECREF(result); }
7483 Py_DECREF(obj);
7488 Py_DECREF(obj);
7484 return;
7489 return;
7485 } else {
7490 } else {
7486 PyErr_Clear();
7491 PyErr_Clear();
7487 }
7492 }
7488 }
7493 }
7489 elfInfoWdgt::inputMethodEvent(arg__1);
7494 elfInfoWdgt::inputMethodEvent(arg__1);
7490 }
7495 }
7491 QVariant PythonQtShell_elfInfoWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
7496 QVariant PythonQtShell_elfInfoWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
7492 {
7497 {
7493 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7498 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7494 static PyObject* name = PyString_FromString("inputMethodQuery");
7499 static PyObject* name = PyString_FromString("inputMethodQuery");
7495 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7500 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7496 if (obj) {
7501 if (obj) {
7497 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
7502 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
7498 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7503 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7499 QVariant returnValue;
7504 QVariant returnValue;
7500 void* args[2] = {NULL, (void*)&arg__1};
7505 void* args[2] = {NULL, (void*)&arg__1};
7501 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7506 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7502 if (result) {
7507 if (result) {
7503 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7508 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7504 if (args[0]!=&returnValue) {
7509 if (args[0]!=&returnValue) {
7505 if (args[0]==NULL) {
7510 if (args[0]==NULL) {
7506 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
7511 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
7507 } else {
7512 } else {
7508 returnValue = *((QVariant*)args[0]);
7513 returnValue = *((QVariant*)args[0]);
7509 }
7514 }
7510 }
7515 }
7511 }
7516 }
7512 if (result) { Py_DECREF(result); }
7517 if (result) { Py_DECREF(result); }
7513 Py_DECREF(obj);
7518 Py_DECREF(obj);
7514 return returnValue;
7519 return returnValue;
7515 } else {
7520 } else {
7516 PyErr_Clear();
7521 PyErr_Clear();
7517 }
7522 }
7518 }
7523 }
7519 return elfInfoWdgt::inputMethodQuery(arg__1);
7524 return elfInfoWdgt::inputMethodQuery(arg__1);
7520 }
7525 }
7521 void PythonQtShell_elfInfoWdgt::keyPressEvent(QKeyEvent* arg__1)
7526 void PythonQtShell_elfInfoWdgt::keyPressEvent(QKeyEvent* arg__1)
7522 {
7527 {
7523 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7528 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7524 static PyObject* name = PyString_FromString("keyPressEvent");
7529 static PyObject* name = PyString_FromString("keyPressEvent");
7525 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7530 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7526 if (obj) {
7531 if (obj) {
7527 static const char* argumentList[] ={"" , "QKeyEvent*"};
7532 static const char* argumentList[] ={"" , "QKeyEvent*"};
7528 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7533 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7529 void* args[2] = {NULL, (void*)&arg__1};
7534 void* args[2] = {NULL, (void*)&arg__1};
7530 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7535 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7531 if (result) { Py_DECREF(result); }
7536 if (result) { Py_DECREF(result); }
7532 Py_DECREF(obj);
7537 Py_DECREF(obj);
7533 return;
7538 return;
7534 } else {
7539 } else {
7535 PyErr_Clear();
7540 PyErr_Clear();
7536 }
7541 }
7537 }
7542 }
7538 elfInfoWdgt::keyPressEvent(arg__1);
7543 elfInfoWdgt::keyPressEvent(arg__1);
7539 }
7544 }
7540 void PythonQtShell_elfInfoWdgt::keyReleaseEvent(QKeyEvent* arg__1)
7545 void PythonQtShell_elfInfoWdgt::keyReleaseEvent(QKeyEvent* arg__1)
7541 {
7546 {
7542 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7547 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7543 static PyObject* name = PyString_FromString("keyReleaseEvent");
7548 static PyObject* name = PyString_FromString("keyReleaseEvent");
7544 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7549 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7545 if (obj) {
7550 if (obj) {
7546 static const char* argumentList[] ={"" , "QKeyEvent*"};
7551 static const char* argumentList[] ={"" , "QKeyEvent*"};
7547 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7552 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7548 void* args[2] = {NULL, (void*)&arg__1};
7553 void* args[2] = {NULL, (void*)&arg__1};
7549 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7554 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7550 if (result) { Py_DECREF(result); }
7555 if (result) { Py_DECREF(result); }
7551 Py_DECREF(obj);
7556 Py_DECREF(obj);
7552 return;
7557 return;
7553 } else {
7558 } else {
7554 PyErr_Clear();
7559 PyErr_Clear();
7555 }
7560 }
7556 }
7561 }
7557 elfInfoWdgt::keyReleaseEvent(arg__1);
7562 elfInfoWdgt::keyReleaseEvent(arg__1);
7558 }
7563 }
7559 void PythonQtShell_elfInfoWdgt::leaveEvent(QEvent* arg__1)
7564 void PythonQtShell_elfInfoWdgt::leaveEvent(QEvent* arg__1)
7560 {
7565 {
7561 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7566 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7562 static PyObject* name = PyString_FromString("leaveEvent");
7567 static PyObject* name = PyString_FromString("leaveEvent");
7563 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7568 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7564 if (obj) {
7569 if (obj) {
7565 static const char* argumentList[] ={"" , "QEvent*"};
7570 static const char* argumentList[] ={"" , "QEvent*"};
7566 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7571 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7567 void* args[2] = {NULL, (void*)&arg__1};
7572 void* args[2] = {NULL, (void*)&arg__1};
7568 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7573 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7569 if (result) { Py_DECREF(result); }
7574 if (result) { Py_DECREF(result); }
7570 Py_DECREF(obj);
7575 Py_DECREF(obj);
7571 return;
7576 return;
7572 } else {
7577 } else {
7573 PyErr_Clear();
7578 PyErr_Clear();
7574 }
7579 }
7575 }
7580 }
7576 elfInfoWdgt::leaveEvent(arg__1);
7581 elfInfoWdgt::leaveEvent(arg__1);
7577 }
7582 }
7578 int PythonQtShell_elfInfoWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
7583 int PythonQtShell_elfInfoWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
7579 {
7584 {
7580 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7585 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7581 static PyObject* name = PyString_FromString("metric");
7586 static PyObject* name = PyString_FromString("metric");
7582 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7587 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7583 if (obj) {
7588 if (obj) {
7584 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
7589 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
7585 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7590 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7586 int returnValue;
7591 int returnValue;
7587 void* args[2] = {NULL, (void*)&arg__1};
7592 void* args[2] = {NULL, (void*)&arg__1};
7588 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7593 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7589 if (result) {
7594 if (result) {
7590 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7595 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7591 if (args[0]!=&returnValue) {
7596 if (args[0]!=&returnValue) {
7592 if (args[0]==NULL) {
7597 if (args[0]==NULL) {
7593 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
7598 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
7594 } else {
7599 } else {
7595 returnValue = *((int*)args[0]);
7600 returnValue = *((int*)args[0]);
7596 }
7601 }
7597 }
7602 }
7598 }
7603 }
7599 if (result) { Py_DECREF(result); }
7604 if (result) { Py_DECREF(result); }
7600 Py_DECREF(obj);
7605 Py_DECREF(obj);
7601 return returnValue;
7606 return returnValue;
7602 } else {
7607 } else {
7603 PyErr_Clear();
7608 PyErr_Clear();
7604 }
7609 }
7605 }
7610 }
7606 return elfInfoWdgt::metric(arg__1);
7611 return elfInfoWdgt::metric(arg__1);
7607 }
7612 }
7608 QSize PythonQtShell_elfInfoWdgt::minimumSizeHint() const
7613 QSize PythonQtShell_elfInfoWdgt::minimumSizeHint() const
7609 {
7614 {
7610 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7615 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7611 static PyObject* name = PyString_FromString("getMinimumSizeHint");
7616 static PyObject* name = PyString_FromString("getMinimumSizeHint");
7612 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7617 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7613 if (obj) {
7618 if (obj) {
7614 static const char* argumentList[] ={"QSize"};
7619 static const char* argumentList[] ={"QSize"};
7615 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7620 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7616 QSize returnValue;
7621 QSize returnValue;
7617 void* args[1] = {NULL};
7622 void* args[1] = {NULL};
7618 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7623 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7619 if (result) {
7624 if (result) {
7620 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7625 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7621 if (args[0]!=&returnValue) {
7626 if (args[0]!=&returnValue) {
7622 if (args[0]==NULL) {
7627 if (args[0]==NULL) {
7623 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
7628 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
7624 } else {
7629 } else {
7625 returnValue = *((QSize*)args[0]);
7630 returnValue = *((QSize*)args[0]);
7626 }
7631 }
7627 }
7632 }
7628 }
7633 }
7629 if (result) { Py_DECREF(result); }
7634 if (result) { Py_DECREF(result); }
7630 Py_DECREF(obj);
7635 Py_DECREF(obj);
7631 return returnValue;
7636 return returnValue;
7632 } else {
7637 } else {
7633 PyErr_Clear();
7638 PyErr_Clear();
7634 }
7639 }
7635 }
7640 }
7636 return elfInfoWdgt::minimumSizeHint();
7641 return elfInfoWdgt::minimumSizeHint();
7637 }
7642 }
7638 void PythonQtShell_elfInfoWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
7643 void PythonQtShell_elfInfoWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
7639 {
7644 {
7640 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7645 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7641 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
7646 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
7642 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7647 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7643 if (obj) {
7648 if (obj) {
7644 static const char* argumentList[] ={"" , "QMouseEvent*"};
7649 static const char* argumentList[] ={"" , "QMouseEvent*"};
7645 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7650 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7646 void* args[2] = {NULL, (void*)&arg__1};
7651 void* args[2] = {NULL, (void*)&arg__1};
7647 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7652 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7648 if (result) { Py_DECREF(result); }
7653 if (result) { Py_DECREF(result); }
7649 Py_DECREF(obj);
7654 Py_DECREF(obj);
7650 return;
7655 return;
7651 } else {
7656 } else {
7652 PyErr_Clear();
7657 PyErr_Clear();
7653 }
7658 }
7654 }
7659 }
7655 elfInfoWdgt::mouseDoubleClickEvent(arg__1);
7660 elfInfoWdgt::mouseDoubleClickEvent(arg__1);
7656 }
7661 }
7657 void PythonQtShell_elfInfoWdgt::mouseMoveEvent(QMouseEvent* arg__1)
7662 void PythonQtShell_elfInfoWdgt::mouseMoveEvent(QMouseEvent* arg__1)
7658 {
7663 {
7659 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7664 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7660 static PyObject* name = PyString_FromString("mouseMoveEvent");
7665 static PyObject* name = PyString_FromString("mouseMoveEvent");
7661 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7666 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7662 if (obj) {
7667 if (obj) {
7663 static const char* argumentList[] ={"" , "QMouseEvent*"};
7668 static const char* argumentList[] ={"" , "QMouseEvent*"};
7664 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7669 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7665 void* args[2] = {NULL, (void*)&arg__1};
7670 void* args[2] = {NULL, (void*)&arg__1};
7666 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7671 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7667 if (result) { Py_DECREF(result); }
7672 if (result) { Py_DECREF(result); }
7668 Py_DECREF(obj);
7673 Py_DECREF(obj);
7669 return;
7674 return;
7670 } else {
7675 } else {
7671 PyErr_Clear();
7676 PyErr_Clear();
7672 }
7677 }
7673 }
7678 }
7674 elfInfoWdgt::mouseMoveEvent(arg__1);
7679 elfInfoWdgt::mouseMoveEvent(arg__1);
7675 }
7680 }
7676 void PythonQtShell_elfInfoWdgt::mousePressEvent(QMouseEvent* arg__1)
7681 void PythonQtShell_elfInfoWdgt::mousePressEvent(QMouseEvent* arg__1)
7677 {
7682 {
7678 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7683 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7679 static PyObject* name = PyString_FromString("mousePressEvent");
7684 static PyObject* name = PyString_FromString("mousePressEvent");
7680 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7685 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7681 if (obj) {
7686 if (obj) {
7682 static const char* argumentList[] ={"" , "QMouseEvent*"};
7687 static const char* argumentList[] ={"" , "QMouseEvent*"};
7683 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7688 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7684 void* args[2] = {NULL, (void*)&arg__1};
7689 void* args[2] = {NULL, (void*)&arg__1};
7685 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7690 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7686 if (result) { Py_DECREF(result); }
7691 if (result) { Py_DECREF(result); }
7687 Py_DECREF(obj);
7692 Py_DECREF(obj);
7688 return;
7693 return;
7689 } else {
7694 } else {
7690 PyErr_Clear();
7695 PyErr_Clear();
7691 }
7696 }
7692 }
7697 }
7693 elfInfoWdgt::mousePressEvent(arg__1);
7698 elfInfoWdgt::mousePressEvent(arg__1);
7694 }
7699 }
7695 void PythonQtShell_elfInfoWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
7700 void PythonQtShell_elfInfoWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
7696 {
7701 {
7697 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7702 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7698 static PyObject* name = PyString_FromString("mouseReleaseEvent");
7703 static PyObject* name = PyString_FromString("mouseReleaseEvent");
7699 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7704 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7700 if (obj) {
7705 if (obj) {
7701 static const char* argumentList[] ={"" , "QMouseEvent*"};
7706 static const char* argumentList[] ={"" , "QMouseEvent*"};
7702 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7707 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7703 void* args[2] = {NULL, (void*)&arg__1};
7708 void* args[2] = {NULL, (void*)&arg__1};
7704 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7709 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7705 if (result) { Py_DECREF(result); }
7710 if (result) { Py_DECREF(result); }
7706 Py_DECREF(obj);
7711 Py_DECREF(obj);
7707 return;
7712 return;
7708 } else {
7713 } else {
7709 PyErr_Clear();
7714 PyErr_Clear();
7710 }
7715 }
7711 }
7716 }
7712 elfInfoWdgt::mouseReleaseEvent(arg__1);
7717 elfInfoWdgt::mouseReleaseEvent(arg__1);
7713 }
7718 }
7714 void PythonQtShell_elfInfoWdgt::moveEvent(QMoveEvent* arg__1)
7719 void PythonQtShell_elfInfoWdgt::moveEvent(QMoveEvent* arg__1)
7715 {
7720 {
7716 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7721 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7717 static PyObject* name = PyString_FromString("moveEvent");
7722 static PyObject* name = PyString_FromString("moveEvent");
7718 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7723 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7719 if (obj) {
7724 if (obj) {
7720 static const char* argumentList[] ={"" , "QMoveEvent*"};
7725 static const char* argumentList[] ={"" , "QMoveEvent*"};
7721 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7726 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7722 void* args[2] = {NULL, (void*)&arg__1};
7727 void* args[2] = {NULL, (void*)&arg__1};
7723 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7728 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7724 if (result) { Py_DECREF(result); }
7729 if (result) { Py_DECREF(result); }
7725 Py_DECREF(obj);
7730 Py_DECREF(obj);
7726 return;
7731 return;
7727 } else {
7732 } else {
7728 PyErr_Clear();
7733 PyErr_Clear();
7729 }
7734 }
7730 }
7735 }
7731 elfInfoWdgt::moveEvent(arg__1);
7736 elfInfoWdgt::moveEvent(arg__1);
7732 }
7737 }
7733 bool PythonQtShell_elfInfoWdgt::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
7738 bool PythonQtShell_elfInfoWdgt::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
7734 {
7739 {
7735 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7740 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7736 static PyObject* name = PyString_FromString("nativeEvent");
7741 static PyObject* name = PyString_FromString("nativeEvent");
7737 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7742 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7738 if (obj) {
7743 if (obj) {
7739 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
7744 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
7740 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
7745 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
7741 bool returnValue;
7746 bool returnValue;
7742 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
7747 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
7743 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7748 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7744 if (result) {
7749 if (result) {
7745 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7750 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7746 if (args[0]!=&returnValue) {
7751 if (args[0]!=&returnValue) {
7747 if (args[0]==NULL) {
7752 if (args[0]==NULL) {
7748 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
7753 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
7749 } else {
7754 } else {
7750 returnValue = *((bool*)args[0]);
7755 returnValue = *((bool*)args[0]);
7751 }
7756 }
7752 }
7757 }
7753 }
7758 }
7754 if (result) { Py_DECREF(result); }
7759 if (result) { Py_DECREF(result); }
7755 Py_DECREF(obj);
7760 Py_DECREF(obj);
7756 return returnValue;
7761 return returnValue;
7757 } else {
7762 } else {
7758 PyErr_Clear();
7763 PyErr_Clear();
7759 }
7764 }
7760 }
7765 }
7761 return elfInfoWdgt::nativeEvent(eventType0, message1, result2);
7766 return elfInfoWdgt::nativeEvent(eventType0, message1, result2);
7762 }
7767 }
7763 QPaintEngine* PythonQtShell_elfInfoWdgt::paintEngine() const
7768 QPaintEngine* PythonQtShell_elfInfoWdgt::paintEngine() const
7764 {
7769 {
7765 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7770 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7766 static PyObject* name = PyString_FromString("paintEngine");
7771 static PyObject* name = PyString_FromString("paintEngine");
7767 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7772 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7768 if (obj) {
7773 if (obj) {
7769 static const char* argumentList[] ={"QPaintEngine*"};
7774 static const char* argumentList[] ={"QPaintEngine*"};
7770 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7775 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7771 QPaintEngine* returnValue;
7776 QPaintEngine* returnValue;
7772 void* args[1] = {NULL};
7777 void* args[1] = {NULL};
7773 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7778 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7774 if (result) {
7779 if (result) {
7775 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7780 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7776 if (args[0]!=&returnValue) {
7781 if (args[0]!=&returnValue) {
7777 if (args[0]==NULL) {
7782 if (args[0]==NULL) {
7778 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
7783 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
7779 } else {
7784 } else {
7780 returnValue = *((QPaintEngine**)args[0]);
7785 returnValue = *((QPaintEngine**)args[0]);
7781 }
7786 }
7782 }
7787 }
7783 }
7788 }
7784 if (result) { Py_DECREF(result); }
7789 if (result) { Py_DECREF(result); }
7785 Py_DECREF(obj);
7790 Py_DECREF(obj);
7786 return returnValue;
7791 return returnValue;
7787 } else {
7792 } else {
7788 PyErr_Clear();
7793 PyErr_Clear();
7789 }
7794 }
7790 }
7795 }
7791 return elfInfoWdgt::paintEngine();
7796 return elfInfoWdgt::paintEngine();
7792 }
7797 }
7793 void PythonQtShell_elfInfoWdgt::paintEvent(QPaintEvent* arg__1)
7798 void PythonQtShell_elfInfoWdgt::paintEvent(QPaintEvent* arg__1)
7794 {
7799 {
7795 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7800 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7796 static PyObject* name = PyString_FromString("paintEvent");
7801 static PyObject* name = PyString_FromString("paintEvent");
7797 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7802 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7798 if (obj) {
7803 if (obj) {
7799 static const char* argumentList[] ={"" , "QPaintEvent*"};
7804 static const char* argumentList[] ={"" , "QPaintEvent*"};
7800 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7805 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7801 void* args[2] = {NULL, (void*)&arg__1};
7806 void* args[2] = {NULL, (void*)&arg__1};
7802 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7807 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7803 if (result) { Py_DECREF(result); }
7808 if (result) { Py_DECREF(result); }
7804 Py_DECREF(obj);
7809 Py_DECREF(obj);
7805 return;
7810 return;
7806 } else {
7811 } else {
7807 PyErr_Clear();
7812 PyErr_Clear();
7808 }
7813 }
7809 }
7814 }
7810 elfInfoWdgt::paintEvent(arg__1);
7815 elfInfoWdgt::paintEvent(arg__1);
7811 }
7816 }
7812 QPaintDevice* PythonQtShell_elfInfoWdgt::redirected(QPoint* offset0) const
7817 QPaintDevice* PythonQtShell_elfInfoWdgt::redirected(QPoint* offset0) const
7813 {
7818 {
7814 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7819 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7815 static PyObject* name = PyString_FromString("redirected");
7820 static PyObject* name = PyString_FromString("redirected");
7816 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7821 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7817 if (obj) {
7822 if (obj) {
7818 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
7823 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
7819 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7824 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7820 QPaintDevice* returnValue;
7825 QPaintDevice* returnValue;
7821 void* args[2] = {NULL, (void*)&offset0};
7826 void* args[2] = {NULL, (void*)&offset0};
7822 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7827 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7823 if (result) {
7828 if (result) {
7824 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7829 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7825 if (args[0]!=&returnValue) {
7830 if (args[0]!=&returnValue) {
7826 if (args[0]==NULL) {
7831 if (args[0]==NULL) {
7827 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
7832 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
7828 } else {
7833 } else {
7829 returnValue = *((QPaintDevice**)args[0]);
7834 returnValue = *((QPaintDevice**)args[0]);
7830 }
7835 }
7831 }
7836 }
7832 }
7837 }
7833 if (result) { Py_DECREF(result); }
7838 if (result) { Py_DECREF(result); }
7834 Py_DECREF(obj);
7839 Py_DECREF(obj);
7835 return returnValue;
7840 return returnValue;
7836 } else {
7841 } else {
7837 PyErr_Clear();
7842 PyErr_Clear();
7838 }
7843 }
7839 }
7844 }
7840 return elfInfoWdgt::redirected(offset0);
7845 return elfInfoWdgt::redirected(offset0);
7841 }
7846 }
7842 void PythonQtShell_elfInfoWdgt::resizeEvent(QResizeEvent* arg__1)
7847 void PythonQtShell_elfInfoWdgt::resizeEvent(QResizeEvent* arg__1)
7843 {
7848 {
7844 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7849 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7845 static PyObject* name = PyString_FromString("resizeEvent");
7850 static PyObject* name = PyString_FromString("resizeEvent");
7846 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7851 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7847 if (obj) {
7852 if (obj) {
7848 static const char* argumentList[] ={"" , "QResizeEvent*"};
7853 static const char* argumentList[] ={"" , "QResizeEvent*"};
7849 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7854 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7850 void* args[2] = {NULL, (void*)&arg__1};
7855 void* args[2] = {NULL, (void*)&arg__1};
7851 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7856 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7852 if (result) { Py_DECREF(result); }
7857 if (result) { Py_DECREF(result); }
7853 Py_DECREF(obj);
7858 Py_DECREF(obj);
7854 return;
7859 return;
7855 } else {
7860 } else {
7856 PyErr_Clear();
7861 PyErr_Clear();
7857 }
7862 }
7858 }
7863 }
7859 elfInfoWdgt::resizeEvent(arg__1);
7864 elfInfoWdgt::resizeEvent(arg__1);
7860 }
7865 }
7861 QPainter* PythonQtShell_elfInfoWdgt::sharedPainter() const
7866 QPainter* PythonQtShell_elfInfoWdgt::sharedPainter() const
7862 {
7867 {
7863 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7868 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7864 static PyObject* name = PyString_FromString("sharedPainter");
7869 static PyObject* name = PyString_FromString("sharedPainter");
7865 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7870 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7866 if (obj) {
7871 if (obj) {
7867 static const char* argumentList[] ={"QPainter*"};
7872 static const char* argumentList[] ={"QPainter*"};
7868 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7873 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7869 QPainter* returnValue;
7874 QPainter* returnValue;
7870 void* args[1] = {NULL};
7875 void* args[1] = {NULL};
7871 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7876 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7872 if (result) {
7877 if (result) {
7873 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7878 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7874 if (args[0]!=&returnValue) {
7879 if (args[0]!=&returnValue) {
7875 if (args[0]==NULL) {
7880 if (args[0]==NULL) {
7876 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
7881 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
7877 } else {
7882 } else {
7878 returnValue = *((QPainter**)args[0]);
7883 returnValue = *((QPainter**)args[0]);
7879 }
7884 }
7880 }
7885 }
7881 }
7886 }
7882 if (result) { Py_DECREF(result); }
7887 if (result) { Py_DECREF(result); }
7883 Py_DECREF(obj);
7888 Py_DECREF(obj);
7884 return returnValue;
7889 return returnValue;
7885 } else {
7890 } else {
7886 PyErr_Clear();
7891 PyErr_Clear();
7887 }
7892 }
7888 }
7893 }
7889 return elfInfoWdgt::sharedPainter();
7894 return elfInfoWdgt::sharedPainter();
7890 }
7895 }
7891 void PythonQtShell_elfInfoWdgt::showEvent(QShowEvent* arg__1)
7896 void PythonQtShell_elfInfoWdgt::showEvent(QShowEvent* arg__1)
7892 {
7897 {
7893 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7898 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7894 static PyObject* name = PyString_FromString("showEvent");
7899 static PyObject* name = PyString_FromString("showEvent");
7895 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7900 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7896 if (obj) {
7901 if (obj) {
7897 static const char* argumentList[] ={"" , "QShowEvent*"};
7902 static const char* argumentList[] ={"" , "QShowEvent*"};
7898 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7903 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7899 void* args[2] = {NULL, (void*)&arg__1};
7904 void* args[2] = {NULL, (void*)&arg__1};
7900 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7905 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7901 if (result) { Py_DECREF(result); }
7906 if (result) { Py_DECREF(result); }
7902 Py_DECREF(obj);
7907 Py_DECREF(obj);
7903 return;
7908 return;
7904 } else {
7909 } else {
7905 PyErr_Clear();
7910 PyErr_Clear();
7906 }
7911 }
7907 }
7912 }
7908 elfInfoWdgt::showEvent(arg__1);
7913 elfInfoWdgt::showEvent(arg__1);
7909 }
7914 }
7910 QSize PythonQtShell_elfInfoWdgt::sizeHint() const
7915 QSize PythonQtShell_elfInfoWdgt::sizeHint() const
7911 {
7916 {
7912 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7917 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7913 static PyObject* name = PyString_FromString("getSizeHint");
7918 static PyObject* name = PyString_FromString("getSizeHint");
7914 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7919 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7915 if (obj) {
7920 if (obj) {
7916 static const char* argumentList[] ={"QSize"};
7921 static const char* argumentList[] ={"QSize"};
7917 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7922 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7918 QSize returnValue;
7923 QSize returnValue;
7919 void* args[1] = {NULL};
7924 void* args[1] = {NULL};
7920 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7925 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7921 if (result) {
7926 if (result) {
7922 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7927 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7923 if (args[0]!=&returnValue) {
7928 if (args[0]!=&returnValue) {
7924 if (args[0]==NULL) {
7929 if (args[0]==NULL) {
7925 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
7930 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
7926 } else {
7931 } else {
7927 returnValue = *((QSize*)args[0]);
7932 returnValue = *((QSize*)args[0]);
7928 }
7933 }
7929 }
7934 }
7930 }
7935 }
7931 if (result) { Py_DECREF(result); }
7936 if (result) { Py_DECREF(result); }
7932 Py_DECREF(obj);
7937 Py_DECREF(obj);
7933 return returnValue;
7938 return returnValue;
7934 } else {
7939 } else {
7935 PyErr_Clear();
7940 PyErr_Clear();
7936 }
7941 }
7937 }
7942 }
7938 return elfInfoWdgt::sizeHint();
7943 return elfInfoWdgt::sizeHint();
7939 }
7944 }
7940 void PythonQtShell_elfInfoWdgt::tabletEvent(QTabletEvent* arg__1)
7945 void PythonQtShell_elfInfoWdgt::tabletEvent(QTabletEvent* arg__1)
7941 {
7946 {
7942 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7947 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7943 static PyObject* name = PyString_FromString("tabletEvent");
7948 static PyObject* name = PyString_FromString("tabletEvent");
7944 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7949 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7945 if (obj) {
7950 if (obj) {
7946 static const char* argumentList[] ={"" , "QTabletEvent*"};
7951 static const char* argumentList[] ={"" , "QTabletEvent*"};
7947 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7952 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7948 void* args[2] = {NULL, (void*)&arg__1};
7953 void* args[2] = {NULL, (void*)&arg__1};
7949 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7954 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7950 if (result) { Py_DECREF(result); }
7955 if (result) { Py_DECREF(result); }
7951 Py_DECREF(obj);
7956 Py_DECREF(obj);
7952 return;
7957 return;
7953 } else {
7958 } else {
7954 PyErr_Clear();
7959 PyErr_Clear();
7955 }
7960 }
7956 }
7961 }
7957 elfInfoWdgt::tabletEvent(arg__1);
7962 elfInfoWdgt::tabletEvent(arg__1);
7958 }
7963 }
7959 void PythonQtShell_elfInfoWdgt::timerEvent(QTimerEvent* arg__1)
7964 void PythonQtShell_elfInfoWdgt::timerEvent(QTimerEvent* arg__1)
7960 {
7965 {
7961 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7966 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7962 static PyObject* name = PyString_FromString("timerEvent");
7967 static PyObject* name = PyString_FromString("timerEvent");
7963 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7968 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7964 if (obj) {
7969 if (obj) {
7965 static const char* argumentList[] ={"" , "QTimerEvent*"};
7970 static const char* argumentList[] ={"" , "QTimerEvent*"};
7966 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7971 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7967 void* args[2] = {NULL, (void*)&arg__1};
7972 void* args[2] = {NULL, (void*)&arg__1};
7968 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7973 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7969 if (result) { Py_DECREF(result); }
7974 if (result) { Py_DECREF(result); }
7970 Py_DECREF(obj);
7975 Py_DECREF(obj);
7971 return;
7976 return;
7972 } else {
7977 } else {
7973 PyErr_Clear();
7978 PyErr_Clear();
7974 }
7979 }
7975 }
7980 }
7976 elfInfoWdgt::timerEvent(arg__1);
7981 elfInfoWdgt::timerEvent(arg__1);
7977 }
7982 }
7978 void PythonQtShell_elfInfoWdgt::wheelEvent(QWheelEvent* arg__1)
7983 void PythonQtShell_elfInfoWdgt::wheelEvent(QWheelEvent* arg__1)
7979 {
7984 {
7980 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7985 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
7981 static PyObject* name = PyString_FromString("wheelEvent");
7986 static PyObject* name = PyString_FromString("wheelEvent");
7982 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7987 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
7983 if (obj) {
7988 if (obj) {
7984 static const char* argumentList[] ={"" , "QWheelEvent*"};
7989 static const char* argumentList[] ={"" , "QWheelEvent*"};
7985 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7990 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7986 void* args[2] = {NULL, (void*)&arg__1};
7991 void* args[2] = {NULL, (void*)&arg__1};
7987 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7992 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7988 if (result) { Py_DECREF(result); }
7993 if (result) { Py_DECREF(result); }
7989 Py_DECREF(obj);
7994 Py_DECREF(obj);
7990 return;
7995 return;
7991 } else {
7996 } else {
7992 PyErr_Clear();
7997 PyErr_Clear();
7993 }
7998 }
7994 }
7999 }
7995 elfInfoWdgt::wheelEvent(arg__1);
8000 elfInfoWdgt::wheelEvent(arg__1);
7996 }
8001 }
7997 elfInfoWdgt* PythonQtWrapper_elfInfoWdgt::new_elfInfoWdgt(QWidget* parent)
8002 elfInfoWdgt* PythonQtWrapper_elfInfoWdgt::new_elfInfoWdgt(QWidget* parent)
7998 {
8003 {
7999 return new PythonQtShell_elfInfoWdgt(parent); }
8004 return new PythonQtShell_elfInfoWdgt(parent); }
8000
8005
8001
8006
8002
8007
8003 elfparser* PythonQtWrapper_elfparser::new_elfparser()
8008 elfparser* PythonQtWrapper_elfparser::new_elfparser()
8004 {
8009 {
8005 return new elfparser(); }
8010 return new elfparser(); }
8006
8011
8007 int PythonQtWrapper_elfparser::closeFile(elfparser* theWrappedObject)
8012 int PythonQtWrapper_elfparser::closeFile(elfparser* theWrappedObject)
8008 {
8013 {
8009 return ( theWrappedObject->closeFile());
8014 return ( theWrappedObject->closeFile());
8010 }
8015 }
8011
8016
8012 QString PythonQtWrapper_elfparser::getABI(elfparser* theWrappedObject)
8017 QString PythonQtWrapper_elfparser::getABI(elfparser* theWrappedObject)
8013 {
8018 {
8014 return ( theWrappedObject->getABI());
8019 return ( theWrappedObject->getABI());
8015 }
8020 }
8016
8021
8017 QString PythonQtWrapper_elfparser::getArchitecture(elfparser* theWrappedObject)
8022 QString PythonQtWrapper_elfparser::getArchitecture(elfparser* theWrappedObject)
8018 {
8023 {
8019 return ( theWrappedObject->getArchitecture());
8024 return ( theWrappedObject->getArchitecture());
8020 }
8025 }
8021
8026
8022 QString PythonQtWrapper_elfparser::getClass(elfparser* theWrappedObject)
8027 QString PythonQtWrapper_elfparser::getClass(elfparser* theWrappedObject)
8023 {
8028 {
8024 return ( theWrappedObject->getClass());
8029 return ( theWrappedObject->getClass());
8025 }
8030 }
8026
8031
8027 QString PythonQtWrapper_elfparser::getEndianness(elfparser* theWrappedObject)
8032 QString PythonQtWrapper_elfparser::getEndianness(elfparser* theWrappedObject)
8028 {
8033 {
8029 return ( theWrappedObject->getEndianness());
8034 return ( theWrappedObject->getEndianness());
8030 }
8035 }
8031
8036
8032 qint64 PythonQtWrapper_elfparser::getEntryPointAddress(elfparser* theWrappedObject)
8037 qint64 PythonQtWrapper_elfparser::getEntryPointAddress(elfparser* theWrappedObject)
8033 {
8038 {
8034 return ( theWrappedObject->getEntryPointAddress());
8039 return ( theWrappedObject->getEntryPointAddress());
8035 }
8040 }
8036
8041
8037 bool PythonQtWrapper_elfparser::getSectionData(elfparser* theWrappedObject, int index, char** buffer)
8042 bool PythonQtWrapper_elfparser::getSectionData(elfparser* theWrappedObject, int index, char** buffer)
8038 {
8043 {
8039 return ( theWrappedObject->getSectionData(index, buffer));
8044 return ( theWrappedObject->getSectionData(index, buffer));
8040 }
8045 }
8041
8046
8042 qint64 PythonQtWrapper_elfparser::getSectionDatasz(elfparser* theWrappedObject, int index)
8047 qint64 PythonQtWrapper_elfparser::getSectionDatasz(elfparser* theWrappedObject, int index)
8043 {
8048 {
8044 return ( theWrappedObject->getSectionDatasz(index));
8049 return ( theWrappedObject->getSectionDatasz(index));
8045 }
8050 }
8046
8051
8047 qint64 PythonQtWrapper_elfparser::getSectionMemsz(elfparser* theWrappedObject, int index)
8052 qint64 PythonQtWrapper_elfparser::getSectionMemsz(elfparser* theWrappedObject, int index)
8048 {
8053 {
8049 return ( theWrappedObject->getSectionMemsz(index));
8054 return ( theWrappedObject->getSectionMemsz(index));
8050 }
8055 }
8051
8056
8052 QString PythonQtWrapper_elfparser::getSectionName(elfparser* theWrappedObject, int index)
8057 QString PythonQtWrapper_elfparser::getSectionName(elfparser* theWrappedObject, int index)
8053 {
8058 {
8054 return ( theWrappedObject->getSectionName(index));
8059 return ( theWrappedObject->getSectionName(index));
8055 }
8060 }
8056
8061
8057 qint64 PythonQtWrapper_elfparser::getSectionPaddr(elfparser* theWrappedObject, int index)
8062 qint64 PythonQtWrapper_elfparser::getSectionPaddr(elfparser* theWrappedObject, int index)
8058 {
8063 {
8059 return ( theWrappedObject->getSectionPaddr(index));
8064 return ( theWrappedObject->getSectionPaddr(index));
8060 }
8065 }
8061
8066
8062 QString PythonQtWrapper_elfparser::getSectionType(elfparser* theWrappedObject, int index)
8067 QString PythonQtWrapper_elfparser::getSectionType(elfparser* theWrappedObject, int index)
8063 {
8068 {
8064 return ( theWrappedObject->getSectionType(index));
8069 return ( theWrappedObject->getSectionType(index));
8065 }
8070 }
8066
8071
8067 int PythonQtWrapper_elfparser::getSectioncount(elfparser* theWrappedObject)
8072 int PythonQtWrapper_elfparser::getSectioncount(elfparser* theWrappedObject)
8068 {
8073 {
8069 return ( theWrappedObject->getSectioncount());
8074 return ( theWrappedObject->getSectioncount());
8070 }
8075 }
8071
8076
8072 qint64 PythonQtWrapper_elfparser::getSegmentFilesz(elfparser* theWrappedObject, int index)
8077 qint64 PythonQtWrapper_elfparser::getSegmentFilesz(elfparser* theWrappedObject, int index)
8073 {
8078 {
8074 return ( theWrappedObject->getSegmentFilesz(index));
8079 return ( theWrappedObject->getSegmentFilesz(index));
8075 }
8080 }
8076
8081
8077 QString PythonQtWrapper_elfparser::getSegmentFlags(elfparser* theWrappedObject, int index)
8082 QString PythonQtWrapper_elfparser::getSegmentFlags(elfparser* theWrappedObject, int index)
8078 {
8083 {
8079 return ( theWrappedObject->getSegmentFlags(index));
8084 return ( theWrappedObject->getSegmentFlags(index));
8080 }
8085 }
8081
8086
8082 qint64 PythonQtWrapper_elfparser::getSegmentMemsz(elfparser* theWrappedObject, int index)
8087 qint64 PythonQtWrapper_elfparser::getSegmentMemsz(elfparser* theWrappedObject, int index)
8083 {
8088 {
8084 return ( theWrappedObject->getSegmentMemsz(index));
8089 return ( theWrappedObject->getSegmentMemsz(index));
8085 }
8090 }
8086
8091
8087 qint64 PythonQtWrapper_elfparser::getSegmentOffset(elfparser* theWrappedObject, int index)
8092 qint64 PythonQtWrapper_elfparser::getSegmentOffset(elfparser* theWrappedObject, int index)
8088 {
8093 {
8089 return ( theWrappedObject->getSegmentOffset(index));
8094 return ( theWrappedObject->getSegmentOffset(index));
8090 }
8095 }
8091
8096
8092 qint64 PythonQtWrapper_elfparser::getSegmentPaddr(elfparser* theWrappedObject, int index)
8097 qint64 PythonQtWrapper_elfparser::getSegmentPaddr(elfparser* theWrappedObject, int index)
8093 {
8098 {
8094 return ( theWrappedObject->getSegmentPaddr(index));
8099 return ( theWrappedObject->getSegmentPaddr(index));
8095 }
8100 }
8096
8101
8097 QString PythonQtWrapper_elfparser::getSegmentType(elfparser* theWrappedObject, int index)
8102 QString PythonQtWrapper_elfparser::getSegmentType(elfparser* theWrappedObject, int index)
8098 {
8103 {
8099 return ( theWrappedObject->getSegmentType(index));
8104 return ( theWrappedObject->getSegmentType(index));
8100 }
8105 }
8101
8106
8102 qint64 PythonQtWrapper_elfparser::getSegmentVaddr(elfparser* theWrappedObject, int index)
8107 qint64 PythonQtWrapper_elfparser::getSegmentVaddr(elfparser* theWrappedObject, int index)
8103 {
8108 {
8104 return ( theWrappedObject->getSegmentVaddr(index));
8109 return ( theWrappedObject->getSegmentVaddr(index));
8105 }
8110 }
8106
8111
8107 int PythonQtWrapper_elfparser::getSegmentcount(elfparser* theWrappedObject)
8112 int PythonQtWrapper_elfparser::getSegmentcount(elfparser* theWrappedObject)
8108 {
8113 {
8109 return ( theWrappedObject->getSegmentcount());
8114 return ( theWrappedObject->getSegmentcount());
8110 }
8115 }
8111
8116
8112 QString PythonQtWrapper_elfparser::getType(elfparser* theWrappedObject)
8117 QString PythonQtWrapper_elfparser::getType(elfparser* theWrappedObject)
8113 {
8118 {
8114 return ( theWrappedObject->getType());
8119 return ( theWrappedObject->getType());
8115 }
8120 }
8116
8121
8117 qint64 PythonQtWrapper_elfparser::getVersion(elfparser* theWrappedObject)
8122 qint64 PythonQtWrapper_elfparser::getVersion(elfparser* theWrappedObject)
8118 {
8123 {
8119 return ( theWrappedObject->getVersion());
8124 return ( theWrappedObject->getVersion());
8120 }
8125 }
8121
8126
8122 bool PythonQtWrapper_elfparser::static_elfparser_isElf(const QString& File)
8127 bool PythonQtWrapper_elfparser::static_elfparser_isElf(const QString& File)
8123 {
8128 {
8124 return (elfparser::isElf(File));
8129 return (elfparser::isElf(File));
8125 }
8130 }
8126
8131
8127 bool PythonQtWrapper_elfparser::iself(elfparser* theWrappedObject)
8132 bool PythonQtWrapper_elfparser::iself(elfparser* theWrappedObject)
8128 {
8133 {
8129 return ( theWrappedObject->iself());
8134 return ( theWrappedObject->iself());
8130 }
8135 }
8131
8136
8132 bool PythonQtWrapper_elfparser::isopened(elfparser* theWrappedObject)
8137 bool PythonQtWrapper_elfparser::isopened(elfparser* theWrappedObject)
8133 {
8138 {
8134 return ( theWrappedObject->isopened());
8139 return ( theWrappedObject->isopened());
8135 }
8140 }
8136
8141
8137 int PythonQtWrapper_elfparser::setFilename(elfparser* theWrappedObject, const QString& name)
8142 int PythonQtWrapper_elfparser::setFilename(elfparser* theWrappedObject, const QString& name)
8138 {
8143 {
8139 return ( theWrappedObject->setFilename(name));
8144 return ( theWrappedObject->setFilename(name));
8140 }
8145 }
8141
8146
8142
8147
8143
8148
8144 PythonQtShell_genericBinaryFileWidget::~PythonQtShell_genericBinaryFileWidget() {
8149 PythonQtShell_genericBinaryFileWidget::~PythonQtShell_genericBinaryFileWidget() {
8145 PythonQtPrivate* priv = PythonQt::priv();
8150 PythonQtPrivate* priv = PythonQt::priv();
8146 if (priv) { priv->shellClassDeleted(this); }
8151 if (priv) { priv->shellClassDeleted(this); }
8147 }
8152 }
8148 void PythonQtShell_genericBinaryFileWidget::actionEvent(QActionEvent* arg__1)
8153 void PythonQtShell_genericBinaryFileWidget::actionEvent(QActionEvent* arg__1)
8149 {
8154 {
8150 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8155 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8151 static PyObject* name = PyString_FromString("actionEvent");
8156 static PyObject* name = PyString_FromString("actionEvent");
8152 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8157 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8153 if (obj) {
8158 if (obj) {
8154 static const char* argumentList[] ={"" , "QActionEvent*"};
8159 static const char* argumentList[] ={"" , "QActionEvent*"};
8155 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8160 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8156 void* args[2] = {NULL, (void*)&arg__1};
8161 void* args[2] = {NULL, (void*)&arg__1};
8157 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8162 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8158 if (result) { Py_DECREF(result); }
8163 if (result) { Py_DECREF(result); }
8159 Py_DECREF(obj);
8164 Py_DECREF(obj);
8160 return;
8165 return;
8161 } else {
8166 } else {
8162 PyErr_Clear();
8167 PyErr_Clear();
8163 }
8168 }
8164 }
8169 }
8165 genericBinaryFileWidget::actionEvent(arg__1);
8170 genericBinaryFileWidget::actionEvent(arg__1);
8166 }
8171 }
8167 void PythonQtShell_genericBinaryFileWidget::changeEvent(QEvent* arg__1)
8172 void PythonQtShell_genericBinaryFileWidget::changeEvent(QEvent* arg__1)
8168 {
8173 {
8169 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8174 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8170 static PyObject* name = PyString_FromString("changeEvent");
8175 static PyObject* name = PyString_FromString("changeEvent");
8171 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8176 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8172 if (obj) {
8177 if (obj) {
8173 static const char* argumentList[] ={"" , "QEvent*"};
8178 static const char* argumentList[] ={"" , "QEvent*"};
8174 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8179 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8175 void* args[2] = {NULL, (void*)&arg__1};
8180 void* args[2] = {NULL, (void*)&arg__1};
8176 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8181 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8177 if (result) { Py_DECREF(result); }
8182 if (result) { Py_DECREF(result); }
8178 Py_DECREF(obj);
8183 Py_DECREF(obj);
8179 return;
8184 return;
8180 } else {
8185 } else {
8181 PyErr_Clear();
8186 PyErr_Clear();
8182 }
8187 }
8183 }
8188 }
8184 genericBinaryFileWidget::changeEvent(arg__1);
8189 genericBinaryFileWidget::changeEvent(arg__1);
8185 }
8190 }
8186 void PythonQtShell_genericBinaryFileWidget::childEvent(QChildEvent* arg__1)
8191 void PythonQtShell_genericBinaryFileWidget::childEvent(QChildEvent* arg__1)
8187 {
8192 {
8188 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8193 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8189 static PyObject* name = PyString_FromString("childEvent");
8194 static PyObject* name = PyString_FromString("childEvent");
8190 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8195 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8191 if (obj) {
8196 if (obj) {
8192 static const char* argumentList[] ={"" , "QChildEvent*"};
8197 static const char* argumentList[] ={"" , "QChildEvent*"};
8193 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8198 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8194 void* args[2] = {NULL, (void*)&arg__1};
8199 void* args[2] = {NULL, (void*)&arg__1};
8195 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8200 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8196 if (result) { Py_DECREF(result); }
8201 if (result) { Py_DECREF(result); }
8197 Py_DECREF(obj);
8202 Py_DECREF(obj);
8198 return;
8203 return;
8199 } else {
8204 } else {
8200 PyErr_Clear();
8205 PyErr_Clear();
8201 }
8206 }
8202 }
8207 }
8203 genericBinaryFileWidget::childEvent(arg__1);
8208 genericBinaryFileWidget::childEvent(arg__1);
8204 }
8209 }
8205 void PythonQtShell_genericBinaryFileWidget::closeEvent(QCloseEvent* arg__1)
8210 void PythonQtShell_genericBinaryFileWidget::closeEvent(QCloseEvent* arg__1)
8206 {
8211 {
8207 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8212 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8208 static PyObject* name = PyString_FromString("closeEvent");
8213 static PyObject* name = PyString_FromString("closeEvent");
8209 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8214 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8210 if (obj) {
8215 if (obj) {
8211 static const char* argumentList[] ={"" , "QCloseEvent*"};
8216 static const char* argumentList[] ={"" , "QCloseEvent*"};
8212 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8217 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8213 void* args[2] = {NULL, (void*)&arg__1};
8218 void* args[2] = {NULL, (void*)&arg__1};
8214 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8219 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8215 if (result) { Py_DECREF(result); }
8220 if (result) { Py_DECREF(result); }
8216 Py_DECREF(obj);
8221 Py_DECREF(obj);
8217 return;
8222 return;
8218 } else {
8223 } else {
8219 PyErr_Clear();
8224 PyErr_Clear();
8220 }
8225 }
8221 }
8226 }
8222 genericBinaryFileWidget::closeEvent(arg__1);
8227 genericBinaryFileWidget::closeEvent(arg__1);
8223 }
8228 }
8224 void PythonQtShell_genericBinaryFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
8229 void PythonQtShell_genericBinaryFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
8225 {
8230 {
8226 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8231 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8227 static PyObject* name = PyString_FromString("contextMenuEvent");
8232 static PyObject* name = PyString_FromString("contextMenuEvent");
8228 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8233 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8229 if (obj) {
8234 if (obj) {
8230 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
8235 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
8231 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8236 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8232 void* args[2] = {NULL, (void*)&arg__1};
8237 void* args[2] = {NULL, (void*)&arg__1};
8233 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8238 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8234 if (result) { Py_DECREF(result); }
8239 if (result) { Py_DECREF(result); }
8235 Py_DECREF(obj);
8240 Py_DECREF(obj);
8236 return;
8241 return;
8237 } else {
8242 } else {
8238 PyErr_Clear();
8243 PyErr_Clear();
8239 }
8244 }
8240 }
8245 }
8241 genericBinaryFileWidget::contextMenuEvent(arg__1);
8246 genericBinaryFileWidget::contextMenuEvent(arg__1);
8242 }
8247 }
8243 void PythonQtShell_genericBinaryFileWidget::customEvent(QEvent* arg__1)
8248 void PythonQtShell_genericBinaryFileWidget::customEvent(QEvent* arg__1)
8244 {
8249 {
8245 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8250 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8246 static PyObject* name = PyString_FromString("customEvent");
8251 static PyObject* name = PyString_FromString("customEvent");
8247 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8252 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8248 if (obj) {
8253 if (obj) {
8249 static const char* argumentList[] ={"" , "QEvent*"};
8254 static const char* argumentList[] ={"" , "QEvent*"};
8250 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8255 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8251 void* args[2] = {NULL, (void*)&arg__1};
8256 void* args[2] = {NULL, (void*)&arg__1};
8252 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8257 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8253 if (result) { Py_DECREF(result); }
8258 if (result) { Py_DECREF(result); }
8254 Py_DECREF(obj);
8259 Py_DECREF(obj);
8255 return;
8260 return;
8256 } else {
8261 } else {
8257 PyErr_Clear();
8262 PyErr_Clear();
8258 }
8263 }
8259 }
8264 }
8260 genericBinaryFileWidget::customEvent(arg__1);
8265 genericBinaryFileWidget::customEvent(arg__1);
8261 }
8266 }
8262 int PythonQtShell_genericBinaryFileWidget::devType() const
8267 int PythonQtShell_genericBinaryFileWidget::devType() const
8263 {
8268 {
8264 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8269 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8265 static PyObject* name = PyString_FromString("devType");
8270 static PyObject* name = PyString_FromString("devType");
8266 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8271 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8267 if (obj) {
8272 if (obj) {
8268 static const char* argumentList[] ={"int"};
8273 static const char* argumentList[] ={"int"};
8269 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8274 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8270 int returnValue;
8275 int returnValue;
8271 void* args[1] = {NULL};
8276 void* args[1] = {NULL};
8272 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8277 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8273 if (result) {
8278 if (result) {
8274 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8279 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8275 if (args[0]!=&returnValue) {
8280 if (args[0]!=&returnValue) {
8276 if (args[0]==NULL) {
8281 if (args[0]==NULL) {
8277 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
8282 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
8278 } else {
8283 } else {
8279 returnValue = *((int*)args[0]);
8284 returnValue = *((int*)args[0]);
8280 }
8285 }
8281 }
8286 }
8282 }
8287 }
8283 if (result) { Py_DECREF(result); }
8288 if (result) { Py_DECREF(result); }
8284 Py_DECREF(obj);
8289 Py_DECREF(obj);
8285 return returnValue;
8290 return returnValue;
8286 } else {
8291 } else {
8287 PyErr_Clear();
8292 PyErr_Clear();
8288 }
8293 }
8289 }
8294 }
8290 return genericBinaryFileWidget::devType();
8295 return genericBinaryFileWidget::devType();
8291 }
8296 }
8292 void PythonQtShell_genericBinaryFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
8297 void PythonQtShell_genericBinaryFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
8293 {
8298 {
8294 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8299 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8295 static PyObject* name = PyString_FromString("dragEnterEvent");
8300 static PyObject* name = PyString_FromString("dragEnterEvent");
8296 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8301 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8297 if (obj) {
8302 if (obj) {
8298 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
8303 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
8299 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8304 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8300 void* args[2] = {NULL, (void*)&arg__1};
8305 void* args[2] = {NULL, (void*)&arg__1};
8301 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8306 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8302 if (result) { Py_DECREF(result); }
8307 if (result) { Py_DECREF(result); }
8303 Py_DECREF(obj);
8308 Py_DECREF(obj);
8304 return;
8309 return;
8305 } else {
8310 } else {
8306 PyErr_Clear();
8311 PyErr_Clear();
8307 }
8312 }
8308 }
8313 }
8309 genericBinaryFileWidget::dragEnterEvent(arg__1);
8314 genericBinaryFileWidget::dragEnterEvent(arg__1);
8310 }
8315 }
8311 void PythonQtShell_genericBinaryFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
8316 void PythonQtShell_genericBinaryFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
8312 {
8317 {
8313 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8318 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8314 static PyObject* name = PyString_FromString("dragLeaveEvent");
8319 static PyObject* name = PyString_FromString("dragLeaveEvent");
8315 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8320 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8316 if (obj) {
8321 if (obj) {
8317 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
8322 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
8318 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8323 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8319 void* args[2] = {NULL, (void*)&arg__1};
8324 void* args[2] = {NULL, (void*)&arg__1};
8320 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8325 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8321 if (result) { Py_DECREF(result); }
8326 if (result) { Py_DECREF(result); }
8322 Py_DECREF(obj);
8327 Py_DECREF(obj);
8323 return;
8328 return;
8324 } else {
8329 } else {
8325 PyErr_Clear();
8330 PyErr_Clear();
8326 }
8331 }
8327 }
8332 }
8328 genericBinaryFileWidget::dragLeaveEvent(arg__1);
8333 genericBinaryFileWidget::dragLeaveEvent(arg__1);
8329 }
8334 }
8330 void PythonQtShell_genericBinaryFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
8335 void PythonQtShell_genericBinaryFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
8331 {
8336 {
8332 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8337 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8333 static PyObject* name = PyString_FromString("dragMoveEvent");
8338 static PyObject* name = PyString_FromString("dragMoveEvent");
8334 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8339 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8335 if (obj) {
8340 if (obj) {
8336 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
8341 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
8337 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8342 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8338 void* args[2] = {NULL, (void*)&arg__1};
8343 void* args[2] = {NULL, (void*)&arg__1};
8339 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8344 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8340 if (result) { Py_DECREF(result); }
8345 if (result) { Py_DECREF(result); }
8341 Py_DECREF(obj);
8346 Py_DECREF(obj);
8342 return;
8347 return;
8343 } else {
8348 } else {
8344 PyErr_Clear();
8349 PyErr_Clear();
8345 }
8350 }
8346 }
8351 }
8347 genericBinaryFileWidget::dragMoveEvent(arg__1);
8352 genericBinaryFileWidget::dragMoveEvent(arg__1);
8348 }
8353 }
8349 void PythonQtShell_genericBinaryFileWidget::dropEvent(QDropEvent* arg__1)
8354 void PythonQtShell_genericBinaryFileWidget::dropEvent(QDropEvent* arg__1)
8350 {
8355 {
8351 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8356 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8352 static PyObject* name = PyString_FromString("dropEvent");
8357 static PyObject* name = PyString_FromString("dropEvent");
8353 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8358 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8354 if (obj) {
8359 if (obj) {
8355 static const char* argumentList[] ={"" , "QDropEvent*"};
8360 static const char* argumentList[] ={"" , "QDropEvent*"};
8356 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8361 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8357 void* args[2] = {NULL, (void*)&arg__1};
8362 void* args[2] = {NULL, (void*)&arg__1};
8358 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8363 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8359 if (result) { Py_DECREF(result); }
8364 if (result) { Py_DECREF(result); }
8360 Py_DECREF(obj);
8365 Py_DECREF(obj);
8361 return;
8366 return;
8362 } else {
8367 } else {
8363 PyErr_Clear();
8368 PyErr_Clear();
8364 }
8369 }
8365 }
8370 }
8366 genericBinaryFileWidget::dropEvent(arg__1);
8371 genericBinaryFileWidget::dropEvent(arg__1);
8367 }
8372 }
8368 void PythonQtShell_genericBinaryFileWidget::enterEvent(QEvent* arg__1)
8373 void PythonQtShell_genericBinaryFileWidget::enterEvent(QEvent* arg__1)
8369 {
8374 {
8370 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8375 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8371 static PyObject* name = PyString_FromString("enterEvent");
8376 static PyObject* name = PyString_FromString("enterEvent");
8372 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8377 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8373 if (obj) {
8378 if (obj) {
8374 static const char* argumentList[] ={"" , "QEvent*"};
8379 static const char* argumentList[] ={"" , "QEvent*"};
8375 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8380 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8376 void* args[2] = {NULL, (void*)&arg__1};
8381 void* args[2] = {NULL, (void*)&arg__1};
8377 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8382 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8378 if (result) { Py_DECREF(result); }
8383 if (result) { Py_DECREF(result); }
8379 Py_DECREF(obj);
8384 Py_DECREF(obj);
8380 return;
8385 return;
8381 } else {
8386 } else {
8382 PyErr_Clear();
8387 PyErr_Clear();
8383 }
8388 }
8384 }
8389 }
8385 genericBinaryFileWidget::enterEvent(arg__1);
8390 genericBinaryFileWidget::enterEvent(arg__1);
8386 }
8391 }
8387 bool PythonQtShell_genericBinaryFileWidget::event(QEvent* arg__1)
8392 bool PythonQtShell_genericBinaryFileWidget::event(QEvent* arg__1)
8388 {
8393 {
8389 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8394 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8390 static PyObject* name = PyString_FromString("event");
8395 static PyObject* name = PyString_FromString("event");
8391 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8396 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8392 if (obj) {
8397 if (obj) {
8393 static const char* argumentList[] ={"bool" , "QEvent*"};
8398 static const char* argumentList[] ={"bool" , "QEvent*"};
8394 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8399 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8395 bool returnValue;
8400 bool returnValue;
8396 void* args[2] = {NULL, (void*)&arg__1};
8401 void* args[2] = {NULL, (void*)&arg__1};
8397 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8402 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8398 if (result) {
8403 if (result) {
8399 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8404 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8400 if (args[0]!=&returnValue) {
8405 if (args[0]!=&returnValue) {
8401 if (args[0]==NULL) {
8406 if (args[0]==NULL) {
8402 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
8407 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
8403 } else {
8408 } else {
8404 returnValue = *((bool*)args[0]);
8409 returnValue = *((bool*)args[0]);
8405 }
8410 }
8406 }
8411 }
8407 }
8412 }
8408 if (result) { Py_DECREF(result); }
8413 if (result) { Py_DECREF(result); }
8409 Py_DECREF(obj);
8414 Py_DECREF(obj);
8410 return returnValue;
8415 return returnValue;
8411 } else {
8416 } else {
8412 PyErr_Clear();
8417 PyErr_Clear();
8413 }
8418 }
8414 }
8419 }
8415 return genericBinaryFileWidget::event(arg__1);
8420 return genericBinaryFileWidget::event(arg__1);
8416 }
8421 }
8417 bool PythonQtShell_genericBinaryFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
8422 bool PythonQtShell_genericBinaryFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
8418 {
8423 {
8419 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8424 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8420 static PyObject* name = PyString_FromString("eventFilter");
8425 static PyObject* name = PyString_FromString("eventFilter");
8421 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8426 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8422 if (obj) {
8427 if (obj) {
8423 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
8428 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
8424 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
8429 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
8425 bool returnValue;
8430 bool returnValue;
8426 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
8431 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
8427 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8432 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8428 if (result) {
8433 if (result) {
8429 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8434 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8430 if (args[0]!=&returnValue) {
8435 if (args[0]!=&returnValue) {
8431 if (args[0]==NULL) {
8436 if (args[0]==NULL) {
8432 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
8437 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
8433 } else {
8438 } else {
8434 returnValue = *((bool*)args[0]);
8439 returnValue = *((bool*)args[0]);
8435 }
8440 }
8436 }
8441 }
8437 }
8442 }
8438 if (result) { Py_DECREF(result); }
8443 if (result) { Py_DECREF(result); }
8439 Py_DECREF(obj);
8444 Py_DECREF(obj);
8440 return returnValue;
8445 return returnValue;
8441 } else {
8446 } else {
8442 PyErr_Clear();
8447 PyErr_Clear();
8443 }
8448 }
8444 }
8449 }
8445 return genericBinaryFileWidget::eventFilter(arg__1, arg__2);
8450 return genericBinaryFileWidget::eventFilter(arg__1, arg__2);
8446 }
8451 }
8447 void PythonQtShell_genericBinaryFileWidget::focusInEvent(QFocusEvent* arg__1)
8452 void PythonQtShell_genericBinaryFileWidget::focusInEvent(QFocusEvent* arg__1)
8448 {
8453 {
8449 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8454 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8450 static PyObject* name = PyString_FromString("focusInEvent");
8455 static PyObject* name = PyString_FromString("focusInEvent");
8451 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8456 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8452 if (obj) {
8457 if (obj) {
8453 static const char* argumentList[] ={"" , "QFocusEvent*"};
8458 static const char* argumentList[] ={"" , "QFocusEvent*"};
8454 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8459 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8455 void* args[2] = {NULL, (void*)&arg__1};
8460 void* args[2] = {NULL, (void*)&arg__1};
8456 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8461 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8457 if (result) { Py_DECREF(result); }
8462 if (result) { Py_DECREF(result); }
8458 Py_DECREF(obj);
8463 Py_DECREF(obj);
8459 return;
8464 return;
8460 } else {
8465 } else {
8461 PyErr_Clear();
8466 PyErr_Clear();
8462 }
8467 }
8463 }
8468 }
8464 genericBinaryFileWidget::focusInEvent(arg__1);
8469 genericBinaryFileWidget::focusInEvent(arg__1);
8465 }
8470 }
8466 bool PythonQtShell_genericBinaryFileWidget::focusNextPrevChild(bool next0)
8471 bool PythonQtShell_genericBinaryFileWidget::focusNextPrevChild(bool next0)
8467 {
8472 {
8468 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8473 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8469 static PyObject* name = PyString_FromString("focusNextPrevChild");
8474 static PyObject* name = PyString_FromString("focusNextPrevChild");
8470 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8475 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8471 if (obj) {
8476 if (obj) {
8472 static const char* argumentList[] ={"bool" , "bool"};
8477 static const char* argumentList[] ={"bool" , "bool"};
8473 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8478 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8474 bool returnValue;
8479 bool returnValue;
8475 void* args[2] = {NULL, (void*)&next0};
8480 void* args[2] = {NULL, (void*)&next0};
8476 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8481 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8477 if (result) {
8482 if (result) {
8478 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8483 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8479 if (args[0]!=&returnValue) {
8484 if (args[0]!=&returnValue) {
8480 if (args[0]==NULL) {
8485 if (args[0]==NULL) {
8481 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
8486 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
8482 } else {
8487 } else {
8483 returnValue = *((bool*)args[0]);
8488 returnValue = *((bool*)args[0]);
8484 }
8489 }
8485 }
8490 }
8486 }
8491 }
8487 if (result) { Py_DECREF(result); }
8492 if (result) { Py_DECREF(result); }
8488 Py_DECREF(obj);
8493 Py_DECREF(obj);
8489 return returnValue;
8494 return returnValue;
8490 } else {
8495 } else {
8491 PyErr_Clear();
8496 PyErr_Clear();
8492 }
8497 }
8493 }
8498 }
8494 return genericBinaryFileWidget::focusNextPrevChild(next0);
8499 return genericBinaryFileWidget::focusNextPrevChild(next0);
8495 }
8500 }
8496 void PythonQtShell_genericBinaryFileWidget::focusOutEvent(QFocusEvent* arg__1)
8501 void PythonQtShell_genericBinaryFileWidget::focusOutEvent(QFocusEvent* arg__1)
8497 {
8502 {
8498 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8503 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8499 static PyObject* name = PyString_FromString("focusOutEvent");
8504 static PyObject* name = PyString_FromString("focusOutEvent");
8500 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8505 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8501 if (obj) {
8506 if (obj) {
8502 static const char* argumentList[] ={"" , "QFocusEvent*"};
8507 static const char* argumentList[] ={"" , "QFocusEvent*"};
8503 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8508 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8504 void* args[2] = {NULL, (void*)&arg__1};
8509 void* args[2] = {NULL, (void*)&arg__1};
8505 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8510 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8506 if (result) { Py_DECREF(result); }
8511 if (result) { Py_DECREF(result); }
8507 Py_DECREF(obj);
8512 Py_DECREF(obj);
8508 return;
8513 return;
8509 } else {
8514 } else {
8510 PyErr_Clear();
8515 PyErr_Clear();
8511 }
8516 }
8512 }
8517 }
8513 genericBinaryFileWidget::focusOutEvent(arg__1);
8518 genericBinaryFileWidget::focusOutEvent(arg__1);
8514 }
8519 }
8515 bool PythonQtShell_genericBinaryFileWidget::hasHeightForWidth() const
8520 bool PythonQtShell_genericBinaryFileWidget::hasHeightForWidth() const
8516 {
8521 {
8517 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8522 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8518 static PyObject* name = PyString_FromString("hasHeightForWidth");
8523 static PyObject* name = PyString_FromString("hasHeightForWidth");
8519 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8524 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8520 if (obj) {
8525 if (obj) {
8521 static const char* argumentList[] ={"bool"};
8526 static const char* argumentList[] ={"bool"};
8522 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8527 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8523 bool returnValue;
8528 bool returnValue;
8524 void* args[1] = {NULL};
8529 void* args[1] = {NULL};
8525 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8530 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8526 if (result) {
8531 if (result) {
8527 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8532 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8528 if (args[0]!=&returnValue) {
8533 if (args[0]!=&returnValue) {
8529 if (args[0]==NULL) {
8534 if (args[0]==NULL) {
8530 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
8535 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
8531 } else {
8536 } else {
8532 returnValue = *((bool*)args[0]);
8537 returnValue = *((bool*)args[0]);
8533 }
8538 }
8534 }
8539 }
8535 }
8540 }
8536 if (result) { Py_DECREF(result); }
8541 if (result) { Py_DECREF(result); }
8537 Py_DECREF(obj);
8542 Py_DECREF(obj);
8538 return returnValue;
8543 return returnValue;
8539 } else {
8544 } else {
8540 PyErr_Clear();
8545 PyErr_Clear();
8541 }
8546 }
8542 }
8547 }
8543 return genericBinaryFileWidget::hasHeightForWidth();
8548 return genericBinaryFileWidget::hasHeightForWidth();
8544 }
8549 }
8545 int PythonQtShell_genericBinaryFileWidget::heightForWidth(int arg__1) const
8550 int PythonQtShell_genericBinaryFileWidget::heightForWidth(int arg__1) const
8546 {
8551 {
8547 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8552 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8548 static PyObject* name = PyString_FromString("heightForWidth");
8553 static PyObject* name = PyString_FromString("heightForWidth");
8549 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8554 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8550 if (obj) {
8555 if (obj) {
8551 static const char* argumentList[] ={"int" , "int"};
8556 static const char* argumentList[] ={"int" , "int"};
8552 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8557 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8553 int returnValue;
8558 int returnValue;
8554 void* args[2] = {NULL, (void*)&arg__1};
8559 void* args[2] = {NULL, (void*)&arg__1};
8555 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8560 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8556 if (result) {
8561 if (result) {
8557 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8562 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8558 if (args[0]!=&returnValue) {
8563 if (args[0]!=&returnValue) {
8559 if (args[0]==NULL) {
8564 if (args[0]==NULL) {
8560 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
8565 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
8561 } else {
8566 } else {
8562 returnValue = *((int*)args[0]);
8567 returnValue = *((int*)args[0]);
8563 }
8568 }
8564 }
8569 }
8565 }
8570 }
8566 if (result) { Py_DECREF(result); }
8571 if (result) { Py_DECREF(result); }
8567 Py_DECREF(obj);
8572 Py_DECREF(obj);
8568 return returnValue;
8573 return returnValue;
8569 } else {
8574 } else {
8570 PyErr_Clear();
8575 PyErr_Clear();
8571 }
8576 }
8572 }
8577 }
8573 return genericBinaryFileWidget::heightForWidth(arg__1);
8578 return genericBinaryFileWidget::heightForWidth(arg__1);
8574 }
8579 }
8575 void PythonQtShell_genericBinaryFileWidget::hideEvent(QHideEvent* arg__1)
8580 void PythonQtShell_genericBinaryFileWidget::hideEvent(QHideEvent* arg__1)
8576 {
8581 {
8577 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8582 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8578 static PyObject* name = PyString_FromString("hideEvent");
8583 static PyObject* name = PyString_FromString("hideEvent");
8579 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8584 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8580 if (obj) {
8585 if (obj) {
8581 static const char* argumentList[] ={"" , "QHideEvent*"};
8586 static const char* argumentList[] ={"" , "QHideEvent*"};
8582 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8587 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8583 void* args[2] = {NULL, (void*)&arg__1};
8588 void* args[2] = {NULL, (void*)&arg__1};
8584 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8589 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8585 if (result) { Py_DECREF(result); }
8590 if (result) { Py_DECREF(result); }
8586 Py_DECREF(obj);
8591 Py_DECREF(obj);
8587 return;
8592 return;
8588 } else {
8593 } else {
8589 PyErr_Clear();
8594 PyErr_Clear();
8590 }
8595 }
8591 }
8596 }
8592 genericBinaryFileWidget::hideEvent(arg__1);
8597 genericBinaryFileWidget::hideEvent(arg__1);
8593 }
8598 }
8594 void PythonQtShell_genericBinaryFileWidget::initPainter(QPainter* painter0) const
8599 void PythonQtShell_genericBinaryFileWidget::initPainter(QPainter* painter0) const
8595 {
8600 {
8596 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8601 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8597 static PyObject* name = PyString_FromString("initPainter");
8602 static PyObject* name = PyString_FromString("initPainter");
8598 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8603 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8599 if (obj) {
8604 if (obj) {
8600 static const char* argumentList[] ={"" , "QPainter*"};
8605 static const char* argumentList[] ={"" , "QPainter*"};
8601 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8606 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8602 void* args[2] = {NULL, (void*)&painter0};
8607 void* args[2] = {NULL, (void*)&painter0};
8603 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8608 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8604 if (result) { Py_DECREF(result); }
8609 if (result) { Py_DECREF(result); }
8605 Py_DECREF(obj);
8610 Py_DECREF(obj);
8606 return;
8611 return;
8607 } else {
8612 } else {
8608 PyErr_Clear();
8613 PyErr_Clear();
8609 }
8614 }
8610 }
8615 }
8611 genericBinaryFileWidget::initPainter(painter0);
8616 genericBinaryFileWidget::initPainter(painter0);
8612 }
8617 }
8613 void PythonQtShell_genericBinaryFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
8618 void PythonQtShell_genericBinaryFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
8614 {
8619 {
8615 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8620 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8616 static PyObject* name = PyString_FromString("inputMethodEvent");
8621 static PyObject* name = PyString_FromString("inputMethodEvent");
8617 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8622 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8618 if (obj) {
8623 if (obj) {
8619 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
8624 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
8620 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8625 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8621 void* args[2] = {NULL, (void*)&arg__1};
8626 void* args[2] = {NULL, (void*)&arg__1};
8622 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8627 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8623 if (result) { Py_DECREF(result); }
8628 if (result) { Py_DECREF(result); }
8624 Py_DECREF(obj);
8629 Py_DECREF(obj);
8625 return;
8630 return;
8626 } else {
8631 } else {
8627 PyErr_Clear();
8632 PyErr_Clear();
8628 }
8633 }
8629 }
8634 }
8630 genericBinaryFileWidget::inputMethodEvent(arg__1);
8635 genericBinaryFileWidget::inputMethodEvent(arg__1);
8631 }
8636 }
8632 QVariant PythonQtShell_genericBinaryFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
8637 QVariant PythonQtShell_genericBinaryFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
8633 {
8638 {
8634 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8639 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8635 static PyObject* name = PyString_FromString("inputMethodQuery");
8640 static PyObject* name = PyString_FromString("inputMethodQuery");
8636 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8641 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8637 if (obj) {
8642 if (obj) {
8638 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
8643 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
8639 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8644 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8640 QVariant returnValue;
8645 QVariant returnValue;
8641 void* args[2] = {NULL, (void*)&arg__1};
8646 void* args[2] = {NULL, (void*)&arg__1};
8642 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8647 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8643 if (result) {
8648 if (result) {
8644 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8649 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8645 if (args[0]!=&returnValue) {
8650 if (args[0]!=&returnValue) {
8646 if (args[0]==NULL) {
8651 if (args[0]==NULL) {
8647 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
8652 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
8648 } else {
8653 } else {
8649 returnValue = *((QVariant*)args[0]);
8654 returnValue = *((QVariant*)args[0]);
8650 }
8655 }
8651 }
8656 }
8652 }
8657 }
8653 if (result) { Py_DECREF(result); }
8658 if (result) { Py_DECREF(result); }
8654 Py_DECREF(obj);
8659 Py_DECREF(obj);
8655 return returnValue;
8660 return returnValue;
8656 } else {
8661 } else {
8657 PyErr_Clear();
8662 PyErr_Clear();
8658 }
8663 }
8659 }
8664 }
8660 return genericBinaryFileWidget::inputMethodQuery(arg__1);
8665 return genericBinaryFileWidget::inputMethodQuery(arg__1);
8661 }
8666 }
8662 void PythonQtShell_genericBinaryFileWidget::keyPressEvent(QKeyEvent* arg__1)
8667 void PythonQtShell_genericBinaryFileWidget::keyPressEvent(QKeyEvent* arg__1)
8663 {
8668 {
8664 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8669 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8665 static PyObject* name = PyString_FromString("keyPressEvent");
8670 static PyObject* name = PyString_FromString("keyPressEvent");
8666 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8671 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8667 if (obj) {
8672 if (obj) {
8668 static const char* argumentList[] ={"" , "QKeyEvent*"};
8673 static const char* argumentList[] ={"" , "QKeyEvent*"};
8669 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8674 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8670 void* args[2] = {NULL, (void*)&arg__1};
8675 void* args[2] = {NULL, (void*)&arg__1};
8671 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8676 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8672 if (result) { Py_DECREF(result); }
8677 if (result) { Py_DECREF(result); }
8673 Py_DECREF(obj);
8678 Py_DECREF(obj);
8674 return;
8679 return;
8675 } else {
8680 } else {
8676 PyErr_Clear();
8681 PyErr_Clear();
8677 }
8682 }
8678 }
8683 }
8679 genericBinaryFileWidget::keyPressEvent(arg__1);
8684 genericBinaryFileWidget::keyPressEvent(arg__1);
8680 }
8685 }
8681 void PythonQtShell_genericBinaryFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
8686 void PythonQtShell_genericBinaryFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
8682 {
8687 {
8683 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8688 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8684 static PyObject* name = PyString_FromString("keyReleaseEvent");
8689 static PyObject* name = PyString_FromString("keyReleaseEvent");
8685 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8690 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8686 if (obj) {
8691 if (obj) {
8687 static const char* argumentList[] ={"" , "QKeyEvent*"};
8692 static const char* argumentList[] ={"" , "QKeyEvent*"};
8688 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8693 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8689 void* args[2] = {NULL, (void*)&arg__1};
8694 void* args[2] = {NULL, (void*)&arg__1};
8690 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8695 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8691 if (result) { Py_DECREF(result); }
8696 if (result) { Py_DECREF(result); }
8692 Py_DECREF(obj);
8697 Py_DECREF(obj);
8693 return;
8698 return;
8694 } else {
8699 } else {
8695 PyErr_Clear();
8700 PyErr_Clear();
8696 }
8701 }
8697 }
8702 }
8698 genericBinaryFileWidget::keyReleaseEvent(arg__1);
8703 genericBinaryFileWidget::keyReleaseEvent(arg__1);
8699 }
8704 }
8700 void PythonQtShell_genericBinaryFileWidget::leaveEvent(QEvent* arg__1)
8705 void PythonQtShell_genericBinaryFileWidget::leaveEvent(QEvent* arg__1)
8701 {
8706 {
8702 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8707 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8703 static PyObject* name = PyString_FromString("leaveEvent");
8708 static PyObject* name = PyString_FromString("leaveEvent");
8704 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8709 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8705 if (obj) {
8710 if (obj) {
8706 static const char* argumentList[] ={"" , "QEvent*"};
8711 static const char* argumentList[] ={"" , "QEvent*"};
8707 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8712 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8708 void* args[2] = {NULL, (void*)&arg__1};
8713 void* args[2] = {NULL, (void*)&arg__1};
8709 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8714 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8710 if (result) { Py_DECREF(result); }
8715 if (result) { Py_DECREF(result); }
8711 Py_DECREF(obj);
8716 Py_DECREF(obj);
8712 return;
8717 return;
8713 } else {
8718 } else {
8714 PyErr_Clear();
8719 PyErr_Clear();
8715 }
8720 }
8716 }
8721 }
8717 genericBinaryFileWidget::leaveEvent(arg__1);
8722 genericBinaryFileWidget::leaveEvent(arg__1);
8718 }
8723 }
8719 int PythonQtShell_genericBinaryFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
8724 int PythonQtShell_genericBinaryFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
8720 {
8725 {
8721 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8726 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8722 static PyObject* name = PyString_FromString("metric");
8727 static PyObject* name = PyString_FromString("metric");
8723 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8728 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8724 if (obj) {
8729 if (obj) {
8725 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
8730 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
8726 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8731 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8727 int returnValue;
8732 int returnValue;
8728 void* args[2] = {NULL, (void*)&arg__1};
8733 void* args[2] = {NULL, (void*)&arg__1};
8729 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8734 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8730 if (result) {
8735 if (result) {
8731 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8736 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8732 if (args[0]!=&returnValue) {
8737 if (args[0]!=&returnValue) {
8733 if (args[0]==NULL) {
8738 if (args[0]==NULL) {
8734 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
8739 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
8735 } else {
8740 } else {
8736 returnValue = *((int*)args[0]);
8741 returnValue = *((int*)args[0]);
8737 }
8742 }
8738 }
8743 }
8739 }
8744 }
8740 if (result) { Py_DECREF(result); }
8745 if (result) { Py_DECREF(result); }
8741 Py_DECREF(obj);
8746 Py_DECREF(obj);
8742 return returnValue;
8747 return returnValue;
8743 } else {
8748 } else {
8744 PyErr_Clear();
8749 PyErr_Clear();
8745 }
8750 }
8746 }
8751 }
8747 return genericBinaryFileWidget::metric(arg__1);
8752 return genericBinaryFileWidget::metric(arg__1);
8748 }
8753 }
8749 QSize PythonQtShell_genericBinaryFileWidget::minimumSizeHint() const
8754 QSize PythonQtShell_genericBinaryFileWidget::minimumSizeHint() const
8750 {
8755 {
8751 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8756 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8752 static PyObject* name = PyString_FromString("getMinimumSizeHint");
8757 static PyObject* name = PyString_FromString("getMinimumSizeHint");
8753 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8758 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8754 if (obj) {
8759 if (obj) {
8755 static const char* argumentList[] ={"QSize"};
8760 static const char* argumentList[] ={"QSize"};
8756 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8761 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8757 QSize returnValue;
8762 QSize returnValue;
8758 void* args[1] = {NULL};
8763 void* args[1] = {NULL};
8759 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8764 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8760 if (result) {
8765 if (result) {
8761 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8766 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8762 if (args[0]!=&returnValue) {
8767 if (args[0]!=&returnValue) {
8763 if (args[0]==NULL) {
8768 if (args[0]==NULL) {
8764 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
8769 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
8765 } else {
8770 } else {
8766 returnValue = *((QSize*)args[0]);
8771 returnValue = *((QSize*)args[0]);
8767 }
8772 }
8768 }
8773 }
8769 }
8774 }
8770 if (result) { Py_DECREF(result); }
8775 if (result) { Py_DECREF(result); }
8771 Py_DECREF(obj);
8776 Py_DECREF(obj);
8772 return returnValue;
8777 return returnValue;
8773 } else {
8778 } else {
8774 PyErr_Clear();
8779 PyErr_Clear();
8775 }
8780 }
8776 }
8781 }
8777 return genericBinaryFileWidget::minimumSizeHint();
8782 return genericBinaryFileWidget::minimumSizeHint();
8778 }
8783 }
8779 void PythonQtShell_genericBinaryFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
8784 void PythonQtShell_genericBinaryFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
8780 {
8785 {
8781 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8786 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8782 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
8787 static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
8783 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8788 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8784 if (obj) {
8789 if (obj) {
8785 static const char* argumentList[] ={"" , "QMouseEvent*"};
8790 static const char* argumentList[] ={"" , "QMouseEvent*"};
8786 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8791 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8787 void* args[2] = {NULL, (void*)&arg__1};
8792 void* args[2] = {NULL, (void*)&arg__1};
8788 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8793 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8789 if (result) { Py_DECREF(result); }
8794 if (result) { Py_DECREF(result); }
8790 Py_DECREF(obj);
8795 Py_DECREF(obj);
8791 return;
8796 return;
8792 } else {
8797 } else {
8793 PyErr_Clear();
8798 PyErr_Clear();
8794 }
8799 }
8795 }
8800 }
8796 genericBinaryFileWidget::mouseDoubleClickEvent(arg__1);
8801 genericBinaryFileWidget::mouseDoubleClickEvent(arg__1);
8797 }
8802 }
8798 void PythonQtShell_genericBinaryFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
8803 void PythonQtShell_genericBinaryFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
8799 {
8804 {
8800 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8805 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8801 static PyObject* name = PyString_FromString("mouseMoveEvent");
8806 static PyObject* name = PyString_FromString("mouseMoveEvent");
8802 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8807 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8803 if (obj) {
8808 if (obj) {
8804 static const char* argumentList[] ={"" , "QMouseEvent*"};
8809 static const char* argumentList[] ={"" , "QMouseEvent*"};
8805 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8810 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8806 void* args[2] = {NULL, (void*)&arg__1};
8811 void* args[2] = {NULL, (void*)&arg__1};
8807 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8812 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8808 if (result) { Py_DECREF(result); }
8813 if (result) { Py_DECREF(result); }
8809 Py_DECREF(obj);
8814 Py_DECREF(obj);
8810 return;
8815 return;
8811 } else {
8816 } else {
8812 PyErr_Clear();
8817 PyErr_Clear();
8813 }
8818 }
8814 }
8819 }
8815 genericBinaryFileWidget::mouseMoveEvent(arg__1);
8820 genericBinaryFileWidget::mouseMoveEvent(arg__1);
8816 }
8821 }
8817 void PythonQtShell_genericBinaryFileWidget::mousePressEvent(QMouseEvent* arg__1)
8822 void PythonQtShell_genericBinaryFileWidget::mousePressEvent(QMouseEvent* arg__1)
8818 {
8823 {
8819 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8824 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8820 static PyObject* name = PyString_FromString("mousePressEvent");
8825 static PyObject* name = PyString_FromString("mousePressEvent");
8821 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8826 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8822 if (obj) {
8827 if (obj) {
8823 static const char* argumentList[] ={"" , "QMouseEvent*"};
8828 static const char* argumentList[] ={"" , "QMouseEvent*"};
8824 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8829 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8825 void* args[2] = {NULL, (void*)&arg__1};
8830 void* args[2] = {NULL, (void*)&arg__1};
8826 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8831 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8827 if (result) { Py_DECREF(result); }
8832 if (result) { Py_DECREF(result); }
8828 Py_DECREF(obj);
8833 Py_DECREF(obj);
8829 return;
8834 return;
8830 } else {
8835 } else {
8831 PyErr_Clear();
8836 PyErr_Clear();
8832 }
8837 }
8833 }
8838 }
8834 genericBinaryFileWidget::mousePressEvent(arg__1);
8839 genericBinaryFileWidget::mousePressEvent(arg__1);
8835 }
8840 }
8836 void PythonQtShell_genericBinaryFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
8841 void PythonQtShell_genericBinaryFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
8837 {
8842 {
8838 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8843 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8839 static PyObject* name = PyString_FromString("mouseReleaseEvent");
8844 static PyObject* name = PyString_FromString("mouseReleaseEvent");
8840 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8845 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8841 if (obj) {
8846 if (obj) {
8842 static const char* argumentList[] ={"" , "QMouseEvent*"};
8847 static const char* argumentList[] ={"" , "QMouseEvent*"};
8843 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8848 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8844 void* args[2] = {NULL, (void*)&arg__1};
8849 void* args[2] = {NULL, (void*)&arg__1};
8845 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8850 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8846 if (result) { Py_DECREF(result); }
8851 if (result) { Py_DECREF(result); }
8847 Py_DECREF(obj);
8852 Py_DECREF(obj);
8848 return;
8853 return;
8849 } else {
8854 } else {
8850 PyErr_Clear();
8855 PyErr_Clear();
8851 }
8856 }
8852 }
8857 }
8853 genericBinaryFileWidget::mouseReleaseEvent(arg__1);
8858 genericBinaryFileWidget::mouseReleaseEvent(arg__1);
8854 }
8859 }
8855 void PythonQtShell_genericBinaryFileWidget::moveEvent(QMoveEvent* arg__1)
8860 void PythonQtShell_genericBinaryFileWidget::moveEvent(QMoveEvent* arg__1)
8856 {
8861 {
8857 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8862 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8858 static PyObject* name = PyString_FromString("moveEvent");
8863 static PyObject* name = PyString_FromString("moveEvent");
8859 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8864 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8860 if (obj) {
8865 if (obj) {
8861 static const char* argumentList[] ={"" , "QMoveEvent*"};
8866 static const char* argumentList[] ={"" , "QMoveEvent*"};
8862 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8867 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8863 void* args[2] = {NULL, (void*)&arg__1};
8868 void* args[2] = {NULL, (void*)&arg__1};
8864 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8869 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8865 if (result) { Py_DECREF(result); }
8870 if (result) { Py_DECREF(result); }
8866 Py_DECREF(obj);
8871 Py_DECREF(obj);
8867 return;
8872 return;
8868 } else {
8873 } else {
8869 PyErr_Clear();
8874 PyErr_Clear();
8870 }
8875 }
8871 }
8876 }
8872 genericBinaryFileWidget::moveEvent(arg__1);
8877 genericBinaryFileWidget::moveEvent(arg__1);
8873 }
8878 }
8874 bool PythonQtShell_genericBinaryFileWidget::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
8879 bool PythonQtShell_genericBinaryFileWidget::nativeEvent(const QByteArray& eventType0, void* message1, long* result2)
8875 {
8880 {
8876 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8881 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8877 static PyObject* name = PyString_FromString("nativeEvent");
8882 static PyObject* name = PyString_FromString("nativeEvent");
8878 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8883 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8879 if (obj) {
8884 if (obj) {
8880 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
8885 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
8881 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
8886 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
8882 bool returnValue;
8887 bool returnValue;
8883 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
8888 void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
8884 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8889 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8885 if (result) {
8890 if (result) {
8886 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8891 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8887 if (args[0]!=&returnValue) {
8892 if (args[0]!=&returnValue) {
8888 if (args[0]==NULL) {
8893 if (args[0]==NULL) {
8889 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
8894 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
8890 } else {
8895 } else {
8891 returnValue = *((bool*)args[0]);
8896 returnValue = *((bool*)args[0]);
8892 }
8897 }
8893 }
8898 }
8894 }
8899 }
8895 if (result) { Py_DECREF(result); }
8900 if (result) { Py_DECREF(result); }
8896 Py_DECREF(obj);
8901 Py_DECREF(obj);
8897 return returnValue;
8902 return returnValue;
8898 } else {
8903 } else {
8899 PyErr_Clear();
8904 PyErr_Clear();
8900 }
8905 }
8901 }
8906 }
8902 return genericBinaryFileWidget::nativeEvent(eventType0, message1, result2);
8907 return genericBinaryFileWidget::nativeEvent(eventType0, message1, result2);
8903 }
8908 }
8904 QPaintEngine* PythonQtShell_genericBinaryFileWidget::paintEngine() const
8909 QPaintEngine* PythonQtShell_genericBinaryFileWidget::paintEngine() const
8905 {
8910 {
8906 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8911 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8907 static PyObject* name = PyString_FromString("paintEngine");
8912 static PyObject* name = PyString_FromString("paintEngine");
8908 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8913 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8909 if (obj) {
8914 if (obj) {
8910 static const char* argumentList[] ={"QPaintEngine*"};
8915 static const char* argumentList[] ={"QPaintEngine*"};
8911 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8916 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8912 QPaintEngine* returnValue;
8917 QPaintEngine* returnValue;
8913 void* args[1] = {NULL};
8918 void* args[1] = {NULL};
8914 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8919 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8915 if (result) {
8920 if (result) {
8916 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8921 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8917 if (args[0]!=&returnValue) {
8922 if (args[0]!=&returnValue) {
8918 if (args[0]==NULL) {
8923 if (args[0]==NULL) {
8919 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
8924 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
8920 } else {
8925 } else {
8921 returnValue = *((QPaintEngine**)args[0]);
8926 returnValue = *((QPaintEngine**)args[0]);
8922 }
8927 }
8923 }
8928 }
8924 }
8929 }
8925 if (result) { Py_DECREF(result); }
8930 if (result) { Py_DECREF(result); }
8926 Py_DECREF(obj);
8931 Py_DECREF(obj);
8927 return returnValue;
8932 return returnValue;
8928 } else {
8933 } else {
8929 PyErr_Clear();
8934 PyErr_Clear();
8930 }
8935 }
8931 }
8936 }
8932 return genericBinaryFileWidget::paintEngine();
8937 return genericBinaryFileWidget::paintEngine();
8933 }
8938 }
8934 void PythonQtShell_genericBinaryFileWidget::paintEvent(QPaintEvent* arg__1)
8939 void PythonQtShell_genericBinaryFileWidget::paintEvent(QPaintEvent* arg__1)
8935 {
8940 {
8936 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8941 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8937 static PyObject* name = PyString_FromString("paintEvent");
8942 static PyObject* name = PyString_FromString("paintEvent");
8938 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8943 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8939 if (obj) {
8944 if (obj) {
8940 static const char* argumentList[] ={"" , "QPaintEvent*"};
8945 static const char* argumentList[] ={"" , "QPaintEvent*"};
8941 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8946 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8942 void* args[2] = {NULL, (void*)&arg__1};
8947 void* args[2] = {NULL, (void*)&arg__1};
8943 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8948 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8944 if (result) { Py_DECREF(result); }
8949 if (result) { Py_DECREF(result); }
8945 Py_DECREF(obj);
8950 Py_DECREF(obj);
8946 return;
8951 return;
8947 } else {
8952 } else {
8948 PyErr_Clear();
8953 PyErr_Clear();
8949 }
8954 }
8950 }
8955 }
8951 genericBinaryFileWidget::paintEvent(arg__1);
8956 genericBinaryFileWidget::paintEvent(arg__1);
8952 }
8957 }
8953 QPaintDevice* PythonQtShell_genericBinaryFileWidget::redirected(QPoint* offset0) const
8958 QPaintDevice* PythonQtShell_genericBinaryFileWidget::redirected(QPoint* offset0) const
8954 {
8959 {
8955 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8960 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8956 static PyObject* name = PyString_FromString("redirected");
8961 static PyObject* name = PyString_FromString("redirected");
8957 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8962 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8958 if (obj) {
8963 if (obj) {
8959 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
8964 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
8960 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8965 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8961 QPaintDevice* returnValue;
8966 QPaintDevice* returnValue;
8962 void* args[2] = {NULL, (void*)&offset0};
8967 void* args[2] = {NULL, (void*)&offset0};
8963 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8968 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8964 if (result) {
8969 if (result) {
8965 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8970 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8966 if (args[0]!=&returnValue) {
8971 if (args[0]!=&returnValue) {
8967 if (args[0]==NULL) {
8972 if (args[0]==NULL) {
8968 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
8973 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
8969 } else {
8974 } else {
8970 returnValue = *((QPaintDevice**)args[0]);
8975 returnValue = *((QPaintDevice**)args[0]);
8971 }
8976 }
8972 }
8977 }
8973 }
8978 }
8974 if (result) { Py_DECREF(result); }
8979 if (result) { Py_DECREF(result); }
8975 Py_DECREF(obj);
8980 Py_DECREF(obj);
8976 return returnValue;
8981 return returnValue;
8977 } else {
8982 } else {
8978 PyErr_Clear();
8983 PyErr_Clear();
8979 }
8984 }
8980 }
8985 }
8981 return genericBinaryFileWidget::redirected(offset0);
8986 return genericBinaryFileWidget::redirected(offset0);
8982 }
8987 }
8983 void PythonQtShell_genericBinaryFileWidget::resizeEvent(QResizeEvent* arg__1)
8988 void PythonQtShell_genericBinaryFileWidget::resizeEvent(QResizeEvent* arg__1)
8984 {
8989 {
8985 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8990 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
8986 static PyObject* name = PyString_FromString("resizeEvent");
8991 static PyObject* name = PyString_FromString("resizeEvent");
8987 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8992 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
8988 if (obj) {
8993 if (obj) {
8989 static const char* argumentList[] ={"" , "QResizeEvent*"};
8994 static const char* argumentList[] ={"" , "QResizeEvent*"};
8990 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8995 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8991 void* args[2] = {NULL, (void*)&arg__1};
8996 void* args[2] = {NULL, (void*)&arg__1};
8992 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8997 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8993 if (result) { Py_DECREF(result); }
8998 if (result) { Py_DECREF(result); }
8994 Py_DECREF(obj);
8999 Py_DECREF(obj);
8995 return;
9000 return;
8996 } else {
9001 } else {
8997 PyErr_Clear();
9002 PyErr_Clear();
8998 }
9003 }
8999 }
9004 }
9000 genericBinaryFileWidget::resizeEvent(arg__1);
9005 genericBinaryFileWidget::resizeEvent(arg__1);
9001 }
9006 }
9002 QPainter* PythonQtShell_genericBinaryFileWidget::sharedPainter() const
9007 QPainter* PythonQtShell_genericBinaryFileWidget::sharedPainter() const
9003 {
9008 {
9004 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9009 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9005 static PyObject* name = PyString_FromString("sharedPainter");
9010 static PyObject* name = PyString_FromString("sharedPainter");
9006 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9011 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9007 if (obj) {
9012 if (obj) {
9008 static const char* argumentList[] ={"QPainter*"};
9013 static const char* argumentList[] ={"QPainter*"};
9009 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9014 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9010 QPainter* returnValue;
9015 QPainter* returnValue;
9011 void* args[1] = {NULL};
9016 void* args[1] = {NULL};
9012 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9017 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9013 if (result) {
9018 if (result) {
9014 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9019 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9015 if (args[0]!=&returnValue) {
9020 if (args[0]!=&returnValue) {
9016 if (args[0]==NULL) {
9021 if (args[0]==NULL) {
9017 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
9022 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
9018 } else {
9023 } else {
9019 returnValue = *((QPainter**)args[0]);
9024 returnValue = *((QPainter**)args[0]);
9020 }
9025 }
9021 }
9026 }
9022 }
9027 }
9023 if (result) { Py_DECREF(result); }
9028 if (result) { Py_DECREF(result); }
9024 Py_DECREF(obj);
9029 Py_DECREF(obj);
9025 return returnValue;
9030 return returnValue;
9026 } else {
9031 } else {
9027 PyErr_Clear();
9032 PyErr_Clear();
9028 }
9033 }
9029 }
9034 }
9030 return genericBinaryFileWidget::sharedPainter();
9035 return genericBinaryFileWidget::sharedPainter();
9031 }
9036 }
9032 void PythonQtShell_genericBinaryFileWidget::showEvent(QShowEvent* arg__1)
9037 void PythonQtShell_genericBinaryFileWidget::showEvent(QShowEvent* arg__1)
9033 {
9038 {
9034 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9039 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9035 static PyObject* name = PyString_FromString("showEvent");
9040 static PyObject* name = PyString_FromString("showEvent");
9036 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9041 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9037 if (obj) {
9042 if (obj) {
9038 static const char* argumentList[] ={"" , "QShowEvent*"};
9043 static const char* argumentList[] ={"" , "QShowEvent*"};
9039 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9044 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9040 void* args[2] = {NULL, (void*)&arg__1};
9045 void* args[2] = {NULL, (void*)&arg__1};
9041 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9046 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9042 if (result) { Py_DECREF(result); }
9047 if (result) { Py_DECREF(result); }
9043 Py_DECREF(obj);
9048 Py_DECREF(obj);
9044 return;
9049 return;
9045 } else {
9050 } else {
9046 PyErr_Clear();
9051 PyErr_Clear();
9047 }
9052 }
9048 }
9053 }
9049 genericBinaryFileWidget::showEvent(arg__1);
9054 genericBinaryFileWidget::showEvent(arg__1);
9050 }
9055 }
9051 QSize PythonQtShell_genericBinaryFileWidget::sizeHint() const
9056 QSize PythonQtShell_genericBinaryFileWidget::sizeHint() const
9052 {
9057 {
9053 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9058 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9054 static PyObject* name = PyString_FromString("getSizeHint");
9059 static PyObject* name = PyString_FromString("getSizeHint");
9055 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9060 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9056 if (obj) {
9061 if (obj) {
9057 static const char* argumentList[] ={"QSize"};
9062 static const char* argumentList[] ={"QSize"};
9058 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9063 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9059 QSize returnValue;
9064 QSize returnValue;
9060 void* args[1] = {NULL};
9065 void* args[1] = {NULL};
9061 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9066 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9062 if (result) {
9067 if (result) {
9063 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9068 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9064 if (args[0]!=&returnValue) {
9069 if (args[0]!=&returnValue) {
9065 if (args[0]==NULL) {
9070 if (args[0]==NULL) {
9066 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
9071 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
9067 } else {
9072 } else {
9068 returnValue = *((QSize*)args[0]);
9073 returnValue = *((QSize*)args[0]);
9069 }
9074 }
9070 }
9075 }
9071 }
9076 }
9072 if (result) { Py_DECREF(result); }
9077 if (result) { Py_DECREF(result); }
9073 Py_DECREF(obj);
9078 Py_DECREF(obj);
9074 return returnValue;
9079 return returnValue;
9075 } else {
9080 } else {
9076 PyErr_Clear();
9081 PyErr_Clear();
9077 }
9082 }
9078 }
9083 }
9079 return genericBinaryFileWidget::sizeHint();
9084 return genericBinaryFileWidget::sizeHint();
9080 }
9085 }
9081 void PythonQtShell_genericBinaryFileWidget::tabletEvent(QTabletEvent* arg__1)
9086 void PythonQtShell_genericBinaryFileWidget::tabletEvent(QTabletEvent* arg__1)
9082 {
9087 {
9083 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9088 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9084 static PyObject* name = PyString_FromString("tabletEvent");
9089 static PyObject* name = PyString_FromString("tabletEvent");
9085 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9090 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9086 if (obj) {
9091 if (obj) {
9087 static const char* argumentList[] ={"" , "QTabletEvent*"};
9092 static const char* argumentList[] ={"" , "QTabletEvent*"};
9088 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9093 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9089 void* args[2] = {NULL, (void*)&arg__1};
9094 void* args[2] = {NULL, (void*)&arg__1};
9090 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9095 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9091 if (result) { Py_DECREF(result); }
9096 if (result) { Py_DECREF(result); }
9092 Py_DECREF(obj);
9097 Py_DECREF(obj);
9093 return;
9098 return;
9094 } else {
9099 } else {
9095 PyErr_Clear();
9100 PyErr_Clear();
9096 }
9101 }
9097 }
9102 }
9098 genericBinaryFileWidget::tabletEvent(arg__1);
9103 genericBinaryFileWidget::tabletEvent(arg__1);
9099 }
9104 }
9100 void PythonQtShell_genericBinaryFileWidget::timerEvent(QTimerEvent* arg__1)
9105 void PythonQtShell_genericBinaryFileWidget::timerEvent(QTimerEvent* arg__1)
9101 {
9106 {
9102 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9107 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9103 static PyObject* name = PyString_FromString("timerEvent");
9108 static PyObject* name = PyString_FromString("timerEvent");
9104 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9109 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9105 if (obj) {
9110 if (obj) {
9106 static const char* argumentList[] ={"" , "QTimerEvent*"};
9111 static const char* argumentList[] ={"" , "QTimerEvent*"};
9107 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9112 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9108 void* args[2] = {NULL, (void*)&arg__1};
9113 void* args[2] = {NULL, (void*)&arg__1};
9109 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9114 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9110 if (result) { Py_DECREF(result); }
9115 if (result) { Py_DECREF(result); }
9111 Py_DECREF(obj);
9116 Py_DECREF(obj);
9112 return;
9117 return;
9113 } else {
9118 } else {
9114 PyErr_Clear();
9119 PyErr_Clear();
9115 }
9120 }
9116 }
9121 }
9117 genericBinaryFileWidget::timerEvent(arg__1);
9122 genericBinaryFileWidget::timerEvent(arg__1);
9118 }
9123 }
9119 void PythonQtShell_genericBinaryFileWidget::wheelEvent(QWheelEvent* arg__1)
9124 void PythonQtShell_genericBinaryFileWidget::wheelEvent(QWheelEvent* arg__1)
9120 {
9125 {
9121 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9126 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9122 static PyObject* name = PyString_FromString("wheelEvent");
9127 static PyObject* name = PyString_FromString("wheelEvent");
9123 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9128 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9124 if (obj) {
9129 if (obj) {
9125 static const char* argumentList[] ={"" , "QWheelEvent*"};
9130 static const char* argumentList[] ={"" , "QWheelEvent*"};
9126 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9131 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9127 void* args[2] = {NULL, (void*)&arg__1};
9132 void* args[2] = {NULL, (void*)&arg__1};
9128 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9133 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9129 if (result) { Py_DECREF(result); }
9134 if (result) { Py_DECREF(result); }
9130 Py_DECREF(obj);
9135 Py_DECREF(obj);
9131 return;
9136 return;
9132 } else {
9137 } else {
9133 PyErr_Clear();
9138 PyErr_Clear();
9134 }
9139 }
9135 }
9140 }
9136 genericBinaryFileWidget::wheelEvent(arg__1);
9141 genericBinaryFileWidget::wheelEvent(arg__1);
9137 }
9142 }
9138 genericBinaryFileWidget* PythonQtWrapper_genericBinaryFileWidget::new_genericBinaryFileWidget(QWidget* parent)
9143 genericBinaryFileWidget* PythonQtWrapper_genericBinaryFileWidget::new_genericBinaryFileWidget(QWidget* parent)
9139 {
9144 {
9140 return new PythonQtShell_genericBinaryFileWidget(parent); }
9145 return new PythonQtShell_genericBinaryFileWidget(parent); }
9141
9146
9142
9147
9143
9148
9144 PythonQtShell_srecFile::~PythonQtShell_srecFile() {
9149 PythonQtShell_srecFile::~PythonQtShell_srecFile() {
9145 PythonQtPrivate* priv = PythonQt::priv();
9150 PythonQtPrivate* priv = PythonQt::priv();
9146 if (priv) { priv->shellClassDeleted(this); }
9151 if (priv) { priv->shellClassDeleted(this); }
9147 }
9152 }
9148 int PythonQtShell_srecFile::closeFile()
9153 int PythonQtShell_srecFile::closeFile()
9149 {
9154 {
9150 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9155 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9151 static PyObject* name = PyString_FromString("closeFile");
9156 static PyObject* name = PyString_FromString("closeFile");
9152 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9157 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9153 if (obj) {
9158 if (obj) {
9154 static const char* argumentList[] ={"int"};
9159 static const char* argumentList[] ={"int"};
9155 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9160 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9156 int returnValue;
9161 int returnValue;
9157 void* args[1] = {NULL};
9162 void* args[1] = {NULL};
9158 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9163 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9159 if (result) {
9164 if (result) {
9160 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9165 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9161 if (args[0]!=&returnValue) {
9166 if (args[0]!=&returnValue) {
9162 if (args[0]==NULL) {
9167 if (args[0]==NULL) {
9163 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
9168 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
9164 } else {
9169 } else {
9165 returnValue = *((int*)args[0]);
9170 returnValue = *((int*)args[0]);
9166 }
9171 }
9167 }
9172 }
9168 }
9173 }
9169 if (result) { Py_DECREF(result); }
9174 if (result) { Py_DECREF(result); }
9170 Py_DECREF(obj);
9175 Py_DECREF(obj);
9171 return returnValue;
9176 return returnValue;
9172 } else {
9177 } else {
9173 PyErr_Clear();
9178 PyErr_Clear();
9174 }
9179 }
9175 }
9180 }
9176 return srecFile::closeFile();
9181 return srecFile::closeFile();
9177 }
9182 }
9178 QList<codeFragment* > PythonQtShell_srecFile::getFragments()
9183 QList<codeFragment* > PythonQtShell_srecFile::getFragments()
9179 {
9184 {
9180 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9185 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9181 static PyObject* name = PyString_FromString("getFragments");
9186 static PyObject* name = PyString_FromString("getFragments");
9182 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9187 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9183 if (obj) {
9188 if (obj) {
9184 static const char* argumentList[] ={"QList<codeFragment* >"};
9189 static const char* argumentList[] ={"QList<codeFragment* >"};
9185 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9190 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9186 QList<codeFragment* > returnValue;
9191 QList<codeFragment* > returnValue;
9187 void* args[1] = {NULL};
9192 void* args[1] = {NULL};
9188 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9193 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9189 if (result) {
9194 if (result) {
9190 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9195 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9191 if (args[0]!=&returnValue) {
9196 if (args[0]!=&returnValue) {
9192 if (args[0]==NULL) {
9197 if (args[0]==NULL) {
9193 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
9198 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
9194 } else {
9199 } else {
9195 returnValue = *((QList<codeFragment* >*)args[0]);
9200 returnValue = *((QList<codeFragment* >*)args[0]);
9196 }
9201 }
9197 }
9202 }
9198 }
9203 }
9199 if (result) { Py_DECREF(result); }
9204 if (result) { Py_DECREF(result); }
9200 Py_DECREF(obj);
9205 Py_DECREF(obj);
9201 return returnValue;
9206 return returnValue;
9202 } else {
9207 } else {
9203 PyErr_Clear();
9208 PyErr_Clear();
9204 }
9209 }
9205 }
9210 }
9206 return srecFile::getFragments();
9211 return srecFile::getFragments();
9207 }
9212 }
9208 bool PythonQtShell_srecFile::isopened()
9213 bool PythonQtShell_srecFile::isopened()
9209 {
9214 {
9210 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9215 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9211 static PyObject* name = PyString_FromString("isopened");
9216 static PyObject* name = PyString_FromString("isopened");
9212 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9217 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9213 if (obj) {
9218 if (obj) {
9214 static const char* argumentList[] ={"bool"};
9219 static const char* argumentList[] ={"bool"};
9215 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9220 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9216 bool returnValue;
9221 bool returnValue;
9217 void* args[1] = {NULL};
9222 void* args[1] = {NULL};
9218 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9223 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9219 if (result) {
9224 if (result) {
9220 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9225 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9221 if (args[0]!=&returnValue) {
9226 if (args[0]!=&returnValue) {
9222 if (args[0]==NULL) {
9227 if (args[0]==NULL) {
9223 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
9228 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
9224 } else {
9229 } else {
9225 returnValue = *((bool*)args[0]);
9230 returnValue = *((bool*)args[0]);
9226 }
9231 }
9227 }
9232 }
9228 }
9233 }
9229 if (result) { Py_DECREF(result); }
9234 if (result) { Py_DECREF(result); }
9230 Py_DECREF(obj);
9235 Py_DECREF(obj);
9231 return returnValue;
9236 return returnValue;
9232 } else {
9237 } else {
9233 PyErr_Clear();
9238 PyErr_Clear();
9234 }
9239 }
9235 }
9240 }
9236 return srecFile::isopened();
9241 return srecFile::isopened();
9237 }
9242 }
9238 bool PythonQtShell_srecFile::openFile(const QString& File0)
9243 bool PythonQtShell_srecFile::openFile(const QString& File0)
9239 {
9244 {
9240 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9245 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9241 static PyObject* name = PyString_FromString("openFile");
9246 static PyObject* name = PyString_FromString("openFile");
9242 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9247 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9243 if (obj) {
9248 if (obj) {
9244 static const char* argumentList[] ={"bool" , "const QString&"};
9249 static const char* argumentList[] ={"bool" , "const QString&"};
9245 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9250 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9246 bool returnValue;
9251 bool returnValue;
9247 void* args[2] = {NULL, (void*)&File0};
9252 void* args[2] = {NULL, (void*)&File0};
9248 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9253 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9249 if (result) {
9254 if (result) {
9250 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9255 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9251 if (args[0]!=&returnValue) {
9256 if (args[0]!=&returnValue) {
9252 if (args[0]==NULL) {
9257 if (args[0]==NULL) {
9253 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
9258 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
9254 } else {
9259 } else {
9255 returnValue = *((bool*)args[0]);
9260 returnValue = *((bool*)args[0]);
9256 }
9261 }
9257 }
9262 }
9258 }
9263 }
9259 if (result) { Py_DECREF(result); }
9264 if (result) { Py_DECREF(result); }
9260 Py_DECREF(obj);
9265 Py_DECREF(obj);
9261 return returnValue;
9266 return returnValue;
9262 } else {
9267 } else {
9263 PyErr_Clear();
9268 PyErr_Clear();
9264 }
9269 }
9265 }
9270 }
9266 return srecFile::openFile(File0);
9271 return srecFile::openFile(File0);
9267 }
9272 }
9268 bool PythonQtShell_srecFile::toBinary(const QString& File0)
9273 bool PythonQtShell_srecFile::toBinary(const QString& File0)
9269 {
9274 {
9270 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9275 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9271 static PyObject* name = PyString_FromString("toBinary");
9276 static PyObject* name = PyString_FromString("toBinary");
9272 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9277 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9273 if (obj) {
9278 if (obj) {
9274 static const char* argumentList[] ={"bool" , "const QString&"};
9279 static const char* argumentList[] ={"bool" , "const QString&"};
9275 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9280 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9276 bool returnValue;
9281 bool returnValue;
9277 void* args[2] = {NULL, (void*)&File0};
9282 void* args[2] = {NULL, (void*)&File0};
9278 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9283 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9279 if (result) {
9284 if (result) {
9280 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9285 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9281 if (args[0]!=&returnValue) {
9286 if (args[0]!=&returnValue) {
9282 if (args[0]==NULL) {
9287 if (args[0]==NULL) {
9283 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
9288 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
9284 } else {
9289 } else {
9285 returnValue = *((bool*)args[0]);
9290 returnValue = *((bool*)args[0]);
9286 }
9291 }
9287 }
9292 }
9288 }
9293 }
9289 if (result) { Py_DECREF(result); }
9294 if (result) { Py_DECREF(result); }
9290 Py_DECREF(obj);
9295 Py_DECREF(obj);
9291 return returnValue;
9296 return returnValue;
9292 } else {
9297 } else {
9293 PyErr_Clear();
9298 PyErr_Clear();
9294 }
9299 }
9295 }
9300 }
9296 return srecFile::toBinary(File0);
9301 return srecFile::toBinary(File0);
9297 }
9302 }
9298 bool PythonQtShell_srecFile::toSrec(const QString& File0)
9303 bool PythonQtShell_srecFile::toSrec(const QString& File0)
9299 {
9304 {
9300 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9305 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9301 static PyObject* name = PyString_FromString("toSrec");
9306 static PyObject* name = PyString_FromString("toSrec");
9302 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9307 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9303 if (obj) {
9308 if (obj) {
9304 static const char* argumentList[] ={"bool" , "const QString&"};
9309 static const char* argumentList[] ={"bool" , "const QString&"};
9305 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9310 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9306 bool returnValue;
9311 bool returnValue;
9307 void* args[2] = {NULL, (void*)&File0};
9312 void* args[2] = {NULL, (void*)&File0};
9308 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9313 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9309 if (result) {
9314 if (result) {
9310 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9315 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
9311 if (args[0]!=&returnValue) {
9316 if (args[0]!=&returnValue) {
9312 if (args[0]==NULL) {
9317 if (args[0]==NULL) {
9313 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
9318 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
9314 } else {
9319 } else {
9315 returnValue = *((bool*)args[0]);
9320 returnValue = *((bool*)args[0]);
9316 }
9321 }
9317 }
9322 }
9318 }
9323 }
9319 if (result) { Py_DECREF(result); }
9324 if (result) { Py_DECREF(result); }
9320 Py_DECREF(obj);
9325 Py_DECREF(obj);
9321 return returnValue;
9326 return returnValue;
9322 } else {
9327 } else {
9323 PyErr_Clear();
9328 PyErr_Clear();
9324 }
9329 }
9325 }
9330 }
9326 return srecFile::toSrec(File0);
9331 return srecFile::toSrec(File0);
9327 }
9332 }
9328 srecFile* PythonQtWrapper_srecFile::new_srecFile()
9333 srecFile* PythonQtWrapper_srecFile::new_srecFile()
9329 {
9334 {
9330 return new PythonQtShell_srecFile(); }
9335 return new PythonQtShell_srecFile(); }
9331
9336
9332 srecFile* PythonQtWrapper_srecFile::new_srecFile(const QString& File)
9337 srecFile* PythonQtWrapper_srecFile::new_srecFile(const QString& File)
9333 {
9338 {
9334 return new PythonQtShell_srecFile(File); }
9339 return new PythonQtShell_srecFile(File); }
9335
9340
9336 srecFile* PythonQtWrapper_srecFile::new_srecFile(const QStringList& Files)
9341 srecFile* PythonQtWrapper_srecFile::new_srecFile(const QStringList& Files)
9337 {
9342 {
9338 return new PythonQtShell_srecFile(Files); }
9343 return new PythonQtShell_srecFile(Files); }
9339
9344
9340 bool PythonQtWrapper_srecFile::static_srecFile_checkSum(const QString& line)
9345 bool PythonQtWrapper_srecFile::static_srecFile_checkSum(const QString& line)
9341 {
9346 {
9342 return (srecFile::checkSum(line));
9347 return (srecFile::checkSum(line));
9343 }
9348 }
9344
9349
9345 int PythonQtWrapper_srecFile::closeFile(srecFile* theWrappedObject)
9350 int PythonQtWrapper_srecFile::closeFile(srecFile* theWrappedObject)
9346 {
9351 {
9347 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_closeFile());
9352 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_closeFile());
9348 }
9353 }
9349
9354
9350 codeFragment* PythonQtWrapper_srecFile::getFragment(srecFile* theWrappedObject, int index)
9355 codeFragment* PythonQtWrapper_srecFile::getFragment(srecFile* theWrappedObject, int index)
9351 {
9356 {
9352 return ( theWrappedObject->getFragment(index));
9357 return ( theWrappedObject->getFragment(index));
9353 }
9358 }
9354
9359
9355 int PythonQtWrapper_srecFile::getFragmentAddress(srecFile* theWrappedObject, int index)
9360 int PythonQtWrapper_srecFile::getFragmentAddress(srecFile* theWrappedObject, int index)
9356 {
9361 {
9357 return ( theWrappedObject->getFragmentAddress(index));
9362 return ( theWrappedObject->getFragmentAddress(index));
9358 }
9363 }
9359
9364
9360 bool PythonQtWrapper_srecFile::getFragmentData(srecFile* theWrappedObject, int index, char** buffer)
9365 bool PythonQtWrapper_srecFile::getFragmentData(srecFile* theWrappedObject, int index, char** buffer)
9361 {
9366 {
9362 return ( theWrappedObject->getFragmentData(index, buffer));
9367 return ( theWrappedObject->getFragmentData(index, buffer));
9363 }
9368 }
9364
9369
9365 QString PythonQtWrapper_srecFile::getFragmentHeader(srecFile* theWrappedObject, int index)
9370 QString PythonQtWrapper_srecFile::getFragmentHeader(srecFile* theWrappedObject, int index)
9366 {
9371 {
9367 return ( theWrappedObject->getFragmentHeader(index));
9372 return ( theWrappedObject->getFragmentHeader(index));
9368 }
9373 }
9369
9374
9370 int PythonQtWrapper_srecFile::getFragmentSize(srecFile* theWrappedObject, int index)
9375 int PythonQtWrapper_srecFile::getFragmentSize(srecFile* theWrappedObject, int index)
9371 {
9376 {
9372 return ( theWrappedObject->getFragmentSize(index));
9377 return ( theWrappedObject->getFragmentSize(index));
9373 }
9378 }
9374
9379
9375 QList<codeFragment* > PythonQtWrapper_srecFile::getFragments(srecFile* theWrappedObject)
9380 QList<codeFragment* > PythonQtWrapper_srecFile::getFragments(srecFile* theWrappedObject)
9376 {
9381 {
9377 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_getFragments());
9382 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_getFragments());
9378 }
9383 }
9379
9384
9380 int PythonQtWrapper_srecFile::getFragmentsCount(srecFile* theWrappedObject)
9385 int PythonQtWrapper_srecFile::getFragmentsCount(srecFile* theWrappedObject)
9381 {
9386 {
9382 return ( theWrappedObject->getFragmentsCount());
9387 return ( theWrappedObject->getFragmentsCount());
9383 }
9388 }
9384
9389
9385 bool PythonQtWrapper_srecFile::isSREC(srecFile* theWrappedObject)
9390 bool PythonQtWrapper_srecFile::isSREC(srecFile* theWrappedObject)
9386 {
9391 {
9387 return ( theWrappedObject->isSREC());
9392 return ( theWrappedObject->isSREC());
9388 }
9393 }
9389
9394
9390 bool PythonQtWrapper_srecFile::static_srecFile_isSREC(const QString& File)
9395 bool PythonQtWrapper_srecFile::static_srecFile_isSREC(const QString& File)
9391 {
9396 {
9392 return (srecFile::isSREC(File));
9397 return (srecFile::isSREC(File));
9393 }
9398 }
9394
9399
9395 bool PythonQtWrapper_srecFile::isopened(srecFile* theWrappedObject)
9400 bool PythonQtWrapper_srecFile::isopened(srecFile* theWrappedObject)
9396 {
9401 {
9397 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_isopened());
9402 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_isopened());
9398 }
9403 }
9399
9404
9400 int PythonQtWrapper_srecFile::lineCount(srecFile* theWrappedObject)
9405 int PythonQtWrapper_srecFile::lineCount(srecFile* theWrappedObject)
9401 {
9406 {
9402 return ( theWrappedObject->lineCount());
9407 return ( theWrappedObject->lineCount());
9403 }
9408 }
9404
9409
9405 bool PythonQtWrapper_srecFile::mergingRecords(srecFile* theWrappedObject)
9410 bool PythonQtWrapper_srecFile::mergingRecords(srecFile* theWrappedObject)
9406 {
9411 {
9407 return ( theWrappedObject->mergingRecords());
9412 return ( theWrappedObject->mergingRecords());
9408 }
9413 }
9409
9414
9410 bool PythonQtWrapper_srecFile::openFile(srecFile* theWrappedObject, const QString& File)
9415 bool PythonQtWrapper_srecFile::openFile(srecFile* theWrappedObject, const QString& File)
9411 {
9416 {
9412 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_openFile(File));
9417 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_openFile(File));
9413 }
9418 }
9414
9419
9415 bool PythonQtWrapper_srecFile::openFiles(srecFile* theWrappedObject, const QStringList& Files)
9420 bool PythonQtWrapper_srecFile::openFiles(srecFile* theWrappedObject, const QStringList& Files)
9416 {
9421 {
9417 return ( theWrappedObject->openFiles(Files));
9422 return ( theWrappedObject->openFiles(Files));
9418 }
9423 }
9419
9424
9420 void PythonQtWrapper_srecFile::setMergingRecords(srecFile* theWrappedObject, bool enabled)
9425 void PythonQtWrapper_srecFile::setMergingRecords(srecFile* theWrappedObject, bool enabled)
9421 {
9426 {
9422 ( theWrappedObject->setMergingRecords(enabled));
9427 ( theWrappedObject->setMergingRecords(enabled));
9423 }
9428 }
9424
9429
9425 bool PythonQtWrapper_srecFile::toBinary(srecFile* theWrappedObject, const QString& File)
9430 bool PythonQtWrapper_srecFile::toBinary(srecFile* theWrappedObject, const QString& File)
9426 {
9431 {
9427 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_toBinary(File));
9432 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_toBinary(File));
9428 }
9433 }
9429
9434
9430 bool PythonQtWrapper_srecFile::static_srecFile_toSrec(QList<codeFragment* > fragments, const QString& File)
9435 bool PythonQtWrapper_srecFile::static_srecFile_toSrec(QList<codeFragment* > fragments, const QString& File)
9431 {
9436 {
9432 return (srecFile::toSrec(fragments, File));
9437 return (srecFile::toSrec(fragments, File));
9433 }
9438 }
9434
9439
9435 bool PythonQtWrapper_srecFile::toSrec(srecFile* theWrappedObject, const QString& File)
9440 bool PythonQtWrapper_srecFile::toSrec(srecFile* theWrappedObject, const QString& File)
9436 {
9441 {
9437 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_toSrec(File));
9442 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_toSrec(File));
9438 }
9443 }
9439
9444
9440
9445
9441
9446
9442 PythonQtShell_srecFileWidget::~PythonQtShell_srecFileWidget() {
9447 PythonQtShell_srecFileWidget::~PythonQtShell_srecFileWidget() {
9443 PythonQtPrivate* priv = PythonQt::priv();
9448 PythonQtPrivate* priv = PythonQt::priv();
9444 if (priv) { priv->shellClassDeleted(this); }
9449 if (priv) { priv->shellClassDeleted(this); }
9445 }
9450 }
9446 void PythonQtShell_srecFileWidget::reloadFile()
9451 void PythonQtShell_srecFileWidget::reloadFile()
9447 {
9452 {
9448 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9453 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9449 static PyObject* name = PyString_FromString("reloadFile");
9454 static PyObject* name = PyString_FromString("reloadFile");
9450 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9455 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9451 if (obj) {
9456 if (obj) {
9452 static const char* argumentList[] ={""};
9457 static const char* argumentList[] ={""};
9453 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9458 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
9454 void* args[1] = {NULL};
9459 void* args[1] = {NULL};
9455 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9460 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9456 if (result) { Py_DECREF(result); }
9461 if (result) { Py_DECREF(result); }
9457 Py_DECREF(obj);
9462 Py_DECREF(obj);
9458 return;
9463 return;
9459 } else {
9464 } else {
9460 PyErr_Clear();
9465 PyErr_Clear();
9461 }
9466 }
9462 }
9467 }
9463 srecFileWidget::reloadFile();
9468 srecFileWidget::reloadFile();
9464 }
9469 }
9465 void PythonQtShell_srecFileWidget::setFile(abstractBinFile* file0)
9470 void PythonQtShell_srecFileWidget::setFile(abstractBinFile* file0)
9466 {
9471 {
9467 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9472 if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
9468 static PyObject* name = PyString_FromString("setFile");
9473 static PyObject* name = PyString_FromString("setFile");
9469 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9474 PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
9470 if (obj) {
9475 if (obj) {
9471 static const char* argumentList[] ={"" , "abstractBinFile*"};
9476 static const char* argumentList[] ={"" , "abstractBinFile*"};
9472 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9477 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
9473 void* args[2] = {NULL, (void*)&file0};
9478 void* args[2] = {NULL, (void*)&file0};
9474 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9479 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
9475 if (result) { Py_DECREF(result); }
9480 if (result) { Py_DECREF(result); }
9476 Py_DECREF(obj);
9481 Py_DECREF(obj);
9477 return;
9482 return;
9478 } else {
9483 } else {
9479 PyErr_Clear();
9484 PyErr_Clear();
9480 }
9485 }
9481 }
9486 }
9482 srecFileWidget::setFile(file0);
9487 srecFileWidget::setFile(file0);
9483 }
9488 }
9484 srecFileWidget* PythonQtWrapper_srecFileWidget::new_srecFileWidget(QWidget* parent)
9489 srecFileWidget* PythonQtWrapper_srecFileWidget::new_srecFileWidget(QWidget* parent)
9485 {
9490 {
9486 return new PythonQtShell_srecFileWidget(parent); }
9491 return new PythonQtShell_srecFileWidget(parent); }
9487
9492
9488 void PythonQtWrapper_srecFileWidget::reloadFile(srecFileWidget* theWrappedObject)
9493 void PythonQtWrapper_srecFileWidget::reloadFile(srecFileWidget* theWrappedObject)
9489 {
9494 {
9490 ( ((PythonQtPublicPromoter_srecFileWidget*)theWrappedObject)->promoted_reloadFile());
9495 ( ((PythonQtPublicPromoter_srecFileWidget*)theWrappedObject)->promoted_reloadFile());
9491 }
9496 }
9492
9497
9493 void PythonQtWrapper_srecFileWidget::setFile(srecFileWidget* theWrappedObject, abstractBinFile* file)
9498 void PythonQtWrapper_srecFileWidget::setFile(srecFileWidget* theWrappedObject, abstractBinFile* file)
9494 {
9499 {
9495 ( ((PythonQtPublicPromoter_srecFileWidget*)theWrappedObject)->promoted_setFile(file));
9500 ( ((PythonQtPublicPromoter_srecFileWidget*)theWrappedObject)->promoted_setFile(file));
9496 }
9501 }
9497
9502
9498
9503
@@ -1,1125 +1,1126
1 #include <PythonQt.h>
1 #include <PythonQt.h>
2 #include <QObject>
2 #include <QObject>
3 #include <QVariant>
3 #include <QVariant>
4 #include <SocExplorerPlot.h>
4 #include <SocExplorerPlot.h>
5 #include <abstractbinfile.h>
5 #include <abstractbinfile.h>
6 #include <binaryfile.h>
6 #include <binaryfile.h>
7 #include <binaryfilewidget.h>
7 #include <binaryfilewidget.h>
8 #include <elffile.h>
8 #include <elffile.h>
9 #include <elffilewidget.h>
9 #include <elffilewidget.h>
10 #include <elfinfowdgt.h>
10 #include <elfinfowdgt.h>
11 #include <elfparser.h>
11 #include <elfparser.h>
12 #include <genericbinaryfilewidget.h>
12 #include <genericbinaryfilewidget.h>
13 #include <memsizewdgt.h>
13 #include <memsizewdgt.h>
14 #include <qaction.h>
14 #include <qaction.h>
15 #include <qbackingstore.h>
15 #include <qbackingstore.h>
16 #include <qbitmap.h>
16 #include <qbitmap.h>
17 #include <qbytearray.h>
17 #include <qbytearray.h>
18 #include <qcolor.h>
18 #include <qcolor.h>
19 #include <qcoreevent.h>
19 #include <qcoreevent.h>
20 #include <qcursor.h>
20 #include <qcursor.h>
21 #include <qevent.h>
21 #include <qevent.h>
22 #include <qfile.h>
22 #include <qfile.h>
23 #include <qfont.h>
23 #include <qfont.h>
24 #include <qgraphicseffect.h>
24 #include <qgraphicseffect.h>
25 #include <qgraphicsproxywidget.h>
25 #include <qgraphicsproxywidget.h>
26 #include <qhexedit.h>
26 #include <qhexedit.h>
27 #include <qhexspinbox.h>
27 #include <qhexspinbox.h>
28 #include <qicon.h>
28 #include <qicon.h>
29 #include <qkeysequence.h>
29 #include <qkeysequence.h>
30 #include <qlayout.h>
30 #include <qlayout.h>
31 #include <qlineedit.h>
31 #include <qlineedit.h>
32 #include <qlist.h>
32 #include <qlist.h>
33 #include <qlocale.h>
33 #include <qlocale.h>
34 #include <qmargins.h>
34 #include <qmargins.h>
35 #include <qmetaobject.h>
35 #include <qmetaobject.h>
36 #include <qobject.h>
36 #include <qobject.h>
37 #include <qpaintdevice.h>
37 #include <qpaintdevice.h>
38 #include <qpaintengine.h>
38 #include <qpaintengine.h>
39 #include <qpainter.h>
39 #include <qpainter.h>
40 #include <qpalette.h>
40 #include <qpalette.h>
41 #include <qpen.h>
41 #include <qpen.h>
42 #include <qpixmap.h>
42 #include <qpixmap.h>
43 #include <qpoint.h>
43 #include <qpoint.h>
44 #include <qrect.h>
44 #include <qrect.h>
45 #include <qregion.h>
45 #include <qregion.h>
46 #include <qscrollarea.h>
46 #include <qscrollarea.h>
47 #include <qscrollbar.h>
47 #include <qscrollbar.h>
48 #include <qsize.h>
48 #include <qsize.h>
49 #include <qsizepolicy.h>
49 #include <qsizepolicy.h>
50 #include <qspinbox.h>
50 #include <qspinbox.h>
51 #include <qstringlist.h>
51 #include <qstringlist.h>
52 #include <qstyle.h>
52 #include <qstyle.h>
53 #include <qstyleoption.h>
53 #include <qstyleoption.h>
54 #include <qwidget.h>
54 #include <qwidget.h>
55 #include <qwindow.h>
55 #include <qwindow.h>
56 #include <srecfile.h>
56 #include <srecfile.h>
57 #include <srecfilewidget.h>
57 #include <srecfilewidget.h>
58 #include <tcp_terminal_client.h>
58 #include <tcp_terminal_client.h>
59 #include <xbytearray.h>
59 #include <xbytearray.h>
60
60
61
61
62
62
63 class PythonQtShell_ElfFile : public ElfFile
63 class PythonQtShell_ElfFile : public ElfFile
64 {
64 {
65 public:
65 public:
66 PythonQtShell_ElfFile():ElfFile(),_wrapper(NULL) { };
66 PythonQtShell_ElfFile():ElfFile(),_wrapper(NULL) { };
67 PythonQtShell_ElfFile(const QString& File):ElfFile(File),_wrapper(NULL) { };
67 PythonQtShell_ElfFile(const QString& File):ElfFile(File),_wrapper(NULL) { };
68
68
69 ~PythonQtShell_ElfFile();
69 ~PythonQtShell_ElfFile();
70
70
71 virtual int closeFile();
71 virtual int closeFile();
72 virtual QList<codeFragment* > getFragments();
72 virtual QList<codeFragment* > getFragments();
73 virtual bool isopened();
73 virtual bool isopened();
74 virtual bool openFile(const QString& File);
74 virtual bool openFile(const QString& File);
75 virtual bool toBinary(const QString& File);
75 virtual bool toBinary(const QString& File);
76 virtual bool toSrec(const QString& File);
76 virtual bool toSrec(const QString& File);
77
77
78 PythonQtInstanceWrapper* _wrapper;
78 PythonQtInstanceWrapper* _wrapper;
79 };
79 };
80
80
81 class PythonQtPublicPromoter_ElfFile : public ElfFile
81 class PythonQtPublicPromoter_ElfFile : public ElfFile
82 { public:
82 { public:
83 inline int promoted_closeFile() { return ElfFile::closeFile(); }
83 inline int promoted_closeFile() { return ElfFile::closeFile(); }
84 inline QList<codeFragment* > promoted_getFragments() { return ElfFile::getFragments(); }
84 inline QList<codeFragment* > promoted_getFragments() { return ElfFile::getFragments(); }
85 inline bool promoted_isopened() { return ElfFile::isopened(); }
85 inline bool promoted_isopened() { return ElfFile::isopened(); }
86 inline bool promoted_openFile(const QString& File) { return ElfFile::openFile(File); }
86 inline bool promoted_openFile(const QString& File) { return ElfFile::openFile(File); }
87 inline bool promoted_toBinary(const QString& File) { return ElfFile::toBinary(File); }
87 inline bool promoted_toBinary(const QString& File) { return ElfFile::toBinary(File); }
88 inline bool promoted_toSrec(const QString& File) { return ElfFile::toSrec(File); }
88 inline bool promoted_toSrec(const QString& File) { return ElfFile::toSrec(File); }
89 };
89 };
90
90
91 class PythonQtWrapper_ElfFile : public QObject
91 class PythonQtWrapper_ElfFile : public QObject
92 { Q_OBJECT
92 { Q_OBJECT
93 public:
93 public:
94 public slots:
94 public slots:
95 ElfFile* new_ElfFile();
95 ElfFile* new_ElfFile();
96 ElfFile* new_ElfFile(const QString& File);
96 ElfFile* new_ElfFile(const QString& File);
97 void delete_ElfFile(ElfFile* obj) { delete obj; }
97 void delete_ElfFile(ElfFile* obj) { delete obj; }
98 int closeFile(ElfFile* theWrappedObject);
98 int closeFile(ElfFile* theWrappedObject);
99 QString getABI(ElfFile* theWrappedObject);
99 QString getABI(ElfFile* theWrappedObject);
100 QString getArchitecture(ElfFile* theWrappedObject);
100 QString getArchitecture(ElfFile* theWrappedObject);
101 QString getClass(ElfFile* theWrappedObject);
101 QString getClass(ElfFile* theWrappedObject);
102 QString getEndianness(ElfFile* theWrappedObject);
102 QString getEndianness(ElfFile* theWrappedObject);
103 qint64 getEntryPointAddress(ElfFile* theWrappedObject);
103 qint64 getEntryPointAddress(ElfFile* theWrappedObject);
104 QList<codeFragment* > getFragments(ElfFile* theWrappedObject);
104 QList<codeFragment* > getFragments(ElfFile* theWrappedObject);
105 QList<codeFragment* > getFragments(ElfFile* theWrappedObject, QStringList fragmentList);
105 QList<codeFragment* > getFragments(ElfFile* theWrappedObject, QStringList fragmentList);
106 int getSectionCount(ElfFile* theWrappedObject);
106 int getSectionCount(ElfFile* theWrappedObject);
107 bool getSectionData(ElfFile* theWrappedObject, int index, char** buffer);
107 bool getSectionData(ElfFile* theWrappedObject, int index, char** buffer);
108 qint64 getSectionDatasz(ElfFile* theWrappedObject, int index);
108 qint64 getSectionDatasz(ElfFile* theWrappedObject, int index);
109 int getSectionIndex(ElfFile* theWrappedObject, QString name);
109 int getSectionIndex(ElfFile* theWrappedObject, QString name);
110 qint64 getSectionMemsz(ElfFile* theWrappedObject, int index);
110 qint64 getSectionMemsz(ElfFile* theWrappedObject, int index);
111 QString getSectionName(ElfFile* theWrappedObject, int index);
111 QString getSectionName(ElfFile* theWrappedObject, int index);
112 qint64 getSectionPaddr(ElfFile* theWrappedObject, int index);
112 qint64 getSectionPaddr(ElfFile* theWrappedObject, int index);
113 QString getSectionType(ElfFile* theWrappedObject, int index);
113 QString getSectionType(ElfFile* theWrappedObject, int index);
114 int getSegmentCount(ElfFile* theWrappedObject);
114 int getSegmentCount(ElfFile* theWrappedObject);
115 qint64 getSegmentFilesz(ElfFile* theWrappedObject, int index);
115 qint64 getSegmentFilesz(ElfFile* theWrappedObject, int index);
116 QString getSegmentFlags(ElfFile* theWrappedObject, int index);
116 QString getSegmentFlags(ElfFile* theWrappedObject, int index);
117 qint64 getSegmentMemsz(ElfFile* theWrappedObject, int index);
117 qint64 getSegmentMemsz(ElfFile* theWrappedObject, int index);
118 qint64 getSegmentOffset(ElfFile* theWrappedObject, int index);
118 qint64 getSegmentOffset(ElfFile* theWrappedObject, int index);
119 qint64 getSegmentPaddr(ElfFile* theWrappedObject, int index);
119 qint64 getSegmentPaddr(ElfFile* theWrappedObject, int index);
120 QString getSegmentType(ElfFile* theWrappedObject, int index);
120 QString getSegmentType(ElfFile* theWrappedObject, int index);
121 qint64 getSegmentVaddr(ElfFile* theWrappedObject, int index);
121 qint64 getSegmentVaddr(ElfFile* theWrappedObject, int index);
122 quint64 getSymbolAddress(ElfFile* theWrappedObject, int index);
122 quint64 getSymbolAddress(ElfFile* theWrappedObject, int index);
123 int getSymbolCount(ElfFile* theWrappedObject);
123 int getSymbolCount(ElfFile* theWrappedObject);
124 int getSymbolIndex(ElfFile* theWrappedObject, const QString& name);
124 QString getSymbolLinkType(ElfFile* theWrappedObject, int index);
125 QString getSymbolLinkType(ElfFile* theWrappedObject, int index);
125 QString getSymbolName(ElfFile* theWrappedObject, int index);
126 QString getSymbolName(ElfFile* theWrappedObject, int index);
126 int getSymbolSectionIndex(ElfFile* theWrappedObject, int index);
127 int getSymbolSectionIndex(ElfFile* theWrappedObject, int index);
127 QString getSymbolSectionName(ElfFile* theWrappedObject, int index);
128 QString getSymbolSectionName(ElfFile* theWrappedObject, int index);
128 quint64 getSymbolSize(ElfFile* theWrappedObject, int index);
129 quint64 getSymbolSize(ElfFile* theWrappedObject, int index);
129 QString getSymbolType(ElfFile* theWrappedObject, int index);
130 QString getSymbolType(ElfFile* theWrappedObject, int index);
130 QString getType(ElfFile* theWrappedObject);
131 QString getType(ElfFile* theWrappedObject);
131 qint64 getVersion(ElfFile* theWrappedObject);
132 qint64 getVersion(ElfFile* theWrappedObject);
132 bool isBigEndian(ElfFile* theWrappedObject);
133 bool isBigEndian(ElfFile* theWrappedObject);
133 bool static_ElfFile_isElf(const QString& File);
134 bool static_ElfFile_isElf(const QString& File);
134 bool isLitleEndian(ElfFile* theWrappedObject);
135 bool isLitleEndian(ElfFile* theWrappedObject);
135 bool iself(ElfFile* theWrappedObject);
136 bool iself(ElfFile* theWrappedObject);
136 bool isopened(ElfFile* theWrappedObject);
137 bool isopened(ElfFile* theWrappedObject);
137 bool openFile(ElfFile* theWrappedObject, const QString& File);
138 bool openFile(ElfFile* theWrappedObject, const QString& File);
138 bool sectionIsNobits(ElfFile* theWrappedObject, int index);
139 bool sectionIsNobits(ElfFile* theWrappedObject, int index);
139 bool toBinary(ElfFile* theWrappedObject, const QString& File);
140 bool toBinary(ElfFile* theWrappedObject, const QString& File);
140 bool toSrec(ElfFile* theWrappedObject, const QString& File);
141 bool toSrec(ElfFile* theWrappedObject, const QString& File);
141 };
142 };
142
143
143
144
144
145
145
146
146
147
147 class PythonQtShell_MemSizeWdgt : public MemSizeWdgt
148 class PythonQtShell_MemSizeWdgt : public MemSizeWdgt
148 {
149 {
149 public:
150 public:
150 PythonQtShell_MemSizeWdgt(QWidget* parent = 0):MemSizeWdgt(parent),_wrapper(NULL) { };
151 PythonQtShell_MemSizeWdgt(QWidget* parent = 0):MemSizeWdgt(parent),_wrapper(NULL) { };
151 PythonQtShell_MemSizeWdgt(int defaultSize, QWidget* parent = 0):MemSizeWdgt(defaultSize, parent),_wrapper(NULL) { };
152 PythonQtShell_MemSizeWdgt(int defaultSize, QWidget* parent = 0):MemSizeWdgt(defaultSize, parent),_wrapper(NULL) { };
152
153
153 ~PythonQtShell_MemSizeWdgt();
154 ~PythonQtShell_MemSizeWdgt();
154
155
155 virtual void actionEvent(QActionEvent* arg__1);
156 virtual void actionEvent(QActionEvent* arg__1);
156 virtual void changeEvent(QEvent* arg__1);
157 virtual void changeEvent(QEvent* arg__1);
157 virtual void childEvent(QChildEvent* arg__1);
158 virtual void childEvent(QChildEvent* arg__1);
158 virtual void closeEvent(QCloseEvent* arg__1);
159 virtual void closeEvent(QCloseEvent* arg__1);
159 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
160 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
160 virtual void customEvent(QEvent* arg__1);
161 virtual void customEvent(QEvent* arg__1);
161 virtual int devType() const;
162 virtual int devType() const;
162 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
163 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
163 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
164 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
164 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
165 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
165 virtual void dropEvent(QDropEvent* arg__1);
166 virtual void dropEvent(QDropEvent* arg__1);
166 virtual void enterEvent(QEvent* arg__1);
167 virtual void enterEvent(QEvent* arg__1);
167 virtual bool event(QEvent* arg__1);
168 virtual bool event(QEvent* arg__1);
168 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
169 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
169 virtual void focusInEvent(QFocusEvent* arg__1);
170 virtual void focusInEvent(QFocusEvent* arg__1);
170 virtual bool focusNextPrevChild(bool next);
171 virtual bool focusNextPrevChild(bool next);
171 virtual void focusOutEvent(QFocusEvent* arg__1);
172 virtual void focusOutEvent(QFocusEvent* arg__1);
172 virtual bool hasHeightForWidth() const;
173 virtual bool hasHeightForWidth() const;
173 virtual int heightForWidth(int arg__1) const;
174 virtual int heightForWidth(int arg__1) const;
174 virtual void hideEvent(QHideEvent* arg__1);
175 virtual void hideEvent(QHideEvent* arg__1);
175 virtual void initPainter(QPainter* painter) const;
176 virtual void initPainter(QPainter* painter) const;
176 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
177 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
177 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
178 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
178 virtual void keyPressEvent(QKeyEvent* arg__1);
179 virtual void keyPressEvent(QKeyEvent* arg__1);
179 virtual void keyReleaseEvent(QKeyEvent* arg__1);
180 virtual void keyReleaseEvent(QKeyEvent* arg__1);
180 virtual void leaveEvent(QEvent* arg__1);
181 virtual void leaveEvent(QEvent* arg__1);
181 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
182 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
182 virtual QSize minimumSizeHint() const;
183 virtual QSize minimumSizeHint() const;
183 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
184 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
184 virtual void mouseMoveEvent(QMouseEvent* arg__1);
185 virtual void mouseMoveEvent(QMouseEvent* arg__1);
185 virtual void mousePressEvent(QMouseEvent* arg__1);
186 virtual void mousePressEvent(QMouseEvent* arg__1);
186 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
187 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
187 virtual void moveEvent(QMoveEvent* arg__1);
188 virtual void moveEvent(QMoveEvent* arg__1);
188 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
189 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
189 virtual QPaintEngine* paintEngine() const;
190 virtual QPaintEngine* paintEngine() const;
190 virtual void paintEvent(QPaintEvent* arg__1);
191 virtual void paintEvent(QPaintEvent* arg__1);
191 virtual QPaintDevice* redirected(QPoint* offset) const;
192 virtual QPaintDevice* redirected(QPoint* offset) const;
192 virtual void resizeEvent(QResizeEvent* arg__1);
193 virtual void resizeEvent(QResizeEvent* arg__1);
193 virtual QPainter* sharedPainter() const;
194 virtual QPainter* sharedPainter() const;
194 virtual void showEvent(QShowEvent* arg__1);
195 virtual void showEvent(QShowEvent* arg__1);
195 virtual QSize sizeHint() const;
196 virtual QSize sizeHint() const;
196 virtual void tabletEvent(QTabletEvent* arg__1);
197 virtual void tabletEvent(QTabletEvent* arg__1);
197 virtual void timerEvent(QTimerEvent* arg__1);
198 virtual void timerEvent(QTimerEvent* arg__1);
198 virtual void wheelEvent(QWheelEvent* arg__1);
199 virtual void wheelEvent(QWheelEvent* arg__1);
199
200
200 PythonQtInstanceWrapper* _wrapper;
201 PythonQtInstanceWrapper* _wrapper;
201 };
202 };
202
203
203 class PythonQtWrapper_MemSizeWdgt : public QObject
204 class PythonQtWrapper_MemSizeWdgt : public QObject
204 { Q_OBJECT
205 { Q_OBJECT
205 public:
206 public:
206 public slots:
207 public slots:
207 MemSizeWdgt* new_MemSizeWdgt(QWidget* parent = 0);
208 MemSizeWdgt* new_MemSizeWdgt(QWidget* parent = 0);
208 MemSizeWdgt* new_MemSizeWdgt(int defaultSize, QWidget* parent = 0);
209 MemSizeWdgt* new_MemSizeWdgt(int defaultSize, QWidget* parent = 0);
209 void delete_MemSizeWdgt(MemSizeWdgt* obj) { delete obj; }
210 void delete_MemSizeWdgt(MemSizeWdgt* obj) { delete obj; }
210 int getsize(MemSizeWdgt* theWrappedObject);
211 int getsize(MemSizeWdgt* theWrappedObject);
211 void setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max);
212 void setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max);
212 void show(MemSizeWdgt* theWrappedObject);
213 void show(MemSizeWdgt* theWrappedObject);
213 void updateSizeValue(MemSizeWdgt* theWrappedObject);
214 void updateSizeValue(MemSizeWdgt* theWrappedObject);
214 };
215 };
215
216
216
217
217
218
218
219
219
220
220 class PythonQtShell_QHexEdit : public QHexEdit
221 class PythonQtShell_QHexEdit : public QHexEdit
221 {
222 {
222 public:
223 public:
223 PythonQtShell_QHexEdit(QWidget* parent = 0):QHexEdit(parent),_wrapper(NULL) { };
224 PythonQtShell_QHexEdit(QWidget* parent = 0):QHexEdit(parent),_wrapper(NULL) { };
224
225
225 ~PythonQtShell_QHexEdit();
226 ~PythonQtShell_QHexEdit();
226
227
227 virtual void actionEvent(QActionEvent* arg__1);
228 virtual void actionEvent(QActionEvent* arg__1);
228 virtual void changeEvent(QEvent* arg__1);
229 virtual void changeEvent(QEvent* arg__1);
229 virtual void childEvent(QChildEvent* arg__1);
230 virtual void childEvent(QChildEvent* arg__1);
230 virtual void closeEvent(QCloseEvent* arg__1);
231 virtual void closeEvent(QCloseEvent* arg__1);
231 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
232 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
232 virtual void customEvent(QEvent* arg__1);
233 virtual void customEvent(QEvent* arg__1);
233 virtual int devType() const;
234 virtual int devType() const;
234 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
235 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
235 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
236 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
236 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
237 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
237 virtual void dropEvent(QDropEvent* arg__1);
238 virtual void dropEvent(QDropEvent* arg__1);
238 virtual void enterEvent(QEvent* arg__1);
239 virtual void enterEvent(QEvent* arg__1);
239 virtual bool event(QEvent* arg__1);
240 virtual bool event(QEvent* arg__1);
240 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
241 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
241 virtual void focusInEvent(QFocusEvent* arg__1);
242 virtual void focusInEvent(QFocusEvent* arg__1);
242 virtual bool focusNextPrevChild(bool next);
243 virtual bool focusNextPrevChild(bool next);
243 virtual void focusOutEvent(QFocusEvent* arg__1);
244 virtual void focusOutEvent(QFocusEvent* arg__1);
244 virtual bool hasHeightForWidth() const;
245 virtual bool hasHeightForWidth() const;
245 virtual int heightForWidth(int arg__1) const;
246 virtual int heightForWidth(int arg__1) const;
246 virtual void hideEvent(QHideEvent* arg__1);
247 virtual void hideEvent(QHideEvent* arg__1);
247 virtual void initPainter(QPainter* painter) const;
248 virtual void initPainter(QPainter* painter) const;
248 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
249 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
249 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
250 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
250 virtual void keyPressEvent(QKeyEvent* arg__1);
251 virtual void keyPressEvent(QKeyEvent* arg__1);
251 virtual void keyReleaseEvent(QKeyEvent* arg__1);
252 virtual void keyReleaseEvent(QKeyEvent* arg__1);
252 virtual void leaveEvent(QEvent* arg__1);
253 virtual void leaveEvent(QEvent* arg__1);
253 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
254 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
254 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
255 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
255 virtual void mouseMoveEvent(QMouseEvent* arg__1);
256 virtual void mouseMoveEvent(QMouseEvent* arg__1);
256 virtual void mousePressEvent(QMouseEvent* arg__1);
257 virtual void mousePressEvent(QMouseEvent* arg__1);
257 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
258 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
258 virtual void moveEvent(QMoveEvent* arg__1);
259 virtual void moveEvent(QMoveEvent* arg__1);
259 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
260 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
260 virtual QPaintEngine* paintEngine() const;
261 virtual QPaintEngine* paintEngine() const;
261 virtual void paintEvent(QPaintEvent* arg__1);
262 virtual void paintEvent(QPaintEvent* arg__1);
262 virtual QPaintDevice* redirected(QPoint* offset) const;
263 virtual QPaintDevice* redirected(QPoint* offset) const;
263 virtual void resizeEvent(QResizeEvent* arg__1);
264 virtual void resizeEvent(QResizeEvent* arg__1);
264 virtual void scrollContentsBy(int dx, int dy);
265 virtual void scrollContentsBy(int dx, int dy);
265 virtual void setupViewport(QWidget* viewport);
266 virtual void setupViewport(QWidget* viewport);
266 virtual QPainter* sharedPainter() const;
267 virtual QPainter* sharedPainter() const;
267 virtual void showEvent(QShowEvent* arg__1);
268 virtual void showEvent(QShowEvent* arg__1);
268 virtual void tabletEvent(QTabletEvent* arg__1);
269 virtual void tabletEvent(QTabletEvent* arg__1);
269 virtual void timerEvent(QTimerEvent* arg__1);
270 virtual void timerEvent(QTimerEvent* arg__1);
270 virtual bool viewportEvent(QEvent* arg__1);
271 virtual bool viewportEvent(QEvent* arg__1);
271 virtual QSize viewportSizeHint() const;
272 virtual QSize viewportSizeHint() const;
272 virtual void wheelEvent(QWheelEvent* arg__1);
273 virtual void wheelEvent(QWheelEvent* arg__1);
273
274
274 PythonQtInstanceWrapper* _wrapper;
275 PythonQtInstanceWrapper* _wrapper;
275 };
276 };
276
277
277 class PythonQtWrapper_QHexEdit : public QObject
278 class PythonQtWrapper_QHexEdit : public QObject
278 { Q_OBJECT
279 { Q_OBJECT
279 public:
280 public:
280 public slots:
281 public slots:
281 QHexEdit* new_QHexEdit(QWidget* parent = 0);
282 QHexEdit* new_QHexEdit(QWidget* parent = 0);
282 void delete_QHexEdit(QHexEdit* obj) { delete obj; }
283 void delete_QHexEdit(QHexEdit* obj) { delete obj; }
283 QColor addressAreaColor(QHexEdit* theWrappedObject);
284 QColor addressAreaColor(QHexEdit* theWrappedObject);
284 int addressOffset(QHexEdit* theWrappedObject);
285 int addressOffset(QHexEdit* theWrappedObject);
285 int cursorPosition(QHexEdit* theWrappedObject);
286 int cursorPosition(QHexEdit* theWrappedObject);
286 QByteArray data(QHexEdit* theWrappedObject);
287 QByteArray data(QHexEdit* theWrappedObject);
287 const QFont* font(QHexEdit* theWrappedObject) const;
288 const QFont* font(QHexEdit* theWrappedObject) const;
288 int getSelectionBegin(QHexEdit* theWrappedObject);
289 int getSelectionBegin(QHexEdit* theWrappedObject);
289 int getSelectionEnd(QHexEdit* theWrappedObject);
290 int getSelectionEnd(QHexEdit* theWrappedObject);
290 QColor highlightingColor(QHexEdit* theWrappedObject);
291 QColor highlightingColor(QHexEdit* theWrappedObject);
291 int indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
292 int indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
292 void insert(QHexEdit* theWrappedObject, int i, char ch);
293 void insert(QHexEdit* theWrappedObject, int i, char ch);
293 void insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba);
294 void insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba);
294 bool isReadOnly(QHexEdit* theWrappedObject);
295 bool isReadOnly(QHexEdit* theWrappedObject);
295 int lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
296 int lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
296 bool overwriteMode(QHexEdit* theWrappedObject);
297 bool overwriteMode(QHexEdit* theWrappedObject);
297 void remove(QHexEdit* theWrappedObject, int pos, int len = 1);
298 void remove(QHexEdit* theWrappedObject, int pos, int len = 1);
298 void replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after);
299 void replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after);
299 void resetSelection(QHexEdit* theWrappedObject);
300 void resetSelection(QHexEdit* theWrappedObject);
300 void resetSelection(QHexEdit* theWrappedObject, int pos);
301 void resetSelection(QHexEdit* theWrappedObject, int pos);
301 QColor selectionColor(QHexEdit* theWrappedObject);
302 QColor selectionColor(QHexEdit* theWrappedObject);
302 QString selectionToReadableString(QHexEdit* theWrappedObject);
303 QString selectionToReadableString(QHexEdit* theWrappedObject);
303 void setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color);
304 void setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color);
304 void setAddressOffset(QHexEdit* theWrappedObject, int offset);
305 void setAddressOffset(QHexEdit* theWrappedObject, int offset);
305 void setCursorPosition(QHexEdit* theWrappedObject, int cusorPos);
306 void setCursorPosition(QHexEdit* theWrappedObject, int cusorPos);
306 void setData(QHexEdit* theWrappedObject, const QByteArray& data);
307 void setData(QHexEdit* theWrappedObject, const QByteArray& data);
307 void setFont(QHexEdit* theWrappedObject, const QFont& arg__1);
308 void setFont(QHexEdit* theWrappedObject, const QFont& arg__1);
308 void setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color);
309 void setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color);
309 void setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1);
310 void setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1);
310 void setReadOnly(QHexEdit* theWrappedObject, bool arg__1);
311 void setReadOnly(QHexEdit* theWrappedObject, bool arg__1);
311 void setSelection(QHexEdit* theWrappedObject, int pos);
312 void setSelection(QHexEdit* theWrappedObject, int pos);
312 void setSelectionColor(QHexEdit* theWrappedObject, const QColor& color);
313 void setSelectionColor(QHexEdit* theWrappedObject, const QColor& color);
313 QString toReadableString(QHexEdit* theWrappedObject);
314 QString toReadableString(QHexEdit* theWrappedObject);
314 };
315 };
315
316
316
317
317
318
318
319
319
320
320 class PythonQtShell_QHexSpinBox : public QHexSpinBox
321 class PythonQtShell_QHexSpinBox : public QHexSpinBox
321 {
322 {
322 public:
323 public:
323 PythonQtShell_QHexSpinBox(QWidget* parent = 0):QHexSpinBox(parent),_wrapper(NULL) { };
324 PythonQtShell_QHexSpinBox(QWidget* parent = 0):QHexSpinBox(parent),_wrapper(NULL) { };
324
325
325 ~PythonQtShell_QHexSpinBox();
326 ~PythonQtShell_QHexSpinBox();
326
327
327 virtual void actionEvent(QActionEvent* arg__1);
328 virtual void actionEvent(QActionEvent* arg__1);
328 virtual void changeEvent(QEvent* event);
329 virtual void changeEvent(QEvent* event);
329 virtual void childEvent(QChildEvent* arg__1);
330 virtual void childEvent(QChildEvent* arg__1);
330 virtual void clear();
331 virtual void clear();
331 virtual void closeEvent(QCloseEvent* event);
332 virtual void closeEvent(QCloseEvent* event);
332 virtual void contextMenuEvent(QContextMenuEvent* event);
333 virtual void contextMenuEvent(QContextMenuEvent* event);
333 virtual void customEvent(QEvent* arg__1);
334 virtual void customEvent(QEvent* arg__1);
334 virtual int devType() const;
335 virtual int devType() const;
335 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
336 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
336 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
337 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
337 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
338 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
338 virtual void dropEvent(QDropEvent* arg__1);
339 virtual void dropEvent(QDropEvent* arg__1);
339 virtual void enterEvent(QEvent* arg__1);
340 virtual void enterEvent(QEvent* arg__1);
340 virtual bool event(QEvent* event);
341 virtual bool event(QEvent* event);
341 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
342 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
342 virtual void fixup(QString& str) const;
343 virtual void fixup(QString& str) const;
343 virtual void focusInEvent(QFocusEvent* event);
344 virtual void focusInEvent(QFocusEvent* event);
344 virtual bool focusNextPrevChild(bool next);
345 virtual bool focusNextPrevChild(bool next);
345 virtual void focusOutEvent(QFocusEvent* event);
346 virtual void focusOutEvent(QFocusEvent* event);
346 virtual bool hasHeightForWidth() const;
347 virtual bool hasHeightForWidth() const;
347 virtual int heightForWidth(int arg__1) const;
348 virtual int heightForWidth(int arg__1) const;
348 virtual void hideEvent(QHideEvent* event);
349 virtual void hideEvent(QHideEvent* event);
349 virtual void initPainter(QPainter* painter) const;
350 virtual void initPainter(QPainter* painter) const;
350 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
351 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
351 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
352 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
352 virtual void keyPressEvent(QKeyEvent* event);
353 virtual void keyPressEvent(QKeyEvent* event);
353 virtual void keyReleaseEvent(QKeyEvent* event);
354 virtual void keyReleaseEvent(QKeyEvent* event);
354 virtual void leaveEvent(QEvent* arg__1);
355 virtual void leaveEvent(QEvent* arg__1);
355 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
356 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
356 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
357 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
357 virtual void mouseMoveEvent(QMouseEvent* event);
358 virtual void mouseMoveEvent(QMouseEvent* event);
358 virtual void mousePressEvent(QMouseEvent* event);
359 virtual void mousePressEvent(QMouseEvent* event);
359 virtual void mouseReleaseEvent(QMouseEvent* event);
360 virtual void mouseReleaseEvent(QMouseEvent* event);
360 virtual void moveEvent(QMoveEvent* arg__1);
361 virtual void moveEvent(QMoveEvent* arg__1);
361 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
362 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
362 virtual QPaintEngine* paintEngine() const;
363 virtual QPaintEngine* paintEngine() const;
363 virtual void paintEvent(QPaintEvent* event);
364 virtual void paintEvent(QPaintEvent* event);
364 virtual QPaintDevice* redirected(QPoint* offset) const;
365 virtual QPaintDevice* redirected(QPoint* offset) const;
365 virtual void resizeEvent(QResizeEvent* event);
366 virtual void resizeEvent(QResizeEvent* event);
366 virtual QPainter* sharedPainter() const;
367 virtual QPainter* sharedPainter() const;
367 virtual void showEvent(QShowEvent* event);
368 virtual void showEvent(QShowEvent* event);
368 virtual void stepBy(int steps);
369 virtual void stepBy(int steps);
369 virtual QAbstractSpinBox::StepEnabled stepEnabled() const;
370 virtual QAbstractSpinBox::StepEnabled stepEnabled() const;
370 virtual void tabletEvent(QTabletEvent* arg__1);
371 virtual void tabletEvent(QTabletEvent* arg__1);
371 virtual QString textFromValue(int value) const;
372 virtual QString textFromValue(int value) const;
372 virtual void timerEvent(QTimerEvent* event);
373 virtual void timerEvent(QTimerEvent* event);
373 virtual QValidator::State validate(QString& input, int& pos) const;
374 virtual QValidator::State validate(QString& input, int& pos) const;
374 virtual int valueFromText(const QString& text) const;
375 virtual int valueFromText(const QString& text) const;
375 virtual void wheelEvent(QWheelEvent* event);
376 virtual void wheelEvent(QWheelEvent* event);
376
377
377 PythonQtInstanceWrapper* _wrapper;
378 PythonQtInstanceWrapper* _wrapper;
378 };
379 };
379
380
380 class PythonQtPublicPromoter_QHexSpinBox : public QHexSpinBox
381 class PythonQtPublicPromoter_QHexSpinBox : public QHexSpinBox
381 { public:
382 { public:
382 inline QString promoted_textFromValue(int value) const { return QHexSpinBox::textFromValue(value); }
383 inline QString promoted_textFromValue(int value) const { return QHexSpinBox::textFromValue(value); }
383 inline QValidator::State promoted_validate(QString& input, int& pos) const { return QHexSpinBox::validate(input, pos); }
384 inline QValidator::State promoted_validate(QString& input, int& pos) const { return QHexSpinBox::validate(input, pos); }
384 inline int promoted_valueFromText(const QString& text) const { return QHexSpinBox::valueFromText(text); }
385 inline int promoted_valueFromText(const QString& text) const { return QHexSpinBox::valueFromText(text); }
385 };
386 };
386
387
387 class PythonQtWrapper_QHexSpinBox : public QObject
388 class PythonQtWrapper_QHexSpinBox : public QObject
388 { Q_OBJECT
389 { Q_OBJECT
389 public:
390 public:
390 public slots:
391 public slots:
391 QHexSpinBox* new_QHexSpinBox(QWidget* parent = 0);
392 QHexSpinBox* new_QHexSpinBox(QWidget* parent = 0);
392 void delete_QHexSpinBox(QHexSpinBox* obj) { delete obj; }
393 void delete_QHexSpinBox(QHexSpinBox* obj) { delete obj; }
393 void show(QHexSpinBox* theWrappedObject);
394 void show(QHexSpinBox* theWrappedObject);
394 QString textFromValue(QHexSpinBox* theWrappedObject, int value) const;
395 QString textFromValue(QHexSpinBox* theWrappedObject, int value) const;
395 QValidator::State validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const;
396 QValidator::State validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const;
396 int valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const;
397 int valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const;
397 };
398 };
398
399
399
400
400
401
401
402
402
403
403 class PythonQtShell_SocExplorerPlot : public SocExplorerPlot
404 class PythonQtShell_SocExplorerPlot : public SocExplorerPlot
404 {
405 {
405 public:
406 public:
406 PythonQtShell_SocExplorerPlot(QWidget* parent = 0):SocExplorerPlot(parent),_wrapper(NULL) { };
407 PythonQtShell_SocExplorerPlot(QWidget* parent = 0):SocExplorerPlot(parent),_wrapper(NULL) { };
407
408
408 ~PythonQtShell_SocExplorerPlot();
409 ~PythonQtShell_SocExplorerPlot();
409
410
410 virtual void actionEvent(QActionEvent* arg__1);
411 virtual void actionEvent(QActionEvent* arg__1);
411 virtual void changeEvent(QEvent* arg__1);
412 virtual void changeEvent(QEvent* arg__1);
412 virtual void childEvent(QChildEvent* arg__1);
413 virtual void childEvent(QChildEvent* arg__1);
413 virtual void closeEvent(QCloseEvent* arg__1);
414 virtual void closeEvent(QCloseEvent* arg__1);
414 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
415 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
415 virtual void customEvent(QEvent* arg__1);
416 virtual void customEvent(QEvent* arg__1);
416 virtual int devType() const;
417 virtual int devType() const;
417 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
418 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
418 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
419 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
419 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
420 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
420 virtual void dropEvent(QDropEvent* arg__1);
421 virtual void dropEvent(QDropEvent* arg__1);
421 virtual void enterEvent(QEvent* arg__1);
422 virtual void enterEvent(QEvent* arg__1);
422 virtual bool event(QEvent* arg__1);
423 virtual bool event(QEvent* arg__1);
423 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
424 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
424 virtual void focusInEvent(QFocusEvent* arg__1);
425 virtual void focusInEvent(QFocusEvent* arg__1);
425 virtual bool focusNextPrevChild(bool next);
426 virtual bool focusNextPrevChild(bool next);
426 virtual void focusOutEvent(QFocusEvent* arg__1);
427 virtual void focusOutEvent(QFocusEvent* arg__1);
427 virtual bool hasHeightForWidth() const;
428 virtual bool hasHeightForWidth() const;
428 virtual int heightForWidth(int arg__1) const;
429 virtual int heightForWidth(int arg__1) const;
429 virtual void hideEvent(QHideEvent* arg__1);
430 virtual void hideEvent(QHideEvent* arg__1);
430 virtual void initPainter(QPainter* painter) const;
431 virtual void initPainter(QPainter* painter) const;
431 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
432 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
432 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
433 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
433 virtual void keyPressEvent(QKeyEvent* arg__1);
434 virtual void keyPressEvent(QKeyEvent* arg__1);
434 virtual void keyReleaseEvent(QKeyEvent* arg__1);
435 virtual void keyReleaseEvent(QKeyEvent* arg__1);
435 virtual void leaveEvent(QEvent* arg__1);
436 virtual void leaveEvent(QEvent* arg__1);
436 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
437 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
437 virtual QSize minimumSizeHint() const;
438 virtual QSize minimumSizeHint() const;
438 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
439 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
439 virtual void mouseMoveEvent(QMouseEvent* arg__1);
440 virtual void mouseMoveEvent(QMouseEvent* arg__1);
440 virtual void mousePressEvent(QMouseEvent* arg__1);
441 virtual void mousePressEvent(QMouseEvent* arg__1);
441 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
442 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
442 virtual void moveEvent(QMoveEvent* arg__1);
443 virtual void moveEvent(QMoveEvent* arg__1);
443 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
444 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
444 virtual QPaintEngine* paintEngine() const;
445 virtual QPaintEngine* paintEngine() const;
445 virtual void paintEvent(QPaintEvent* arg__1);
446 virtual void paintEvent(QPaintEvent* arg__1);
446 virtual QPaintDevice* redirected(QPoint* offset) const;
447 virtual QPaintDevice* redirected(QPoint* offset) const;
447 virtual void resizeEvent(QResizeEvent* arg__1);
448 virtual void resizeEvent(QResizeEvent* arg__1);
448 virtual QPainter* sharedPainter() const;
449 virtual QPainter* sharedPainter() const;
449 virtual void showEvent(QShowEvent* arg__1);
450 virtual void showEvent(QShowEvent* arg__1);
450 virtual QSize sizeHint() const;
451 virtual QSize sizeHint() const;
451 virtual void tabletEvent(QTabletEvent* arg__1);
452 virtual void tabletEvent(QTabletEvent* arg__1);
452 virtual void timerEvent(QTimerEvent* arg__1);
453 virtual void timerEvent(QTimerEvent* arg__1);
453 virtual void wheelEvent(QWheelEvent* arg__1);
454 virtual void wheelEvent(QWheelEvent* arg__1);
454
455
455 PythonQtInstanceWrapper* _wrapper;
456 PythonQtInstanceWrapper* _wrapper;
456 };
457 };
457
458
458 class PythonQtPublicPromoter_SocExplorerPlot : public SocExplorerPlot
459 class PythonQtPublicPromoter_SocExplorerPlot : public SocExplorerPlot
459 { public:
460 { public:
460 inline void promoted_keyPressEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyPressEvent(arg__1); }
461 inline void promoted_keyPressEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyPressEvent(arg__1); }
461 inline void promoted_keyReleaseEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyReleaseEvent(arg__1); }
462 inline void promoted_keyReleaseEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyReleaseEvent(arg__1); }
462 inline void promoted_mouseMoveEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseMoveEvent(arg__1); }
463 inline void promoted_mouseMoveEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseMoveEvent(arg__1); }
463 inline void promoted_mousePressEvent(QMouseEvent* arg__1) { SocExplorerPlot::mousePressEvent(arg__1); }
464 inline void promoted_mousePressEvent(QMouseEvent* arg__1) { SocExplorerPlot::mousePressEvent(arg__1); }
464 inline void promoted_mouseReleaseEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseReleaseEvent(arg__1); }
465 inline void promoted_mouseReleaseEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseReleaseEvent(arg__1); }
465 inline void promoted_wheelEvent(QWheelEvent* arg__1) { SocExplorerPlot::wheelEvent(arg__1); }
466 inline void promoted_wheelEvent(QWheelEvent* arg__1) { SocExplorerPlot::wheelEvent(arg__1); }
466 };
467 };
467
468
468 class PythonQtWrapper_SocExplorerPlot : public QObject
469 class PythonQtWrapper_SocExplorerPlot : public QObject
469 { Q_OBJECT
470 { Q_OBJECT
470 public:
471 public:
471 public slots:
472 public slots:
472 SocExplorerPlot* new_SocExplorerPlot(QWidget* parent = 0);
473 SocExplorerPlot* new_SocExplorerPlot(QWidget* parent = 0);
473 void delete_SocExplorerPlot(SocExplorerPlot* obj) { delete obj; }
474 void delete_SocExplorerPlot(SocExplorerPlot* obj) { delete obj; }
474 int addGraph(SocExplorerPlot* theWrappedObject);
475 int addGraph(SocExplorerPlot* theWrappedObject);
475 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
476 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
476 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y);
477 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y);
477 QPen getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex);
478 QPen getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex);
478 void keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
479 void keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
479 void keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
480 void keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
480 void mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
481 void mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
481 void mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
482 void mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
482 void mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
483 void mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
483 void removeAllGraphs(SocExplorerPlot* theWrappedObject);
484 void removeAllGraphs(SocExplorerPlot* theWrappedObject);
484 bool removeGraph(SocExplorerPlot* theWrappedObject, int graphIndex);
485 bool removeGraph(SocExplorerPlot* theWrappedObject, int graphIndex);
485 void replot(SocExplorerPlot* theWrappedObject);
486 void replot(SocExplorerPlot* theWrappedObject);
486 void rescaleAxis(SocExplorerPlot* theWrappedObject);
487 void rescaleAxis(SocExplorerPlot* theWrappedObject);
487 void setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable);
488 void setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable);
488 void setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
489 void setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
489 void setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle);
490 void setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle);
490 void setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name);
491 void setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name);
491 void setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen);
492 void setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen);
492 void setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle);
493 void setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle);
493 void setLegendFont(SocExplorerPlot* theWrappedObject, QFont font);
494 void setLegendFont(SocExplorerPlot* theWrappedObject, QFont font);
494 void setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font);
495 void setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font);
495 void setTitle(SocExplorerPlot* theWrappedObject, QString title);
496 void setTitle(SocExplorerPlot* theWrappedObject, QString title);
496 void setXaxisDateTimeFormat(SocExplorerPlot* theWrappedObject, const QString& format);
497 void setXaxisDateTimeFormat(SocExplorerPlot* theWrappedObject, const QString& format);
497 void setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
498 void setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
498 void setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
499 void setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
499 void setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
500 void setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
500 void setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
501 void setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
501 void show(SocExplorerPlot* theWrappedObject);
502 void show(SocExplorerPlot* theWrappedObject);
502 void wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1);
503 void wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1);
503 };
504 };
504
505
505
506
506
507
507
508
508
509
509 class PythonQtShell_TCP_Terminal_Client : public TCP_Terminal_Client
510 class PythonQtShell_TCP_Terminal_Client : public TCP_Terminal_Client
510 {
511 {
511 public:
512 public:
512 PythonQtShell_TCP_Terminal_Client(QObject* parent = 0):TCP_Terminal_Client(parent),_wrapper(NULL) { };
513 PythonQtShell_TCP_Terminal_Client(QObject* parent = 0):TCP_Terminal_Client(parent),_wrapper(NULL) { };
513
514
514 ~PythonQtShell_TCP_Terminal_Client();
515 ~PythonQtShell_TCP_Terminal_Client();
515
516
516 virtual void childEvent(QChildEvent* arg__1);
517 virtual void childEvent(QChildEvent* arg__1);
517 virtual void customEvent(QEvent* arg__1);
518 virtual void customEvent(QEvent* arg__1);
518 virtual bool event(QEvent* arg__1);
519 virtual bool event(QEvent* arg__1);
519 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
520 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
520 virtual void timerEvent(QTimerEvent* arg__1);
521 virtual void timerEvent(QTimerEvent* arg__1);
521
522
522 PythonQtInstanceWrapper* _wrapper;
523 PythonQtInstanceWrapper* _wrapper;
523 };
524 };
524
525
525 class PythonQtWrapper_TCP_Terminal_Client : public QObject
526 class PythonQtWrapper_TCP_Terminal_Client : public QObject
526 { Q_OBJECT
527 { Q_OBJECT
527 public:
528 public:
528 public slots:
529 public slots:
529 TCP_Terminal_Client* new_TCP_Terminal_Client(QObject* parent = 0);
530 TCP_Terminal_Client* new_TCP_Terminal_Client(QObject* parent = 0);
530 void delete_TCP_Terminal_Client(TCP_Terminal_Client* obj) { delete obj; }
531 void delete_TCP_Terminal_Client(TCP_Terminal_Client* obj) { delete obj; }
531 void connectToServer(TCP_Terminal_Client* theWrappedObject);
532 void connectToServer(TCP_Terminal_Client* theWrappedObject);
532 void connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port);
533 void connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port);
533 bool isConnected(TCP_Terminal_Client* theWrappedObject);
534 bool isConnected(TCP_Terminal_Client* theWrappedObject);
534 void sendText(TCP_Terminal_Client* theWrappedObject, const QString& text);
535 void sendText(TCP_Terminal_Client* theWrappedObject, const QString& text);
535 void startServer(TCP_Terminal_Client* theWrappedObject);
536 void startServer(TCP_Terminal_Client* theWrappedObject);
536 void startServer(TCP_Terminal_Client* theWrappedObject, int port);
537 void startServer(TCP_Terminal_Client* theWrappedObject, int port);
537 };
538 };
538
539
539
540
540
541
541
542
542
543
543 class PythonQtWrapper_XByteArray : public QObject
544 class PythonQtWrapper_XByteArray : public QObject
544 { Q_OBJECT
545 { Q_OBJECT
545 public:
546 public:
546 public slots:
547 public slots:
547 XByteArray* new_XByteArray();
548 XByteArray* new_XByteArray();
548 void delete_XByteArray(XByteArray* obj) { delete obj; }
549 void delete_XByteArray(XByteArray* obj) { delete obj; }
549 int addressOffset(XByteArray* theWrappedObject);
550 int addressOffset(XByteArray* theWrappedObject);
550 int addressWidth(XByteArray* theWrappedObject);
551 int addressWidth(XByteArray* theWrappedObject);
551 QChar asciiChar(XByteArray* theWrappedObject, int index);
552 QChar asciiChar(XByteArray* theWrappedObject, int index);
552 QByteArray* data(XByteArray* theWrappedObject);
553 QByteArray* data(XByteArray* theWrappedObject);
553 bool dataChanged(XByteArray* theWrappedObject, int i);
554 bool dataChanged(XByteArray* theWrappedObject, int i);
554 QByteArray dataChanged(XByteArray* theWrappedObject, int i, int len);
555 QByteArray dataChanged(XByteArray* theWrappedObject, int i, int len);
555 QByteArray* insert(XByteArray* theWrappedObject, int i, char ch);
556 QByteArray* insert(XByteArray* theWrappedObject, int i, char ch);
556 QByteArray* insert(XByteArray* theWrappedObject, int i, const QByteArray& ba);
557 QByteArray* insert(XByteArray* theWrappedObject, int i, const QByteArray& ba);
557 int realAddressNumbers(XByteArray* theWrappedObject);
558 int realAddressNumbers(XByteArray* theWrappedObject);
558 QByteArray* remove(XByteArray* theWrappedObject, int pos, int len);
559 QByteArray* remove(XByteArray* theWrappedObject, int pos, int len);
559 QByteArray* replace(XByteArray* theWrappedObject, int index, char ch);
560 QByteArray* replace(XByteArray* theWrappedObject, int index, char ch);
560 QByteArray* replace(XByteArray* theWrappedObject, int index, const QByteArray& ba);
561 QByteArray* replace(XByteArray* theWrappedObject, int index, const QByteArray& ba);
561 QByteArray* replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba);
562 QByteArray* replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba);
562 void setAddressOffset(XByteArray* theWrappedObject, int offset);
563 void setAddressOffset(XByteArray* theWrappedObject, int offset);
563 void setAddressWidth(XByteArray* theWrappedObject, int width);
564 void setAddressWidth(XByteArray* theWrappedObject, int width);
564 void setData(XByteArray* theWrappedObject, QByteArray data);
565 void setData(XByteArray* theWrappedObject, QByteArray data);
565 void setDataChanged(XByteArray* theWrappedObject, int i, bool state);
566 void setDataChanged(XByteArray* theWrappedObject, int i, bool state);
566 void setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state);
567 void setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state);
567 int size(XByteArray* theWrappedObject);
568 int size(XByteArray* theWrappedObject);
568 QString toRedableString(XByteArray* theWrappedObject, int start = 0, int end = -1);
569 QString toRedableString(XByteArray* theWrappedObject, int start = 0, int end = -1);
569 };
570 };
570
571
571
572
572
573
573
574
574
575
575 class PythonQtShell_abstractBinFile : public abstractBinFile
576 class PythonQtShell_abstractBinFile : public abstractBinFile
576 {
577 {
577 public:
578 public:
578 PythonQtShell_abstractBinFile():abstractBinFile(),_wrapper(NULL) { };
579 PythonQtShell_abstractBinFile():abstractBinFile(),_wrapper(NULL) { };
579
580
580 ~PythonQtShell_abstractBinFile();
581 ~PythonQtShell_abstractBinFile();
581
582
582 virtual void childEvent(QChildEvent* arg__1);
583 virtual void childEvent(QChildEvent* arg__1);
583 virtual int closeFile();
584 virtual int closeFile();
584 virtual void customEvent(QEvent* arg__1);
585 virtual void customEvent(QEvent* arg__1);
585 virtual bool event(QEvent* arg__1);
586 virtual bool event(QEvent* arg__1);
586 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
587 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
587 virtual QList<codeFragment* > getFragments();
588 virtual QList<codeFragment* > getFragments();
588 virtual bool isopened();
589 virtual bool isopened();
589 virtual bool openFile(const QString& File);
590 virtual bool openFile(const QString& File);
590 virtual void timerEvent(QTimerEvent* arg__1);
591 virtual void timerEvent(QTimerEvent* arg__1);
591 virtual bool toBinary(const QString& File);
592 virtual bool toBinary(const QString& File);
592 virtual bool toSrec(const QString& File);
593 virtual bool toSrec(const QString& File);
593
594
594 PythonQtInstanceWrapper* _wrapper;
595 PythonQtInstanceWrapper* _wrapper;
595 };
596 };
596
597
597 class PythonQtPublicPromoter_abstractBinFile : public abstractBinFile
598 class PythonQtPublicPromoter_abstractBinFile : public abstractBinFile
598 { public:
599 { public:
599 inline int promoted_closeFile() { return closeFile(); }
600 inline int promoted_closeFile() { return closeFile(); }
600 inline QList<codeFragment* > promoted_getFragments() { return getFragments(); }
601 inline QList<codeFragment* > promoted_getFragments() { return getFragments(); }
601 inline bool promoted_isopened() { return isopened(); }
602 inline bool promoted_isopened() { return isopened(); }
602 inline bool promoted_openFile(const QString& File) { return openFile(File); }
603 inline bool promoted_openFile(const QString& File) { return openFile(File); }
603 inline bool promoted_toBinary(const QString& File) { return toBinary(File); }
604 inline bool promoted_toBinary(const QString& File) { return toBinary(File); }
604 inline bool promoted_toSrec(const QString& File) { return toSrec(File); }
605 inline bool promoted_toSrec(const QString& File) { return toSrec(File); }
605 };
606 };
606
607
607 class PythonQtWrapper_abstractBinFile : public QObject
608 class PythonQtWrapper_abstractBinFile : public QObject
608 { Q_OBJECT
609 { Q_OBJECT
609 public:
610 public:
610 public slots:
611 public slots:
611 abstractBinFile* new_abstractBinFile();
612 abstractBinFile* new_abstractBinFile();
612 void delete_abstractBinFile(abstractBinFile* obj) { delete obj; }
613 void delete_abstractBinFile(abstractBinFile* obj) { delete obj; }
613 int closeFile(abstractBinFile* theWrappedObject);
614 int closeFile(abstractBinFile* theWrappedObject);
614 QList<codeFragment* > getFragments(abstractBinFile* theWrappedObject);
615 QList<codeFragment* > getFragments(abstractBinFile* theWrappedObject);
615 bool isopened(abstractBinFile* theWrappedObject);
616 bool isopened(abstractBinFile* theWrappedObject);
616 bool openFile(abstractBinFile* theWrappedObject, const QString& File);
617 bool openFile(abstractBinFile* theWrappedObject, const QString& File);
617 bool toBinary(abstractBinFile* theWrappedObject, const QString& File);
618 bool toBinary(abstractBinFile* theWrappedObject, const QString& File);
618 bool toSrec(abstractBinFile* theWrappedObject, const QString& File);
619 bool toSrec(abstractBinFile* theWrappedObject, const QString& File);
619 void py_set_litleendian(abstractBinFile* theWrappedObject, bool litleendian){ theWrappedObject->litleendian = litleendian; }
620 void py_set_litleendian(abstractBinFile* theWrappedObject, bool litleendian){ theWrappedObject->litleendian = litleendian; }
620 bool py_get_litleendian(abstractBinFile* theWrappedObject){ return theWrappedObject->litleendian; }
621 bool py_get_litleendian(abstractBinFile* theWrappedObject){ return theWrappedObject->litleendian; }
621 };
622 };
622
623
623
624
624
625
625
626
626
627
627 class PythonQtShell_abstractBinFileWidget : public abstractBinFileWidget
628 class PythonQtShell_abstractBinFileWidget : public abstractBinFileWidget
628 {
629 {
629 public:
630 public:
630 PythonQtShell_abstractBinFileWidget(QWidget* parent = 0):abstractBinFileWidget(parent),_wrapper(NULL) { };
631 PythonQtShell_abstractBinFileWidget(QWidget* parent = 0):abstractBinFileWidget(parent),_wrapper(NULL) { };
631
632
632 ~PythonQtShell_abstractBinFileWidget();
633 ~PythonQtShell_abstractBinFileWidget();
633
634
634 virtual void actionEvent(QActionEvent* arg__1);
635 virtual void actionEvent(QActionEvent* arg__1);
635 virtual void changeEvent(QEvent* arg__1);
636 virtual void changeEvent(QEvent* arg__1);
636 virtual void childEvent(QChildEvent* arg__1);
637 virtual void childEvent(QChildEvent* arg__1);
637 virtual void closeEvent(QCloseEvent* arg__1);
638 virtual void closeEvent(QCloseEvent* arg__1);
638 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
639 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
639 virtual void customEvent(QEvent* arg__1);
640 virtual void customEvent(QEvent* arg__1);
640 virtual int devType() const;
641 virtual int devType() const;
641 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
642 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
642 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
643 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
643 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
644 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
644 virtual void dropEvent(QDropEvent* arg__1);
645 virtual void dropEvent(QDropEvent* arg__1);
645 virtual void enterEvent(QEvent* arg__1);
646 virtual void enterEvent(QEvent* arg__1);
646 virtual bool event(QEvent* arg__1);
647 virtual bool event(QEvent* arg__1);
647 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
648 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
648 virtual void focusInEvent(QFocusEvent* arg__1);
649 virtual void focusInEvent(QFocusEvent* arg__1);
649 virtual bool focusNextPrevChild(bool next);
650 virtual bool focusNextPrevChild(bool next);
650 virtual void focusOutEvent(QFocusEvent* arg__1);
651 virtual void focusOutEvent(QFocusEvent* arg__1);
651 virtual bool hasHeightForWidth() const;
652 virtual bool hasHeightForWidth() const;
652 virtual int heightForWidth(int arg__1) const;
653 virtual int heightForWidth(int arg__1) const;
653 virtual void hideEvent(QHideEvent* arg__1);
654 virtual void hideEvent(QHideEvent* arg__1);
654 virtual void initPainter(QPainter* painter) const;
655 virtual void initPainter(QPainter* painter) const;
655 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
656 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
656 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
657 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
657 virtual void keyPressEvent(QKeyEvent* arg__1);
658 virtual void keyPressEvent(QKeyEvent* arg__1);
658 virtual void keyReleaseEvent(QKeyEvent* arg__1);
659 virtual void keyReleaseEvent(QKeyEvent* arg__1);
659 virtual void leaveEvent(QEvent* arg__1);
660 virtual void leaveEvent(QEvent* arg__1);
660 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
661 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
661 virtual QSize minimumSizeHint() const;
662 virtual QSize minimumSizeHint() const;
662 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
663 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
663 virtual void mouseMoveEvent(QMouseEvent* arg__1);
664 virtual void mouseMoveEvent(QMouseEvent* arg__1);
664 virtual void mousePressEvent(QMouseEvent* arg__1);
665 virtual void mousePressEvent(QMouseEvent* arg__1);
665 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
666 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
666 virtual void moveEvent(QMoveEvent* arg__1);
667 virtual void moveEvent(QMoveEvent* arg__1);
667 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
668 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
668 virtual QPaintEngine* paintEngine() const;
669 virtual QPaintEngine* paintEngine() const;
669 virtual void paintEvent(QPaintEvent* arg__1);
670 virtual void paintEvent(QPaintEvent* arg__1);
670 virtual QPaintDevice* redirected(QPoint* offset) const;
671 virtual QPaintDevice* redirected(QPoint* offset) const;
671 virtual void reloadFile();
672 virtual void reloadFile();
672 virtual void resizeEvent(QResizeEvent* arg__1);
673 virtual void resizeEvent(QResizeEvent* arg__1);
673 virtual void setFile(abstractBinFile* file);
674 virtual void setFile(abstractBinFile* file);
674 virtual QPainter* sharedPainter() const;
675 virtual QPainter* sharedPainter() const;
675 virtual void showEvent(QShowEvent* arg__1);
676 virtual void showEvent(QShowEvent* arg__1);
676 virtual QSize sizeHint() const;
677 virtual QSize sizeHint() const;
677 virtual void tabletEvent(QTabletEvent* arg__1);
678 virtual void tabletEvent(QTabletEvent* arg__1);
678 virtual void timerEvent(QTimerEvent* arg__1);
679 virtual void timerEvent(QTimerEvent* arg__1);
679 virtual void wheelEvent(QWheelEvent* arg__1);
680 virtual void wheelEvent(QWheelEvent* arg__1);
680
681
681 PythonQtInstanceWrapper* _wrapper;
682 PythonQtInstanceWrapper* _wrapper;
682 };
683 };
683
684
684 class PythonQtPublicPromoter_abstractBinFileWidget : public abstractBinFileWidget
685 class PythonQtPublicPromoter_abstractBinFileWidget : public abstractBinFileWidget
685 { public:
686 { public:
686 inline void promoted_reloadFile() { reloadFile(); }
687 inline void promoted_reloadFile() { reloadFile(); }
687 inline void promoted_setFile(abstractBinFile* file) { setFile(file); }
688 inline void promoted_setFile(abstractBinFile* file) { setFile(file); }
688 };
689 };
689
690
690 class PythonQtWrapper_abstractBinFileWidget : public QObject
691 class PythonQtWrapper_abstractBinFileWidget : public QObject
691 { Q_OBJECT
692 { Q_OBJECT
692 public:
693 public:
693 public slots:
694 public slots:
694 abstractBinFileWidget* new_abstractBinFileWidget(QWidget* parent = 0);
695 abstractBinFileWidget* new_abstractBinFileWidget(QWidget* parent = 0);
695 void delete_abstractBinFileWidget(abstractBinFileWidget* obj) { delete obj; }
696 void delete_abstractBinFileWidget(abstractBinFileWidget* obj) { delete obj; }
696 void reloadFile(abstractBinFileWidget* theWrappedObject);
697 void reloadFile(abstractBinFileWidget* theWrappedObject);
697 void setFile(abstractBinFileWidget* theWrappedObject, abstractBinFile* file);
698 void setFile(abstractBinFileWidget* theWrappedObject, abstractBinFile* file);
698 };
699 };
699
700
700
701
701
702
702
703
703
704
704 class PythonQtShell_binaryFile : public binaryFile
705 class PythonQtShell_binaryFile : public binaryFile
705 {
706 {
706 public:
707 public:
707 PythonQtShell_binaryFile():binaryFile(),_wrapper(NULL) { };
708 PythonQtShell_binaryFile():binaryFile(),_wrapper(NULL) { };
708 PythonQtShell_binaryFile(const QString& File):binaryFile(File),_wrapper(NULL) { };
709 PythonQtShell_binaryFile(const QString& File):binaryFile(File),_wrapper(NULL) { };
709 PythonQtShell_binaryFile(const QStringList& Files):binaryFile(Files),_wrapper(NULL) { };
710 PythonQtShell_binaryFile(const QStringList& Files):binaryFile(Files),_wrapper(NULL) { };
710
711
711 ~PythonQtShell_binaryFile();
712 ~PythonQtShell_binaryFile();
712
713
713 virtual int closeFile();
714 virtual int closeFile();
714 virtual QList<codeFragment* > getFragments();
715 virtual QList<codeFragment* > getFragments();
715 virtual bool isopened();
716 virtual bool isopened();
716 virtual bool openFile(const QString& File);
717 virtual bool openFile(const QString& File);
717 virtual bool toBinary(const QString& fileName);
718 virtual bool toBinary(const QString& fileName);
718 virtual bool toSrec(const QString& fileName);
719 virtual bool toSrec(const QString& fileName);
719
720
720 PythonQtInstanceWrapper* _wrapper;
721 PythonQtInstanceWrapper* _wrapper;
721 };
722 };
722
723
723 class PythonQtPublicPromoter_binaryFile : public binaryFile
724 class PythonQtPublicPromoter_binaryFile : public binaryFile
724 { public:
725 { public:
725 inline int promoted_closeFile() { return binaryFile::closeFile(); }
726 inline int promoted_closeFile() { return binaryFile::closeFile(); }
726 inline QList<codeFragment* > promoted_getFragments() { return binaryFile::getFragments(); }
727 inline QList<codeFragment* > promoted_getFragments() { return binaryFile::getFragments(); }
727 inline bool promoted_isopened() { return binaryFile::isopened(); }
728 inline bool promoted_isopened() { return binaryFile::isopened(); }
728 inline bool promoted_openFile(const QString& File) { return binaryFile::openFile(File); }
729 inline bool promoted_openFile(const QString& File) { return binaryFile::openFile(File); }
729 inline bool promoted_toBinary(const QString& fileName) { return binaryFile::toBinary(fileName); }
730 inline bool promoted_toBinary(const QString& fileName) { return binaryFile::toBinary(fileName); }
730 inline bool promoted_toSrec(const QString& fileName) { return binaryFile::toSrec(fileName); }
731 inline bool promoted_toSrec(const QString& fileName) { return binaryFile::toSrec(fileName); }
731 };
732 };
732
733
733 class PythonQtWrapper_binaryFile : public QObject
734 class PythonQtWrapper_binaryFile : public QObject
734 { Q_OBJECT
735 { Q_OBJECT
735 public:
736 public:
736 public slots:
737 public slots:
737 binaryFile* new_binaryFile();
738 binaryFile* new_binaryFile();
738 binaryFile* new_binaryFile(const QString& File);
739 binaryFile* new_binaryFile(const QString& File);
739 binaryFile* new_binaryFile(const QStringList& Files);
740 binaryFile* new_binaryFile(const QStringList& Files);
740 void delete_binaryFile(binaryFile* obj) { delete obj; }
741 void delete_binaryFile(binaryFile* obj) { delete obj; }
741 int closeFile(binaryFile* theWrappedObject);
742 int closeFile(binaryFile* theWrappedObject);
742 codeFragment* getFragment(binaryFile* theWrappedObject, int index);
743 codeFragment* getFragment(binaryFile* theWrappedObject, int index);
743 int getFragmentAddress(binaryFile* theWrappedObject, int index);
744 int getFragmentAddress(binaryFile* theWrappedObject, int index);
744 bool getFragmentData(binaryFile* theWrappedObject, int index, char** buffer);
745 bool getFragmentData(binaryFile* theWrappedObject, int index, char** buffer);
745 QString getFragmentHeader(binaryFile* theWrappedObject, int index);
746 QString getFragmentHeader(binaryFile* theWrappedObject, int index);
746 int getFragmentSize(binaryFile* theWrappedObject, int index);
747 int getFragmentSize(binaryFile* theWrappedObject, int index);
747 QList<codeFragment* > getFragments(binaryFile* theWrappedObject);
748 QList<codeFragment* > getFragments(binaryFile* theWrappedObject);
748 int getFragmentsCount(binaryFile* theWrappedObject);
749 int getFragmentsCount(binaryFile* theWrappedObject);
749 bool isopened(binaryFile* theWrappedObject);
750 bool isopened(binaryFile* theWrappedObject);
750 bool openFile(binaryFile* theWrappedObject, const QString& File);
751 bool openFile(binaryFile* theWrappedObject, const QString& File);
751 bool openFiles(binaryFile* theWrappedObject, const QStringList& Files);
752 bool openFiles(binaryFile* theWrappedObject, const QStringList& Files);
752 bool static_binaryFile_toBinary(QList<codeFragment* > fragments, const QString& File);
753 bool static_binaryFile_toBinary(QList<codeFragment* > fragments, const QString& File);
753 bool toBinary(binaryFile* theWrappedObject, const QString& fileName);
754 bool toBinary(binaryFile* theWrappedObject, const QString& fileName);
754 bool toSrec(binaryFile* theWrappedObject, const QString& fileName);
755 bool toSrec(binaryFile* theWrappedObject, const QString& fileName);
755 };
756 };
756
757
757
758
758
759
759
760
760
761
761 class PythonQtShell_binaryFileWidget : public binaryFileWidget
762 class PythonQtShell_binaryFileWidget : public binaryFileWidget
762 {
763 {
763 public:
764 public:
764 PythonQtShell_binaryFileWidget(QWidget* parent = 0):binaryFileWidget(parent),_wrapper(NULL) { };
765 PythonQtShell_binaryFileWidget(QWidget* parent = 0):binaryFileWidget(parent),_wrapper(NULL) { };
765
766
766 ~PythonQtShell_binaryFileWidget();
767 ~PythonQtShell_binaryFileWidget();
767
768
768 virtual void reloadFile();
769 virtual void reloadFile();
769 virtual void setFile(abstractBinFile* file);
770 virtual void setFile(abstractBinFile* file);
770
771
771 PythonQtInstanceWrapper* _wrapper;
772 PythonQtInstanceWrapper* _wrapper;
772 };
773 };
773
774
774 class PythonQtPublicPromoter_binaryFileWidget : public binaryFileWidget
775 class PythonQtPublicPromoter_binaryFileWidget : public binaryFileWidget
775 { public:
776 { public:
776 inline void promoted_reloadFile() { binaryFileWidget::reloadFile(); }
777 inline void promoted_reloadFile() { binaryFileWidget::reloadFile(); }
777 inline void promoted_setFile(abstractBinFile* file) { binaryFileWidget::setFile(file); }
778 inline void promoted_setFile(abstractBinFile* file) { binaryFileWidget::setFile(file); }
778 };
779 };
779
780
780 class PythonQtWrapper_binaryFileWidget : public QObject
781 class PythonQtWrapper_binaryFileWidget : public QObject
781 { Q_OBJECT
782 { Q_OBJECT
782 public:
783 public:
783 public slots:
784 public slots:
784 binaryFileWidget* new_binaryFileWidget(QWidget* parent = 0);
785 binaryFileWidget* new_binaryFileWidget(QWidget* parent = 0);
785 void delete_binaryFileWidget(binaryFileWidget* obj) { delete obj; }
786 void delete_binaryFileWidget(binaryFileWidget* obj) { delete obj; }
786 void reloadFile(binaryFileWidget* theWrappedObject);
787 void reloadFile(binaryFileWidget* theWrappedObject);
787 void setFile(binaryFileWidget* theWrappedObject, abstractBinFile* file);
788 void setFile(binaryFileWidget* theWrappedObject, abstractBinFile* file);
788 };
789 };
789
790
790
791
791
792
792
793
793
794
794 class PythonQtShell_codeFragment : public codeFragment
795 class PythonQtShell_codeFragment : public codeFragment
795 {
796 {
796 public:
797 public:
797 PythonQtShell_codeFragment():codeFragment(),_wrapper(NULL) { };
798 PythonQtShell_codeFragment():codeFragment(),_wrapper(NULL) { };
798 PythonQtShell_codeFragment(char* data, quint64 size, quint64 address):codeFragment(data, size, address),_wrapper(NULL) { };
799 PythonQtShell_codeFragment(char* data, quint64 size, quint64 address):codeFragment(data, size, address),_wrapper(NULL) { };
799
800
800 ~PythonQtShell_codeFragment();
801 ~PythonQtShell_codeFragment();
801
802
802
803
803 PythonQtInstanceWrapper* _wrapper;
804 PythonQtInstanceWrapper* _wrapper;
804 };
805 };
805
806
806 class PythonQtWrapper_codeFragment : public QObject
807 class PythonQtWrapper_codeFragment : public QObject
807 { Q_OBJECT
808 { Q_OBJECT
808 public:
809 public:
809 public slots:
810 public slots:
810 codeFragment* new_codeFragment();
811 codeFragment* new_codeFragment();
811 codeFragment* new_codeFragment(char* data, quint64 size, quint64 address);
812 codeFragment* new_codeFragment(char* data, quint64 size, quint64 address);
812 void delete_codeFragment(codeFragment* obj) { delete obj; }
813 void delete_codeFragment(codeFragment* obj) { delete obj; }
813 void py_set_address(codeFragment* theWrappedObject, quint64 address){ theWrappedObject->address = address; }
814 void py_set_address(codeFragment* theWrappedObject, quint64 address){ theWrappedObject->address = address; }
814 quint64 py_get_address(codeFragment* theWrappedObject){ return theWrappedObject->address; }
815 quint64 py_get_address(codeFragment* theWrappedObject){ return theWrappedObject->address; }
815 void py_set_data(codeFragment* theWrappedObject, char* data){ theWrappedObject->data = data; }
816 void py_set_data(codeFragment* theWrappedObject, char* data){ theWrappedObject->data = data; }
816 char* py_get_data(codeFragment* theWrappedObject){ return theWrappedObject->data; }
817 char* py_get_data(codeFragment* theWrappedObject){ return theWrappedObject->data; }
817 void py_set_header(codeFragment* theWrappedObject, QString header){ theWrappedObject->header = header; }
818 void py_set_header(codeFragment* theWrappedObject, QString header){ theWrappedObject->header = header; }
818 QString py_get_header(codeFragment* theWrappedObject){ return theWrappedObject->header; }
819 QString py_get_header(codeFragment* theWrappedObject){ return theWrappedObject->header; }
819 void py_set_size(codeFragment* theWrappedObject, quint64 size){ theWrappedObject->size = size; }
820 void py_set_size(codeFragment* theWrappedObject, quint64 size){ theWrappedObject->size = size; }
820 quint64 py_get_size(codeFragment* theWrappedObject){ return theWrappedObject->size; }
821 quint64 py_get_size(codeFragment* theWrappedObject){ return theWrappedObject->size; }
821 };
822 };
822
823
823
824
824
825
825
826
826
827
827 class PythonQtShell_elfFileWidget : public elfFileWidget
828 class PythonQtShell_elfFileWidget : public elfFileWidget
828 {
829 {
829 public:
830 public:
830 PythonQtShell_elfFileWidget(QWidget* parent = 0):elfFileWidget(parent),_wrapper(NULL) { };
831 PythonQtShell_elfFileWidget(QWidget* parent = 0):elfFileWidget(parent),_wrapper(NULL) { };
831
832
832 ~PythonQtShell_elfFileWidget();
833 ~PythonQtShell_elfFileWidget();
833
834
834 virtual void reloadFile();
835 virtual void reloadFile();
835 virtual void setFile(abstractBinFile* file);
836 virtual void setFile(abstractBinFile* file);
836
837
837 PythonQtInstanceWrapper* _wrapper;
838 PythonQtInstanceWrapper* _wrapper;
838 };
839 };
839
840
840 class PythonQtPublicPromoter_elfFileWidget : public elfFileWidget
841 class PythonQtPublicPromoter_elfFileWidget : public elfFileWidget
841 { public:
842 { public:
842 inline void promoted_reloadFile() { elfFileWidget::reloadFile(); }
843 inline void promoted_reloadFile() { elfFileWidget::reloadFile(); }
843 inline void promoted_setFile(abstractBinFile* file) { elfFileWidget::setFile(file); }
844 inline void promoted_setFile(abstractBinFile* file) { elfFileWidget::setFile(file); }
844 };
845 };
845
846
846 class PythonQtWrapper_elfFileWidget : public QObject
847 class PythonQtWrapper_elfFileWidget : public QObject
847 { Q_OBJECT
848 { Q_OBJECT
848 public:
849 public:
849 public slots:
850 public slots:
850 elfFileWidget* new_elfFileWidget(QWidget* parent = 0);
851 elfFileWidget* new_elfFileWidget(QWidget* parent = 0);
851 void delete_elfFileWidget(elfFileWidget* obj) { delete obj; }
852 void delete_elfFileWidget(elfFileWidget* obj) { delete obj; }
852 void reloadFile(elfFileWidget* theWrappedObject);
853 void reloadFile(elfFileWidget* theWrappedObject);
853 void setFile(elfFileWidget* theWrappedObject, abstractBinFile* file);
854 void setFile(elfFileWidget* theWrappedObject, abstractBinFile* file);
854 };
855 };
855
856
856
857
857
858
858
859
859
860
860 class PythonQtShell_elfInfoWdgt : public elfInfoWdgt
861 class PythonQtShell_elfInfoWdgt : public elfInfoWdgt
861 {
862 {
862 public:
863 public:
863 PythonQtShell_elfInfoWdgt(QWidget* parent = 0):elfInfoWdgt(parent),_wrapper(NULL) { };
864 PythonQtShell_elfInfoWdgt(QWidget* parent = 0):elfInfoWdgt(parent),_wrapper(NULL) { };
864
865
865 ~PythonQtShell_elfInfoWdgt();
866 ~PythonQtShell_elfInfoWdgt();
866
867
867 virtual void actionEvent(QActionEvent* arg__1);
868 virtual void actionEvent(QActionEvent* arg__1);
868 virtual void changeEvent(QEvent* arg__1);
869 virtual void changeEvent(QEvent* arg__1);
869 virtual void childEvent(QChildEvent* arg__1);
870 virtual void childEvent(QChildEvent* arg__1);
870 virtual void closeEvent(QCloseEvent* arg__1);
871 virtual void closeEvent(QCloseEvent* arg__1);
871 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
872 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
872 virtual void customEvent(QEvent* arg__1);
873 virtual void customEvent(QEvent* arg__1);
873 virtual int devType() const;
874 virtual int devType() const;
874 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
875 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
875 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
876 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
876 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
877 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
877 virtual void dropEvent(QDropEvent* arg__1);
878 virtual void dropEvent(QDropEvent* arg__1);
878 virtual void enterEvent(QEvent* arg__1);
879 virtual void enterEvent(QEvent* arg__1);
879 virtual bool event(QEvent* arg__1);
880 virtual bool event(QEvent* arg__1);
880 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
881 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
881 virtual void focusInEvent(QFocusEvent* arg__1);
882 virtual void focusInEvent(QFocusEvent* arg__1);
882 virtual bool focusNextPrevChild(bool next);
883 virtual bool focusNextPrevChild(bool next);
883 virtual void focusOutEvent(QFocusEvent* arg__1);
884 virtual void focusOutEvent(QFocusEvent* arg__1);
884 virtual bool hasHeightForWidth() const;
885 virtual bool hasHeightForWidth() const;
885 virtual int heightForWidth(int arg__1) const;
886 virtual int heightForWidth(int arg__1) const;
886 virtual void hideEvent(QHideEvent* arg__1);
887 virtual void hideEvent(QHideEvent* arg__1);
887 virtual void initPainter(QPainter* painter) const;
888 virtual void initPainter(QPainter* painter) const;
888 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
889 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
889 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
890 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
890 virtual void keyPressEvent(QKeyEvent* arg__1);
891 virtual void keyPressEvent(QKeyEvent* arg__1);
891 virtual void keyReleaseEvent(QKeyEvent* arg__1);
892 virtual void keyReleaseEvent(QKeyEvent* arg__1);
892 virtual void leaveEvent(QEvent* arg__1);
893 virtual void leaveEvent(QEvent* arg__1);
893 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
894 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
894 virtual QSize minimumSizeHint() const;
895 virtual QSize minimumSizeHint() const;
895 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
896 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
896 virtual void mouseMoveEvent(QMouseEvent* arg__1);
897 virtual void mouseMoveEvent(QMouseEvent* arg__1);
897 virtual void mousePressEvent(QMouseEvent* arg__1);
898 virtual void mousePressEvent(QMouseEvent* arg__1);
898 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
899 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
899 virtual void moveEvent(QMoveEvent* arg__1);
900 virtual void moveEvent(QMoveEvent* arg__1);
900 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
901 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
901 virtual QPaintEngine* paintEngine() const;
902 virtual QPaintEngine* paintEngine() const;
902 virtual void paintEvent(QPaintEvent* arg__1);
903 virtual void paintEvent(QPaintEvent* arg__1);
903 virtual QPaintDevice* redirected(QPoint* offset) const;
904 virtual QPaintDevice* redirected(QPoint* offset) const;
904 virtual void resizeEvent(QResizeEvent* arg__1);
905 virtual void resizeEvent(QResizeEvent* arg__1);
905 virtual QPainter* sharedPainter() const;
906 virtual QPainter* sharedPainter() const;
906 virtual void showEvent(QShowEvent* arg__1);
907 virtual void showEvent(QShowEvent* arg__1);
907 virtual QSize sizeHint() const;
908 virtual QSize sizeHint() const;
908 virtual void tabletEvent(QTabletEvent* arg__1);
909 virtual void tabletEvent(QTabletEvent* arg__1);
909 virtual void timerEvent(QTimerEvent* arg__1);
910 virtual void timerEvent(QTimerEvent* arg__1);
910 virtual void wheelEvent(QWheelEvent* arg__1);
911 virtual void wheelEvent(QWheelEvent* arg__1);
911
912
912 PythonQtInstanceWrapper* _wrapper;
913 PythonQtInstanceWrapper* _wrapper;
913 };
914 };
914
915
915 class PythonQtWrapper_elfInfoWdgt : public QObject
916 class PythonQtWrapper_elfInfoWdgt : public QObject
916 { Q_OBJECT
917 { Q_OBJECT
917 public:
918 public:
918 public slots:
919 public slots:
919 elfInfoWdgt* new_elfInfoWdgt(QWidget* parent = 0);
920 elfInfoWdgt* new_elfInfoWdgt(QWidget* parent = 0);
920 void delete_elfInfoWdgt(elfInfoWdgt* obj) { delete obj; }
921 void delete_elfInfoWdgt(elfInfoWdgt* obj) { delete obj; }
921 };
922 };
922
923
923
924
924
925
925
926
926
927
927 class PythonQtWrapper_elfparser : public QObject
928 class PythonQtWrapper_elfparser : public QObject
928 { Q_OBJECT
929 { Q_OBJECT
929 public:
930 public:
930 public slots:
931 public slots:
931 elfparser* new_elfparser();
932 elfparser* new_elfparser();
932 void delete_elfparser(elfparser* obj) { delete obj; }
933 void delete_elfparser(elfparser* obj) { delete obj; }
933 int closeFile(elfparser* theWrappedObject);
934 int closeFile(elfparser* theWrappedObject);
934 QString getABI(elfparser* theWrappedObject);
935 QString getABI(elfparser* theWrappedObject);
935 QString getArchitecture(elfparser* theWrappedObject);
936 QString getArchitecture(elfparser* theWrappedObject);
936 QString getClass(elfparser* theWrappedObject);
937 QString getClass(elfparser* theWrappedObject);
937 QString getEndianness(elfparser* theWrappedObject);
938 QString getEndianness(elfparser* theWrappedObject);
938 qint64 getEntryPointAddress(elfparser* theWrappedObject);
939 qint64 getEntryPointAddress(elfparser* theWrappedObject);
939 bool getSectionData(elfparser* theWrappedObject, int index, char** buffer);
940 bool getSectionData(elfparser* theWrappedObject, int index, char** buffer);
940 qint64 getSectionDatasz(elfparser* theWrappedObject, int index);
941 qint64 getSectionDatasz(elfparser* theWrappedObject, int index);
941 qint64 getSectionMemsz(elfparser* theWrappedObject, int index);
942 qint64 getSectionMemsz(elfparser* theWrappedObject, int index);
942 QString getSectionName(elfparser* theWrappedObject, int index);
943 QString getSectionName(elfparser* theWrappedObject, int index);
943 qint64 getSectionPaddr(elfparser* theWrappedObject, int index);
944 qint64 getSectionPaddr(elfparser* theWrappedObject, int index);
944 QString getSectionType(elfparser* theWrappedObject, int index);
945 QString getSectionType(elfparser* theWrappedObject, int index);
945 int getSectioncount(elfparser* theWrappedObject);
946 int getSectioncount(elfparser* theWrappedObject);
946 qint64 getSegmentFilesz(elfparser* theWrappedObject, int index);
947 qint64 getSegmentFilesz(elfparser* theWrappedObject, int index);
947 QString getSegmentFlags(elfparser* theWrappedObject, int index);
948 QString getSegmentFlags(elfparser* theWrappedObject, int index);
948 qint64 getSegmentMemsz(elfparser* theWrappedObject, int index);
949 qint64 getSegmentMemsz(elfparser* theWrappedObject, int index);
949 qint64 getSegmentOffset(elfparser* theWrappedObject, int index);
950 qint64 getSegmentOffset(elfparser* theWrappedObject, int index);
950 qint64 getSegmentPaddr(elfparser* theWrappedObject, int index);
951 qint64 getSegmentPaddr(elfparser* theWrappedObject, int index);
951 QString getSegmentType(elfparser* theWrappedObject, int index);
952 QString getSegmentType(elfparser* theWrappedObject, int index);
952 qint64 getSegmentVaddr(elfparser* theWrappedObject, int index);
953 qint64 getSegmentVaddr(elfparser* theWrappedObject, int index);
953 int getSegmentcount(elfparser* theWrappedObject);
954 int getSegmentcount(elfparser* theWrappedObject);
954 QString getType(elfparser* theWrappedObject);
955 QString getType(elfparser* theWrappedObject);
955 qint64 getVersion(elfparser* theWrappedObject);
956 qint64 getVersion(elfparser* theWrappedObject);
956 bool static_elfparser_isElf(const QString& File);
957 bool static_elfparser_isElf(const QString& File);
957 bool iself(elfparser* theWrappedObject);
958 bool iself(elfparser* theWrappedObject);
958 bool isopened(elfparser* theWrappedObject);
959 bool isopened(elfparser* theWrappedObject);
959 int setFilename(elfparser* theWrappedObject, const QString& name);
960 int setFilename(elfparser* theWrappedObject, const QString& name);
960 };
961 };
961
962
962
963
963
964
964
965
965
966
966 class PythonQtShell_genericBinaryFileWidget : public genericBinaryFileWidget
967 class PythonQtShell_genericBinaryFileWidget : public genericBinaryFileWidget
967 {
968 {
968 public:
969 public:
969 PythonQtShell_genericBinaryFileWidget(QWidget* parent = 0):genericBinaryFileWidget(parent),_wrapper(NULL) { };
970 PythonQtShell_genericBinaryFileWidget(QWidget* parent = 0):genericBinaryFileWidget(parent),_wrapper(NULL) { };
970
971
971 ~PythonQtShell_genericBinaryFileWidget();
972 ~PythonQtShell_genericBinaryFileWidget();
972
973
973 virtual void actionEvent(QActionEvent* arg__1);
974 virtual void actionEvent(QActionEvent* arg__1);
974 virtual void changeEvent(QEvent* arg__1);
975 virtual void changeEvent(QEvent* arg__1);
975 virtual void childEvent(QChildEvent* arg__1);
976 virtual void childEvent(QChildEvent* arg__1);
976 virtual void closeEvent(QCloseEvent* arg__1);
977 virtual void closeEvent(QCloseEvent* arg__1);
977 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
978 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
978 virtual void customEvent(QEvent* arg__1);
979 virtual void customEvent(QEvent* arg__1);
979 virtual int devType() const;
980 virtual int devType() const;
980 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
981 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
981 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
982 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
982 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
983 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
983 virtual void dropEvent(QDropEvent* arg__1);
984 virtual void dropEvent(QDropEvent* arg__1);
984 virtual void enterEvent(QEvent* arg__1);
985 virtual void enterEvent(QEvent* arg__1);
985 virtual bool event(QEvent* arg__1);
986 virtual bool event(QEvent* arg__1);
986 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
987 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
987 virtual void focusInEvent(QFocusEvent* arg__1);
988 virtual void focusInEvent(QFocusEvent* arg__1);
988 virtual bool focusNextPrevChild(bool next);
989 virtual bool focusNextPrevChild(bool next);
989 virtual void focusOutEvent(QFocusEvent* arg__1);
990 virtual void focusOutEvent(QFocusEvent* arg__1);
990 virtual bool hasHeightForWidth() const;
991 virtual bool hasHeightForWidth() const;
991 virtual int heightForWidth(int arg__1) const;
992 virtual int heightForWidth(int arg__1) const;
992 virtual void hideEvent(QHideEvent* arg__1);
993 virtual void hideEvent(QHideEvent* arg__1);
993 virtual void initPainter(QPainter* painter) const;
994 virtual void initPainter(QPainter* painter) const;
994 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
995 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
995 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
996 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
996 virtual void keyPressEvent(QKeyEvent* arg__1);
997 virtual void keyPressEvent(QKeyEvent* arg__1);
997 virtual void keyReleaseEvent(QKeyEvent* arg__1);
998 virtual void keyReleaseEvent(QKeyEvent* arg__1);
998 virtual void leaveEvent(QEvent* arg__1);
999 virtual void leaveEvent(QEvent* arg__1);
999 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
1000 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
1000 virtual QSize minimumSizeHint() const;
1001 virtual QSize minimumSizeHint() const;
1001 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
1002 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
1002 virtual void mouseMoveEvent(QMouseEvent* arg__1);
1003 virtual void mouseMoveEvent(QMouseEvent* arg__1);
1003 virtual void mousePressEvent(QMouseEvent* arg__1);
1004 virtual void mousePressEvent(QMouseEvent* arg__1);
1004 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
1005 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
1005 virtual void moveEvent(QMoveEvent* arg__1);
1006 virtual void moveEvent(QMoveEvent* arg__1);
1006 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
1007 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
1007 virtual QPaintEngine* paintEngine() const;
1008 virtual QPaintEngine* paintEngine() const;
1008 virtual void paintEvent(QPaintEvent* arg__1);
1009 virtual void paintEvent(QPaintEvent* arg__1);
1009 virtual QPaintDevice* redirected(QPoint* offset) const;
1010 virtual QPaintDevice* redirected(QPoint* offset) const;
1010 virtual void resizeEvent(QResizeEvent* arg__1);
1011 virtual void resizeEvent(QResizeEvent* arg__1);
1011 virtual QPainter* sharedPainter() const;
1012 virtual QPainter* sharedPainter() const;
1012 virtual void showEvent(QShowEvent* arg__1);
1013 virtual void showEvent(QShowEvent* arg__1);
1013 virtual QSize sizeHint() const;
1014 virtual QSize sizeHint() const;
1014 virtual void tabletEvent(QTabletEvent* arg__1);
1015 virtual void tabletEvent(QTabletEvent* arg__1);
1015 virtual void timerEvent(QTimerEvent* arg__1);
1016 virtual void timerEvent(QTimerEvent* arg__1);
1016 virtual void wheelEvent(QWheelEvent* arg__1);
1017 virtual void wheelEvent(QWheelEvent* arg__1);
1017
1018
1018 PythonQtInstanceWrapper* _wrapper;
1019 PythonQtInstanceWrapper* _wrapper;
1019 };
1020 };
1020
1021
1021 class PythonQtWrapper_genericBinaryFileWidget : public QObject
1022 class PythonQtWrapper_genericBinaryFileWidget : public QObject
1022 { Q_OBJECT
1023 { Q_OBJECT
1023 public:
1024 public:
1024 public slots:
1025 public slots:
1025 genericBinaryFileWidget* new_genericBinaryFileWidget(QWidget* parent = 0);
1026 genericBinaryFileWidget* new_genericBinaryFileWidget(QWidget* parent = 0);
1026 void delete_genericBinaryFileWidget(genericBinaryFileWidget* obj) { delete obj; }
1027 void delete_genericBinaryFileWidget(genericBinaryFileWidget* obj) { delete obj; }
1027 };
1028 };
1028
1029
1029
1030
1030
1031
1031
1032
1032
1033
1033 class PythonQtShell_srecFile : public srecFile
1034 class PythonQtShell_srecFile : public srecFile
1034 {
1035 {
1035 public:
1036 public:
1036 PythonQtShell_srecFile():srecFile(),_wrapper(NULL) { };
1037 PythonQtShell_srecFile():srecFile(),_wrapper(NULL) { };
1037 PythonQtShell_srecFile(const QString& File):srecFile(File),_wrapper(NULL) { };
1038 PythonQtShell_srecFile(const QString& File):srecFile(File),_wrapper(NULL) { };
1038 PythonQtShell_srecFile(const QStringList& Files):srecFile(Files),_wrapper(NULL) { };
1039 PythonQtShell_srecFile(const QStringList& Files):srecFile(Files),_wrapper(NULL) { };
1039
1040
1040 ~PythonQtShell_srecFile();
1041 ~PythonQtShell_srecFile();
1041
1042
1042 virtual int closeFile();
1043 virtual int closeFile();
1043 virtual QList<codeFragment* > getFragments();
1044 virtual QList<codeFragment* > getFragments();
1044 virtual bool isopened();
1045 virtual bool isopened();
1045 virtual bool openFile(const QString& File);
1046 virtual bool openFile(const QString& File);
1046 virtual bool toBinary(const QString& File);
1047 virtual bool toBinary(const QString& File);
1047 virtual bool toSrec(const QString& File);
1048 virtual bool toSrec(const QString& File);
1048
1049
1049 PythonQtInstanceWrapper* _wrapper;
1050 PythonQtInstanceWrapper* _wrapper;
1050 };
1051 };
1051
1052
1052 class PythonQtPublicPromoter_srecFile : public srecFile
1053 class PythonQtPublicPromoter_srecFile : public srecFile
1053 { public:
1054 { public:
1054 inline int promoted_closeFile() { return srecFile::closeFile(); }
1055 inline int promoted_closeFile() { return srecFile::closeFile(); }
1055 inline QList<codeFragment* > promoted_getFragments() { return srecFile::getFragments(); }
1056 inline QList<codeFragment* > promoted_getFragments() { return srecFile::getFragments(); }
1056 inline bool promoted_isopened() { return srecFile::isopened(); }
1057 inline bool promoted_isopened() { return srecFile::isopened(); }
1057 inline bool promoted_openFile(const QString& File) { return srecFile::openFile(File); }
1058 inline bool promoted_openFile(const QString& File) { return srecFile::openFile(File); }
1058 inline bool promoted_toBinary(const QString& File) { return srecFile::toBinary(File); }
1059 inline bool promoted_toBinary(const QString& File) { return srecFile::toBinary(File); }
1059 inline bool promoted_toSrec(const QString& File) { return srecFile::toSrec(File); }
1060 inline bool promoted_toSrec(const QString& File) { return srecFile::toSrec(File); }
1060 };
1061 };
1061
1062
1062 class PythonQtWrapper_srecFile : public QObject
1063 class PythonQtWrapper_srecFile : public QObject
1063 { Q_OBJECT
1064 { Q_OBJECT
1064 public:
1065 public:
1065 public slots:
1066 public slots:
1066 srecFile* new_srecFile();
1067 srecFile* new_srecFile();
1067 srecFile* new_srecFile(const QString& File);
1068 srecFile* new_srecFile(const QString& File);
1068 srecFile* new_srecFile(const QStringList& Files);
1069 srecFile* new_srecFile(const QStringList& Files);
1069 void delete_srecFile(srecFile* obj) { delete obj; }
1070 void delete_srecFile(srecFile* obj) { delete obj; }
1070 bool static_srecFile_checkSum(const QString& line);
1071 bool static_srecFile_checkSum(const QString& line);
1071 int closeFile(srecFile* theWrappedObject);
1072 int closeFile(srecFile* theWrappedObject);
1072 codeFragment* getFragment(srecFile* theWrappedObject, int index);
1073 codeFragment* getFragment(srecFile* theWrappedObject, int index);
1073 int getFragmentAddress(srecFile* theWrappedObject, int index);
1074 int getFragmentAddress(srecFile* theWrappedObject, int index);
1074 bool getFragmentData(srecFile* theWrappedObject, int index, char** buffer);
1075 bool getFragmentData(srecFile* theWrappedObject, int index, char** buffer);
1075 QString getFragmentHeader(srecFile* theWrappedObject, int index);
1076 QString getFragmentHeader(srecFile* theWrappedObject, int index);
1076 int getFragmentSize(srecFile* theWrappedObject, int index);
1077 int getFragmentSize(srecFile* theWrappedObject, int index);
1077 QList<codeFragment* > getFragments(srecFile* theWrappedObject);
1078 QList<codeFragment* > getFragments(srecFile* theWrappedObject);
1078 int getFragmentsCount(srecFile* theWrappedObject);
1079 int getFragmentsCount(srecFile* theWrappedObject);
1079 bool isSREC(srecFile* theWrappedObject);
1080 bool isSREC(srecFile* theWrappedObject);
1080 bool static_srecFile_isSREC(const QString& File);
1081 bool static_srecFile_isSREC(const QString& File);
1081 bool isopened(srecFile* theWrappedObject);
1082 bool isopened(srecFile* theWrappedObject);
1082 int lineCount(srecFile* theWrappedObject);
1083 int lineCount(srecFile* theWrappedObject);
1083 bool mergingRecords(srecFile* theWrappedObject);
1084 bool mergingRecords(srecFile* theWrappedObject);
1084 bool openFile(srecFile* theWrappedObject, const QString& File);
1085 bool openFile(srecFile* theWrappedObject, const QString& File);
1085 bool openFiles(srecFile* theWrappedObject, const QStringList& Files);
1086 bool openFiles(srecFile* theWrappedObject, const QStringList& Files);
1086 void setMergingRecords(srecFile* theWrappedObject, bool enabled);
1087 void setMergingRecords(srecFile* theWrappedObject, bool enabled);
1087 bool toBinary(srecFile* theWrappedObject, const QString& File);
1088 bool toBinary(srecFile* theWrappedObject, const QString& File);
1088 bool static_srecFile_toSrec(QList<codeFragment* > fragments, const QString& File);
1089 bool static_srecFile_toSrec(QList<codeFragment* > fragments, const QString& File);
1089 bool toSrec(srecFile* theWrappedObject, const QString& File);
1090 bool toSrec(srecFile* theWrappedObject, const QString& File);
1090 };
1091 };
1091
1092
1092
1093
1093
1094
1094
1095
1095
1096
1096 class PythonQtShell_srecFileWidget : public srecFileWidget
1097 class PythonQtShell_srecFileWidget : public srecFileWidget
1097 {
1098 {
1098 public:
1099 public:
1099 PythonQtShell_srecFileWidget(QWidget* parent = 0):srecFileWidget(parent),_wrapper(NULL) { };
1100 PythonQtShell_srecFileWidget(QWidget* parent = 0):srecFileWidget(parent),_wrapper(NULL) { };
1100
1101
1101 ~PythonQtShell_srecFileWidget();
1102 ~PythonQtShell_srecFileWidget();
1102
1103
1103 virtual void reloadFile();
1104 virtual void reloadFile();
1104 virtual void setFile(abstractBinFile* file);
1105 virtual void setFile(abstractBinFile* file);
1105
1106
1106 PythonQtInstanceWrapper* _wrapper;
1107 PythonQtInstanceWrapper* _wrapper;
1107 };
1108 };
1108
1109
1109 class PythonQtPublicPromoter_srecFileWidget : public srecFileWidget
1110 class PythonQtPublicPromoter_srecFileWidget : public srecFileWidget
1110 { public:
1111 { public:
1111 inline void promoted_reloadFile() { srecFileWidget::reloadFile(); }
1112 inline void promoted_reloadFile() { srecFileWidget::reloadFile(); }
1112 inline void promoted_setFile(abstractBinFile* file) { srecFileWidget::setFile(file); }
1113 inline void promoted_setFile(abstractBinFile* file) { srecFileWidget::setFile(file); }
1113 };
1114 };
1114
1115
1115 class PythonQtWrapper_srecFileWidget : public QObject
1116 class PythonQtWrapper_srecFileWidget : public QObject
1116 { Q_OBJECT
1117 { Q_OBJECT
1117 public:
1118 public:
1118 public slots:
1119 public slots:
1119 srecFileWidget* new_srecFileWidget(QWidget* parent = 0);
1120 srecFileWidget* new_srecFileWidget(QWidget* parent = 0);
1120 void delete_srecFileWidget(srecFileWidget* obj) { delete obj; }
1121 void delete_srecFileWidget(srecFileWidget* obj) { delete obj; }
1121 void reloadFile(srecFileWidget* theWrappedObject);
1122 void reloadFile(srecFileWidget* theWrappedObject);
1122 void setFile(srecFileWidget* theWrappedObject, abstractBinFile* file);
1123 void setFile(srecFileWidget* theWrappedObject, abstractBinFile* file);
1123 };
1124 };
1124
1125
1125
1126
@@ -1,89 +1,113
1 /*------------------------------------------------------------------------------
1 /*------------------------------------------------------------------------------
2 -- This file is a part of the SocExplorer Software
2 -- This file is a part of the SocExplorer Software
3 -- Copyright (C) 2011, Plasma Physics Laboratory - CNRS
3 -- Copyright (C) 2011, Plasma Physics Laboratory - CNRS
4 --
4 --
5 -- This program is free software; you can redistribute it and/or modify
5 -- This program is free software; you can redistribute it and/or modify
6 -- it under the terms of the GNU General Public License as published by
6 -- it under the terms of the GNU General Public License as published by
7 -- the Free Software Foundation; either version 2 of the License, or
7 -- the Free Software Foundation; either version 2 of the License, or
8 -- (at your option) any later version.
8 -- (at your option) any later version.
9 --
9 --
10 -- This program is distributed in the hope that it will be useful,
10 -- This program is distributed in the hope that it will be useful,
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 -- GNU General Public License for more details.
13 -- GNU General Public License for more details.
14 --
14 --
15 -- You should have received a copy of the GNU General Public License
15 -- You should have received a copy of the GNU General Public License
16 -- along with this program; if not, write to the Free Software
16 -- along with this program; if not, write to the Free Software
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 -------------------------------------------------------------------------------*/
18 -------------------------------------------------------------------------------*/
19 /*-- Author : Alexis Jeandet
19 /*-- Author : Alexis Jeandet
20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
21 ----------------------------------------------------------------------------*/
21 ----------------------------------------------------------------------------*/
22 #include <QApplication>
22 #include <QApplication>
23 #include "mainwindow.h"
23 #include "mainwindow.h"
24 #include <PythonQt.h>
24 #include <PythonQt.h>
25 #include <PythonQt_QtAll.h>
25 #include <PythonQt_QtAll.h>
26 #include <gui/PythonQtScriptingConsole.h>
26 #include <gui/PythonQtScriptingConsole.h>
27 #include <socexplorerplugin.h>
27 #include <socexplorerplugin.h>
28 #include <QStyle>
28 #include <QStyle>
29 #include <QStyleFactory>
29 #include <QStyleFactory>
30 #include <QStringList>
30 #include <QStringList>
31 #include <QFile>
31 #include <QFile>
32 #include <QCommandLineOption>
33 #include <QCommandLineParser>
32
34
33 void usage();
35
36 QCommandLineOption executeOption = QCommandLineOption (
37 QStringList() << "e" << "execute",
38 QCoreApplication::translate("main", "Execute given script <script>."),
39 QCoreApplication::translate("main", "script"));
40
41 QCommandLineOption debugLevelOption = QCommandLineOption (
42 QStringList() << "d" << "debug-level",
43 QCoreApplication::translate("main", "Execute given script <script>."),
44 QCoreApplication::translate("main", "script"),
45 "1");
46
47 QCommandLineOption noGUIOption = QCommandLineOption (
48 QStringList() << "n" << "no-gui",
49 QCoreApplication::translate("main", "Starts SocExplorer in batch mode."));
50
51 const char* socexplorerDesc="\
52 SocExplorer is an open source generic System On Chip testing software/framework.\
53 We write this software for the development and the validation of our instrument,\
54 the Low Frequency Receiver(LFR) for the Solar Orbiter mission. This instrument is\
55 based on an actel FPGA hosting a LEON3FT processor and some peripherals. To make\
56 it more collaborative, we use a plugin based system, the main executable is SocExplorer\
57 then all the functionality are provided by plugins. Like this everybody can provide\
58 his set of plugins to handle a new SOC or just a new peripheral. SocExplorer uses\
59 PythonQt to allow user to automate some tasks such as loading some plugins, configuring\
60 them and talking with his device. SocExplorer is provided under the terms of the GNU\
61 General Public License as published by the Free Software Foundation; either version 2\
62 of the License, or (at your option) any later version.";
34
63
35 int main(int argc, char *argv[])
64 int main(int argc, char *argv[])
36 {
65 {
37 QApplication a(argc, argv);
66 QApplication a(argc, argv);
38 QString scriptToEval;
67 QString scriptToEval;
39 QStringList args= a.arguments();
68 QApplication::setOrganizationName("LPP");
69 QApplication::setOrganizationDomain("lpp.fr");
70 QApplication::setApplicationName("SocExplorer");
71 QCommandLineParser parser;
72 parser.setApplicationDescription(socexplorerDesc);
73 parser.addHelpOption();
74 parser.addVersionOption();
40 bool noGUI=false;
75 bool noGUI=false;
41 for(int i=0;i<=args.count()-1;i++)
76 parser.addOption(executeOption);
77 parser.addOption(debugLevelOption);
78 parser.addOption(noGUIOption);
79 parser.process(a);
80 if(parser.isSet(executeOption))
42 {
81 {
43 if(((args.at(i).compare("-e")==0) || (args.at(i).compare("--execute")==0)) && (i<(args.count()-1)))
82 scriptToEval = parser.value(executeOption);
83 if(!QFile::exists(scriptToEval))
44 {
84 {
45 scriptToEval = args.at(i+1);
85 scriptToEval.clear();
46 if(!QFile::exists(scriptToEval))
47 {
48 scriptToEval.clear();
49 }
50 else
51 qDebug() << "Will execute" << scriptToEval;
52 break;
53 }
54 if(((args.at(i).compare("-d")==0) || (args.at(i).compare("--debug-level")==0)) && (i<(args.count()-1)))
55 {
56 bool success;
57 int lvl;
58 lvl = args.at(i+1).toInt(&success,10);
59 if(success)
60 {
61 SocExplorerEngine::setLogLevel(lvl);
62 }
63 }
64 if((args.at(i).compare("--no-gui")==0))
65 {
66 noGUI = true;
67 qDebug() << "CLI mode";
68 }
86 }
69 }
87 }
70
88 if(parser.isSet(debugLevelOption))
89 {
90 bool success;
91 int lvl;
92 lvl = parser.value(debugLevelOption).toInt(&success,10);
93 if(success)
94 {
95 SocExplorerEngine::setLogLevel(lvl);
96 }
97 }
98 if(parser.isSet(noGUIOption))
99 {
100 noGUI = true;
101 qDebug() << "CLI mode";
102 }
71 SocExplorerMainWindow w(scriptToEval);
103 SocExplorerMainWindow w(scriptToEval);
72 if(!noGUI)
104 if(!noGUI)
73 {
105 {
74
75 w.show();
106 w.show();
76 }
107 }
77 else
108 else
78 {
109 {
79
110
80 }
111 }
81 return a.exec();
112 return a.exec();
82 }
113 }
83
84
85 void usage()
86 {
87 // TODO respect usual Linux Cli interface, socexplore [OPTION]...FILES...
88 // TODO write an usage helper.
89 }
@@ -1,240 +1,264
1 /*------------------------------------------------------------------------------
1 /*------------------------------------------------------------------------------
2 -- This file is a part of the SocExplorer Software
2 -- This file is a part of the SocExplorer Software
3 -- Copyright (C) 2011, Plasma Physics Laboratory - CNRS
3 -- Copyright (C) 2011-2015, Plasma Physics Laboratory - CNRS
4 --
4 --
5 -- This program is free software; you can redistribute it and/or modify
5 -- This program is free software; you can redistribute it and/or modify
6 -- it under the terms of the GNU General Public License as published by
6 -- it under the terms of the GNU General Public License as published by
7 -- the Free Software Foundation; either version 2 of the License, or
7 -- the Free Software Foundation; either version 2 of the License, or
8 -- (at your option) any later version.
8 -- (at your option) any later version.
9 --
9 --
10 -- This program is distributed in the hope that it will be useful,
10 -- This program is distributed in the hope that it will be useful,
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 -- GNU General Public License for more details.
13 -- GNU General Public License for more details.
14 --
14 --
15 -- You should have received a copy of the GNU General Public License
15 -- You should have received a copy of the GNU General Public License
16 -- along with this program; if not, write to the Free Software
16 -- along with this program; if not, write to the Free Software
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 -------------------------------------------------------------------------------*/
18 -------------------------------------------------------------------------------*/
19 /*-- Author : Alexis Jeandet
19 /*-- Author : Alexis Jeandet
20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
21 ----------------------------------------------------------------------------*/
21 ----------------------------------------------------------------------------*/
22 #include "mainwindow.h"
22 #include "mainwindow.h"
23 #include <QDockWidget>
23 #include <QDockWidget>
24 #include <socexplorersettings.h>
25 #include <socexplorerconfigkeys.h>
24
26
25 SocExplorerMainWindow::SocExplorerMainWindow(QString ScriptToEval, QWidget *parent)
27 SocExplorerMainWindow::SocExplorerMainWindow(QString ScriptToEval, QWidget *parent)
26 : QMainWindow(parent)
28 : QMainWindow(parent)
27 {
29 {
28 QCoreApplication::setApplicationName("SocExplorer");
30 QCoreApplication::setApplicationName("SocExplorer");
29 QCoreApplication::setOrganizationName("LPP");
31 QCoreApplication::setOrganizationName("LPP");
30 QCoreApplication::setOrganizationDomain("lpp.fr");
32 QCoreApplication::setOrganizationDomain("lpp.fr");
31 this->makeObjects(ScriptToEval);
33 this->makeObjects(ScriptToEval);
32 this->makeLayout();
34 this->makeLayout();
33 this->makeMenu();
35 this->makeMenu();
36 SocExplorerSettings::init();
37 SocExplorerSettings::loadSession("Session1");
34 this->makeConnections();
38 this->makeConnections();
35 this->setWindowIcon(QIcon(":/images/icon.png"));
39 this->setWindowIcon(QIcon(":/images/icon.png"));
36 this->setAcceptDrops(true);
40 this->setAcceptDrops(true);
37 this->pluginManager->setRootLoadable(true);
41 this->pluginManager->setRootLoadable(true);
38 this->PythonConsoleInst->pyConsoleRunFile(ScriptToEval);
42 this->PythonConsoleInst->pyConsoleRunFile(ScriptToEval);
39 QFile file(":/styles/SocExplorer.css");
43 QFile file(":/styles/SocExplorer.css");
40 if(file.open(QIODevice::ReadOnly | QIODevice::Text))
44 if(file.open(QIODevice::ReadOnly | QIODevice::Text))
41 {
45 {
42 qApp->setStyleSheet(file.readAll());
46 qApp->setStyleSheet(file.readAll());
43 file.close();
47 file.close();
44 }
48 }
45 }
49 }
46
50
47
51
48 void SocExplorerMainWindow::makeObjects(QString ScriptToEval)
52 void SocExplorerMainWindow::makeObjects(QString ScriptToEval)
49 {
53 {
50 Q_UNUSED(ScriptToEval)
54 Q_UNUSED(ScriptToEval)
51 this->p_pluginGUIlist = new QList<QDockWidget*>();
55 this->p_pluginGUIlist = new QList<QDockWidget*>();
52 pluginsDockContainer = new QMainWindow;
56 pluginsDockContainer = new QMainWindow;
53 pluginsDockContainer->setWindowFlags(Qt::Widget);
57 pluginsDockContainer->setWindowFlags(Qt::Widget);
54 pluginsDockContainer->setDockNestingEnabled(true);
58 pluginsDockContainer->setDockNestingEnabled(true);
55 this->mainWidget = new QSplitter(Qt::Vertical);
59 this->mainWidget = new QSplitter(Qt::Vertical);
56 this->appTranslator = new QTranslator;
60 this->appTranslator = new QTranslator;
57 this->Quit = new QAction(tr("&Quit"),this);
61 this->Quit = new QAction(tr("&Quit"),this);
58 this->Quit->setShortcut(tr("CTRL+Q"));
62 this->Quit->setShortcut(tr("CTRL+Q"));
59 this->ManagePlugins = new QAction(tr("&Manage Plugins"),this);
63 this->ManagePlugins = new QAction(tr("&Manage Plugins"),this);
60 this->ManagePlugins->setShortcut(tr("CTRL+P"));
64 this->ManagePlugins->setShortcut(tr("CTRL+P"));
61 this->regsManager = new QAction(tr("&Manage registers"),this);
65 this->regsManager = new QAction(tr("&Manage registers"),this);
62 this->exploreRegs = new QAction(tr("&Explore registers"),this);
66 this->exploreRegs = new QAction(tr("&Explore registers"),this);
63 this->help = new QAction(tr("&Help"),this);
67 this->help = new QAction(tr("&Help"),this);
64 this->help->setShortcut(tr("CTRL+H"));
68 this->help->setShortcut(tr("CTRL+H"));
65 this->about = new QAction(tr("&About"),this);
69 this->about = new QAction(tr("&About"),this);
66 socexplorerproxy::setMainWindow(this);
70 socexplorerproxy::setMainWindow(this);
67 SocExplorerEngine::setMainWindow(this);
71 SocExplorerEngine::setMainWindow(this);
68 SocExplorerEngine::xmlModel()->scanXmlFiles();
72 SocExplorerEngine::xmlModel()->scanXmlFiles();
69 this->regExplorer = new RegsExplorer();
73 this->regExplorer = new RegsExplorer();
70 this->regExplorer->setAllowedAreas(Qt::AllDockWidgetAreas);
74 this->regExplorer->setAllowedAreas(Qt::AllDockWidgetAreas);
71 this->addPluginInterface(this->regExplorer);
75 this->addPluginInterface(this->regExplorer);
72 this->PythonConsoleInst = new PythonConsole(socexplorerproxy::self());
76 this->PythonConsoleInst = new PythonConsole(socexplorerproxy::self());
73 this->PythonConsoleInst->addObject("SocExplorerEngine",SocExplorerEngine::self());
77 this->PythonConsoleInst->addObject("SocExplorerEngine",SocExplorerEngine::self());
74 this->pluginManager = new dockablePluginManager();
78 this->pluginManager = new dockablePluginManager();
75 this->toolpane = new toolBar;
79 this->toolpane = new toolBar;
76 this->p_about = new aboutsocexplorer();
80 this->p_about = new aboutsocexplorer();
77 }
81 }
78
82
79 void SocExplorerMainWindow::makeLayout()
83 void SocExplorerMainWindow::makeLayout()
80 {
84 {
81 this->mainWidget->addWidget(pluginsDockContainer);
85 this->mainWidget->addWidget(pluginsDockContainer);
82 this->mainWidget->addWidget(this->PythonConsoleInst);
86 this->mainWidget->addWidget(this->PythonConsoleInst);
83 this->toolpane->setAllowedAreas(Qt::RightDockWidgetArea|Qt::LeftDockWidgetArea);
87 this->toolpane->setAllowedAreas(Qt::RightDockWidgetArea|Qt::LeftDockWidgetArea);
84 this->addDockWidget(Qt::LeftDockWidgetArea,this->toolpane);
88 this->addDockWidget(Qt::LeftDockWidgetArea,this->toolpane);
85 this->toolpane->addTool(this->pluginManager);
89 this->toolpane->addTool(this->pluginManager);
86 this->setCentralWidget(this->mainWidget);
90 this->setCentralWidget(this->mainWidget);
87 }
91 }
88
92
89
93
90 void SocExplorerMainWindow::makeConnections()
94 void SocExplorerMainWindow::makeConnections()
91 {
95 {
92 connect(socexplorerproxy::self(),SIGNAL(clearMenu()),this,SLOT(clearMenu()));
96 connect(socexplorerproxy::self(),SIGNAL(clearMenu()),this,SLOT(clearMenu()));
93 connect(this,SIGNAL(translateSig()),socexplorerproxy::self(),SLOT(updateText()));
97 connect(this,SIGNAL(translateSig()),socexplorerproxy::self(),SLOT(updateText()));
94 connect(socexplorerproxy::self(),SIGNAL(addPluginGUI(QDockWidget*)),this,SLOT(addPluginInterface(QDockWidget*)));
98 connect(socexplorerproxy::self(),SIGNAL(addPluginGUI(QDockWidget*)),this,SLOT(addPluginInterface(QDockWidget*)));
95 connect(socexplorerproxy::self(),SIGNAL(removePluginGUI(QDockWidget*)),this,SLOT(removePluginInterface(QDockWidget*)));
99 connect(socexplorerproxy::self(),SIGNAL(removePluginGUI(QDockWidget*)),this,SLOT(removePluginInterface(QDockWidget*)));
96 connect(this->ManagePlugins,SIGNAL(triggered()),this,SLOT(launchPluginManager()));
100 connect(this->ManagePlugins,SIGNAL(triggered()),this,SLOT(launchPluginManager()));
97 connect(this->Quit,SIGNAL(triggered()),qApp,SLOT(quit()));
101 connect(this->Quit,SIGNAL(triggered()),qApp,SLOT(quit()));
98 connect(this,SIGNAL(registerObject(QObject*,QString)),this->PythonConsoleInst,SLOT(registerObject(QObject*,QString)));
102 connect(this,SIGNAL(registerObject(QObject*,QString)),this->PythonConsoleInst,SLOT(registerObject(QObject*,QString)));
99 connect(socexplorerproxy::self(),SIGNAL(registerObject(QObject*,QString)),this,SIGNAL(registerObject(QObject*,QString)));
103 connect(socexplorerproxy::self(),SIGNAL(registerObject(QObject*,QString)),this,SIGNAL(registerObject(QObject*,QString)));
100 connect(this->pluginManager,SIGNAL(geteplugintree()),socexplorerproxy::self(),SLOT(geteplugintree()));
104 connect(this->pluginManager,SIGNAL(geteplugintree()),socexplorerproxy::self(),SLOT(geteplugintree()));
101 connect(socexplorerproxy::self(),SIGNAL(treeChanged(QList<socexplorerplugin*>)),this->pluginManager,SIGNAL(treeChanged(QList<socexplorerplugin*>)));
105 connect(socexplorerproxy::self(),SIGNAL(treeChanged(QList<socexplorerplugin*>)),this->pluginManager,SIGNAL(treeChanged(QList<socexplorerplugin*>)));
102 connect(this->pluginManager,SIGNAL(changeSysDriverInstName(QString,QString)),socexplorerproxy::self(),SLOT(changeSysDriverInstName(QString,QString)));
106 connect(this->pluginManager,SIGNAL(changeSysDriverInstName(QString,QString)),socexplorerproxy::self(),SLOT(changeSysDriverInstName(QString,QString)));
103 connect(this->pluginManager,SIGNAL(changeSysDriverInstName(QString,QString)),this->PythonConsoleInst,SLOT(changeSysDriverInstName(QString,QString)));
107 connect(this->pluginManager,SIGNAL(changeSysDriverInstName(QString,QString)),this->PythonConsoleInst,SLOT(changeSysDriverInstName(QString,QString)));
104 connect(this->pluginManager,SIGNAL(closeSysDriver(QString)),socexplorerproxy::self(),SLOT(closeSysDriver(QString)));
108 connect(this->pluginManager,SIGNAL(closeSysDriver(QString)),socexplorerproxy::self(),SLOT(closeSysDriver(QString)));
105 connect(this->pluginManager,SIGNAL(closeSysDriver(QString)),this->PythonConsoleInst,SLOT(removeDriver(QString)));
109 connect(this->pluginManager,SIGNAL(closeSysDriver(QString)),this->PythonConsoleInst,SLOT(removeDriver(QString)));
106 connect(this->pluginManager,SIGNAL(pluginselected(QString)),this,SLOT(pluginselected(QString)));
110 connect(this->pluginManager,SIGNAL(pluginselected(QString)),this,SLOT(pluginselected(QString)));
107 connect(this->about,SIGNAL(triggered()),this,SLOT(showAboutBox()));
111 connect(this->about,SIGNAL(triggered()),this,SLOT(showAboutBox()));
108 connect(this->exploreRegs,SIGNAL(triggered()),this->regExplorer,SLOT(show()));
112 connect(this->exploreRegs,SIGNAL(triggered()),this->regExplorer,SLOT(show()));
109
113
110 this->pluginManager->connect(this->pluginManager,SIGNAL(loadSysDrviver(QString)),socexplorerproxy::self(),SLOT(loadSysDriver(QString)));
114 this->pluginManager->connect(this->pluginManager,SIGNAL(loadSysDrviver(QString)),socexplorerproxy::self(),SLOT(loadSysDriver(QString)));
111 this->pluginManager->connect(this->pluginManager,SIGNAL(loadSysDriverToParent(QString,QString)),socexplorerproxy::self(),SLOT(loadSysDriverToParent(QString,QString)));
115 this->pluginManager->connect(this->pluginManager,SIGNAL(loadSysDriverToParent(QString,QString)),socexplorerproxy::self(),SLOT(loadSysDriverToParent(QString,QString)));
112
116
113 }
117 }
114
118
115
119
116 void SocExplorerMainWindow::launchPluginManager()
120 void SocExplorerMainWindow::launchPluginManager()
117 {
121 {
118
122
119 if(this->pluginManager->isHidden())
123 if(this->pluginManager->isHidden())
120 {
124 {
121 this->pluginManager->setHidden(false);
125 this->pluginManager->setHidden(false);
122 }
126 }
123
127
124 }
128 }
125
129
126
130
127 void SocExplorerMainWindow::addPluginInterface(QDockWidget *plugin)
131 void SocExplorerMainWindow::addPluginInterface(QDockWidget *plugin)
128 {
132 {
129 plugin->setAllowedAreas(Qt::AllDockWidgetAreas);
133 plugin->setAllowedAreas(Qt::AllDockWidgetAreas);
130 this->pluginsDockContainer->addDockWidget(Qt::TopDockWidgetArea,plugin);
134 this->pluginsDockContainer->addDockWidget(Qt::TopDockWidgetArea,plugin);
131 if(p_pluginGUIlist->count()!=0)
135 if(p_pluginGUIlist->count()!=0)
132 this->pluginsDockContainer->tabifyDockWidget(p_pluginGUIlist->last(),plugin);
136 this->pluginsDockContainer->tabifyDockWidget(p_pluginGUIlist->last(),plugin);
133 p_pluginGUIlist->append(plugin);
137 p_pluginGUIlist->append(plugin);
134 }
138 }
135
139
136 void SocExplorerMainWindow::removePluginInterface(QDockWidget *plugin)
140 void SocExplorerMainWindow::removePluginInterface(QDockWidget *plugin)
137 {
141 {
138 p_pluginGUIlist->removeOne(plugin);
142 p_pluginGUIlist->removeOne(plugin);
139 this->pluginsDockContainer->removeDockWidget(plugin);
143 this->pluginsDockContainer->removeDockWidget(plugin);
140 }
144 }
141
145
142
146
143 void SocExplorerMainWindow::clearMenu()
147 void SocExplorerMainWindow::clearMenu()
144 {
148 {
145 this->menuBar()->clear();
149 this->menuBar()->clear();
146 this->makeMenu();
150 this->makeMenu();
147 }
151 }
148
152
149
153
150 void SocExplorerMainWindow::makeMenu()
154 void SocExplorerMainWindow::makeMenu()
151 {
155 {
152 this->FileMenu = menuBar()->addMenu(tr("&File"));
156 this->FileMenu = menuBar()->addMenu(tr("&File"));
157 this->SessionsMenu = this->FileMenu->addMenu(tr("&Sessions"));
158 this->SettingsMenu = menuBar()->addMenu(tr("&Settings"));
159 SocExplorerGUI::registerMenuBar(menuBar(),this->FileMenu,this->SettingsMenu);
153 this->PluginsMenu = menuBar()->addMenu(tr("&Plugins"));
160 this->PluginsMenu = menuBar()->addMenu(tr("&Plugins"));
154 this->ToolsMenu = menuBar()->addMenu(tr("&Tools"));
161 this->ToolsMenu = menuBar()->addMenu(tr("&Tools"));
155 this->ToolsMenu->addAction(this->exploreRegs);
162 this->ToolsMenu->addAction(this->exploreRegs);
156 this->FileMenu->addAction(this->Quit);
163 this->FileMenu->addAction(this->Quit);
157 socexplorerproxy::self()->makeMenu(this->PluginsMenu);
164 socexplorerproxy::self()->makeMenu(this->PluginsMenu);
158 this->PluginsMenu->addAction(this->ManagePlugins);
165 this->PluginsMenu->addAction(this->ManagePlugins);
159
166
160 this->helpMenu = menuBar()->addMenu(tr("Help"));
167 this->helpMenu = menuBar()->addMenu(tr("Help"));
161 this->helpMenu->addAction(this->help);
168 this->helpMenu->addAction(this->help);
162 this->helpMenu->addAction(this->about);
169 this->helpMenu->addAction(this->about);
163
170
164 }
171 }
165
172
173 void SocExplorerMainWindow::loadSessions()
174 {
175 // QStringList sessions = SocExplorerSettings::value();
176 QList<QList<QVariant> > sessions = SocExplorerSettings::arrays(SOCEXPLORERGLOBAL_SETTINGS_SESSIONS_SCOPE,QStringList()<<SOCEXPLORERGLOBAL_SETTINGS_SESSIONS_NAME);
177 p_Sessions.clear();
178 for(int i=0;i<sessions.count();i++)
179 {
180 if(sessions.at(i).count()>=1)
181 {
182 p_Sessions.append(sessions.at(i).at(0).toString());
183 }
184 }
185
186 }
187
166
188
167 SocExplorerMainWindow::~SocExplorerMainWindow()
189 SocExplorerMainWindow::~SocExplorerMainWindow()
168 {
190 {
191 SocExplorerSettings::setValue("GLOBAL","LastModified",QDate::currentDate().toString(),SocExplorerSettings::Session);
192 SocExplorerSettings::sync();
169 }
193 }
170
194
171
195
172 void SocExplorerMainWindow::setLangage(QAction *action)
196 void SocExplorerMainWindow::setLangage(QAction *action)
173 {
197 {
174 QString local = action->data().toString();
198 QString local = action->data().toString();
175 QString qmPath = QDir(QString("translations")).absolutePath();
199 QString qmPath = QDir(QString("translations")).absolutePath();
176 appTranslator->load(qmPath+"/socexplorer_"+local+".qm");
200 appTranslator->load(qmPath+"/socexplorer_"+local+".qm");
177 qApp->installTranslator(appTranslator);
201 qApp->installTranslator(appTranslator);
178 emit this->translateSig();
202 emit this->translateSig();
179 }
203 }
180
204
181
205
182 void SocExplorerMainWindow::createLangMenu()
206 void SocExplorerMainWindow::createLangMenu()
183 {
207 {
184 this->langMenu = menuBar()->addMenu(tr("&Langue"));
208 this->langMenu = menuBar()->addMenu(tr("&Langue"));
185 this->langActionGrp = new QActionGroup(this);
209 this->langActionGrp = new QActionGroup(this);
186 connect(this->langActionGrp,SIGNAL(triggered(QAction*)),this,SLOT(setLangage(QAction*)));
210 connect(this->langActionGrp,SIGNAL(triggered(QAction*)),this,SLOT(setLangage(QAction*)));
187 QDir* qmDir = new QDir(QString("translations"));
211 QDir* qmDir = new QDir(QString("translations"));
188 QStringList LangFiles = qmDir->entryList(QStringList("socexplorer_*.qm"));
212 QStringList LangFiles = qmDir->entryList(QStringList("socexplorer_*.qm"));
189 for(int i=0;i<LangFiles.size();++i)
213 for(int i=0;i<LangFiles.size();++i)
190 {
214 {
191 QString Local = LangFiles[i];
215 QString Local = LangFiles[i];
192 Local.remove(0,Local.indexOf('_')+1);
216 Local.remove(0,Local.indexOf('_')+1);
193 Local.chop(3);
217 Local.chop(3);
194 QTranslator translator;
218 QTranslator translator;
195 translator.load(LangFiles[i],qmDir->absolutePath());
219 translator.load(LangFiles[i],qmDir->absolutePath());
196 QString langage = translator.translate("MainWindow","English");
220 QString langage = translator.translate("MainWindow","English");
197 QAction *action = new QAction(tr("&%1 %2").arg(i+1).arg(langage),this);
221 QAction *action = new QAction(tr("&%1 %2").arg(i+1).arg(langage),this);
198 action->setCheckable(true);
222 action->setCheckable(true);
199 action->setData(Local);
223 action->setData(Local);
200 langMenu->addAction(action);
224 langMenu->addAction(action);
201 langActionGrp->addAction(action);
225 langActionGrp->addAction(action);
202 if(langage==tr("English"))
226 if(langage==tr("English"))
203 action->setChecked(true);
227 action->setChecked(true);
204 }
228 }
205 }
229 }
206
230
207
231
208 void SocExplorerMainWindow::updateText()
232 void SocExplorerMainWindow::updateText()
209 {
233 {
210 emit this->translateSig();
234 emit this->translateSig();
211 }
235 }
212
236
213
237
214
238
215 void SocExplorerMainWindow::showAboutBox()
239 void SocExplorerMainWindow::showAboutBox()
216 {
240 {
217 p_about->show();
241 p_about->show();
218 }
242 }
219
243
220 void SocExplorerMainWindow::pluginselected(const QString &instanceName)
244 void SocExplorerMainWindow::pluginselected(const QString &instanceName)
221 {
245 {
222 socexplorerplugin* drv=socexplorerproxy::self()->getSysDriver(instanceName);
246 socexplorerplugin* drv=socexplorerproxy::self()->getSysDriver(instanceName);
223 if(drv)
247 if(drv)
224 drv->raise();
248 drv->raise();
225 }
249 }
226
250
227
251
228
252
229 void SocExplorerMainWindow::closeEvent(QCloseEvent *event)
253 void SocExplorerMainWindow::closeEvent(QCloseEvent *event)
230 {
254 {
231 socexplorerproxy::self()->close();
255 socexplorerproxy::self()->close();
232 qApp->closeAllWindows();
256 qApp->closeAllWindows();
233 event->accept();
257 event->accept();
234 }
258 }
235
259
236
260
237
261
238
262
239
263
240
264
@@ -1,86 +1,89
1 /*------------------------------------------------------------------------------
1 /*------------------------------------------------------------------------------
2 -- This file is a part of the SocExplorer Software
2 -- This file is a part of the SocExplorer Software
3 -- Copyright (C) 2011, Plasma Physics Laboratory - CNRS
3 -- Copyright (C) 2011, Plasma Physics Laboratory - CNRS
4 --
4 --
5 -- This program is free software; you can redistribute it and/or modify
5 -- This program is free software; you can redistribute it and/or modify
6 -- it under the terms of the GNU General Public License as published by
6 -- it under the terms of the GNU General Public License as published by
7 -- the Free Software Foundation; either version 2 of the License, or
7 -- the Free Software Foundation; either version 2 of the License, or
8 -- (at your option) any later version.
8 -- (at your option) any later version.
9 --
9 --
10 -- This program is distributed in the hope that it will be useful,
10 -- This program is distributed in the hope that it will be useful,
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 -- GNU General Public License for more details.
13 -- GNU General Public License for more details.
14 --
14 --
15 -- You should have received a copy of the GNU General Public License
15 -- You should have received a copy of the GNU General Public License
16 -- along with this program; if not, write to the Free Software
16 -- along with this program; if not, write to the Free Software
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 -------------------------------------------------------------------------------*/
18 -------------------------------------------------------------------------------*/
19 /*-- Author : Alexis Jeandet
19 /*-- Author : Alexis Jeandet
20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
21 ----------------------------------------------------------------------------*/
21 ----------------------------------------------------------------------------*/
22 #ifndef MAINWINDOW_H
22 #ifndef MAINWINDOW_H
23 #define MAINWINDOW_H
23 #define MAINWINDOW_H
24
24
25 #include <QMainWindow>
25 #include <QMainWindow>
26 #include <QApplication>
26 #include <QApplication>
27 #include <QVBoxLayout>
27 #include <QVBoxLayout>
28 #include <QIcon>
28 #include <QIcon>
29 #include <QMenuBar>
29 #include <QMenuBar>
30 #include <QMenu>
30 #include <QMenu>
31 #include <QAction>
31 #include <QAction>
32 #include <QDockWidget>
32 #include <QDockWidget>
33 #include <QTranslator>
33 #include <QTranslator>
34 #include <QSplitter>
34 #include <QSplitter>
35 #include "dockablepluginmanager.h"
35 #include "dockablepluginmanager.h"
36 #include <socexplorerproxy.h>
36 #include <socexplorerproxy.h>
37 #include "PyWdgt/pythonconsole.h"
37 #include "PyWdgt/pythonconsole.h"
38 #include "aboutsocexplorer.h"
38 #include "aboutsocexplorer.h"
39 #include "toolbar.h"
39 #include "toolbar.h"
40 #include "regsExplorer/regsexplorer.h"
40 #include "regsExplorer/regsexplorer.h"
41 #include "socexplorergui.h"
41
42
42 class SocExplorerMainWindow : public QMainWindow
43 class SocExplorerMainWindow : public QMainWindow
43 {
44 {
44 Q_OBJECT
45 Q_OBJECT
45
46
46 public:
47 public:
47 SocExplorerMainWindow(QString ScriptToEval,QWidget *parent = 0);
48 SocExplorerMainWindow(QString ScriptToEval,QWidget *parent = 0);
48 ~SocExplorerMainWindow();
49 ~SocExplorerMainWindow();
49 QAction* Quit,*LoadPlugin,*ManagePlugins,*help,*regsManager,*exploreRegs,*about,*translateAction;
50 QAction* Quit,*LoadPlugin,*ManagePlugins,*help,*regsManager,*exploreRegs,*about,*translateAction;
50 QActionGroup*langActionGrp;
51 QActionGroup*langActionGrp;
51 QMenu* FileMenu,*PluginsMenu,*ToolsMenu,*langMenu,*helpMenu;
52 QMenu* FileMenu,*SettingsMenu,*PluginsMenu,*ToolsMenu,*langMenu,*helpMenu,*SessionsMenu;
52 QTranslator* appTranslator;
53 QTranslator* appTranslator;
53 void createLangMenu();
54 void createLangMenu();
54 void closeEvent(QCloseEvent *event);
55 void closeEvent(QCloseEvent *event);
55 toolBar* toolpane;
56 toolBar* toolpane;
56
57
57
58
58 public slots:
59 public slots:
59 void launchPluginManager();
60 void launchPluginManager();
60 void addPluginInterface(QDockWidget* plugin);
61 void addPluginInterface(QDockWidget* plugin);
61 void removePluginInterface(QDockWidget* plugin);
62 void removePluginInterface(QDockWidget* plugin);
62 void clearMenu();
63 void clearMenu();
63 void updateText();
64 void updateText();
64 void setLangage(QAction* action);
65 void setLangage(QAction* action);
65 void showAboutBox();
66 void showAboutBox();
66 void pluginselected(const QString& instanceName);
67 void pluginselected(const QString& instanceName);
67
68
68 signals:
69 signals:
69 void translateSig();
70 void translateSig();
70 void registerObject(QObject* object,const QString& instanceName);
71 void registerObject(QObject* object,const QString& instanceName);
71
72
72 private:
73 private:
73 void makeObjects(QString ScriptToEval);
74 void makeObjects(QString ScriptToEval);
74 void makeLayout();
75 void makeLayout();
75 void makeConnections();
76 void makeConnections();
76 void makeMenu();
77 void makeMenu();
78 void loadSessions();
77 QMainWindow* pluginsDockContainer;
79 QMainWindow* pluginsDockContainer;
78 QSplitter* mainWidget;
80 QSplitter* mainWidget;
79 PythonConsole* PythonConsoleInst;
81 PythonConsole* PythonConsoleInst;
80 dockablePluginManager* pluginManager;
82 dockablePluginManager* pluginManager;
81 RegsExplorer* regExplorer;
83 RegsExplorer* regExplorer;
82 aboutsocexplorer* p_about;
84 aboutsocexplorer* p_about;
83 QList<QDockWidget*>* p_pluginGUIlist;
85 QList<QDockWidget*>* p_pluginGUIlist;
86 QStringList p_Sessions;
84 };
87 };
85
88
86 #endif // MAINWINDOW_H
89 #endif // MAINWINDOW_H
@@ -1,123 +1,126
1 #-------------------------------------------------
1 #-------------------------------------------------
2 #
2 #
3 # Project created by QtCreator 2011-09-19T22:52:10
3 # Project created by QtCreator 2011-09-19T22:52:10
4 #
4 #
5 #-------------------------------------------------
5 #-------------------------------------------------
6 SOCEXPLORER_ROOT = $${PWD}/..
6 SOCEXPLORER_ROOT = $${PWD}/..
7 include(../build_cfg/socexplorer.pri)
7 include(../build_cfg/socexplorer.pri)
8
8
9 TARGET = socexplorer$${DEBUG_EXT}
9 TARGET = socexplorer$${DEBUG_EXT}
10 TEMPLATE = app
10 TEMPLATE = app
11 CONFIG += pythonqt
11 CONFIG += pythonqt
12
12
13
13
14 QMAKE_LFLAGS_RELEASE += --enable-auto-import -mstackrealign
14 QMAKE_LFLAGS_RELEASE += --enable-auto-import -mstackrealign
15 QMAKE_LFLAGS_DEBUG += --enable-auto-import -mstackrealign
15 QMAKE_LFLAGS_DEBUG += --enable-auto-import -mstackrealign
16
16
17 include ( common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer.pri )
17 include ( common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer.pri )
18 include ( SocExplorerEngine/pythonQtOut/generated_cpp/PySocExplorerEngine/PySocExplorerEngine.pri )
18 include ( SocExplorerEngine/pythonQtOut/generated_cpp/PySocExplorerEngine/PySocExplorerEngine.pri )
19 include ( SocExplorerEngine/plugins/socexplorerplugin.prf )
19 include ( SocExplorerEngine/plugins/socexplorerplugin.prf )
20
20
21 INCLUDEPATH+=$${PWD} \
21 INCLUDEPATH+=$${PWD} \
22 $${PWD}/common \
22 $${PWD}/common \
23 $${PWD}/common/qhexedit \
23 $${PWD}/common/qhexedit \
24 $${PWD}/common/QCustomPlot \
24 $${PWD}/common/QCustomPlot \
25 $${PWD}/common/genericBinaryFiles \
25 $${PWD}/common/genericBinaryFiles \
26 $${PWD}/common/genericBinaryFiles/elf \
26 $${PWD}/common/genericBinaryFiles/elf \
27 $${PWD}/common/genericBinaryFiles/srec \
27 $${PWD}/common/genericBinaryFiles/srec \
28 $${PWD}/common/genericBinaryFiles/BinFile \
28 $${PWD}/common/genericBinaryFiles/BinFile \
29 SocExplorerEngine/engine \
29 SocExplorerEngine/engine \
30 SocExplorerEngine/pluginloader \
30 SocExplorerEngine/pluginloader \
31 SocExplorerEngine/pluginsInterface \
31 SocExplorerEngine/pluginsInterface \
32 SocExplorerEngine/proxy \
32 SocExplorerEngine/proxy \
33 SocExplorerEngine/pluginManagerWdgt \
33 SocExplorerEngine/pluginManagerWdgt \
34 SocExplorerEngine/plugins \
34 SocExplorerEngine/plugins \
35 SocExplorerEngine/RegisterMVS \
35 SocExplorerEngine/RegisterMVS \
36 SocExplorerEngine/XmlEngine \
36 SocExplorerEngine/XmlEngine \
37 SocExplorerEngine/SOC \
37 SocExplorerEngine/SOC \
38 SocExplorerEngine/PeripheralWidget/src \
38 SocExplorerEngine/PeripheralWidget/src \
39 SocExplorerEngine/memtester
39 SocExplorerEngine/memtester
40
40
41 win32:INCLUDEPATH+= \
41 win32:INCLUDEPATH+= \
42 $${PWD}/common/genericBinaryFiles/elf/libelfWin32/include \
42 $${PWD}/common/genericBinaryFiles/elf/libelfWin32/include \
43 $${PWD}/common/genericBinaryFiles/elf/libelfWin32/include/libelf \
43 $${PWD}/common/genericBinaryFiles/elf/libelfWin32/include/libelf \
44
44
45
45
46 RC_FILE = ../win32cfg/socexplorer.rc
46 RC_FILE = ../win32cfg/socexplorer.rc
47
47
48
48
49 unix:LIBS+=-L$${SOCEXPLORER_ROOT}/bin/linux -lsocexplorercommon$${DEBUG_EXT} -L$${SOCEXPLORER_ROOT}/bin/linux -lsocexplorerengine$${DEBUG_EXT}
49 unix:LIBS+=-L$${SOCEXPLORER_ROOT}/bin/linux -lsocexplorercommon$${DEBUG_EXT} -L$${SOCEXPLORER_ROOT}/bin/linux -lsocexplorerengine$${DEBUG_EXT}
50
50
51 win32-g++:LIBS += $${SOCEXPLORER_ROOT}/bin/win32/socexplorercommon$${DEBUG_EXT}.dll $${SOCEXPLORER_ROOT}/bin/win32/socexplorerengine$${DEBUG_EXT}.dll
51 win32-g++:LIBS += $${SOCEXPLORER_ROOT}/bin/win32/socexplorercommon$${DEBUG_EXT}.dll $${SOCEXPLORER_ROOT}/bin/win32/socexplorerengine$${DEBUG_EXT}.dll
52
52
53
53
54 unix{
54 unix{
55 translation.files = $${SOCEXPLORER_ROOT}/translations/socexplorer_fr.qm \
55 translation.files = $${SOCEXPLORER_ROOT}/translations/socexplorer_fr.qm \
56 $${SOCEXPLORER_ROOT}/translations/socexplorer_en.qm
56 $${SOCEXPLORER_ROOT}/translations/socexplorer_en.qm
57 translation.path = $${SOCEXPLORER_TRANSLATION_INSTALL_PATH}
57 translation.path = $${SOCEXPLORER_TRANSLATION_INSTALL_PATH}
58 target.path = /usr/bin
58 target.path = /usr/bin
59 INSTALLS += translation target
59 INSTALLS += translation target
60 }
60 }
61
61
62 header.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common
62 header.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common
63 header.files = \
63 header.files = \
64 socexplorer.h
64 socexplorer.h
65 INSTALLS += header
65 INSTALLS += header
66
66
67
67
68 SOURCES += main.cpp\
68 SOURCES += main.cpp\
69 mainwindow.cpp \
69 mainwindow.cpp \
70 PyWdgt/pythonconsole.cpp \
70 PyWdgt/pythonconsole.cpp \
71 PyWdgt/pythonqtscriptingconsoledandd.cpp \
71 PyWdgt/pythonqtscriptingconsoledandd.cpp \
72 dockablepluginmanager.cpp \
72 dockablepluginmanager.cpp \
73 toolbar.cpp \
73 toolbar.cpp \
74 toolbarcontainer.cpp \
74 toolbarcontainer.cpp \
75 aboutsocexplorer.cpp \
75 aboutsocexplorer.cpp \
76 regsExplorer/regsexplorer.cpp
76 regsExplorer/regsexplorer.cpp \
77 socexplorercoresettingsgui.cpp
77
78
78 HEADERS += mainwindow.h \
79 HEADERS += mainwindow.h \
79 PyWdgt/pythonconsole.h \
80 PyWdgt/pythonconsole.h \
80 PyWdgt/pythonqtscriptingconsoledandd.h \
81 PyWdgt/pythonqtscriptingconsoledandd.h \
81 dockablepluginmanager.h \
82 dockablepluginmanager.h \
82 toolbar.h \
83 toolbar.h \
83 toolbarcontainer.h \
84 toolbarcontainer.h \
84 socexplorer.h \
85 socexplorer.h \
85 SocExplorerEngine/plugins/socexplorerplugin.h \
86 SocExplorerEngine/plugins/socexplorerplugin.h \
86 aboutsocexplorer.h \
87 aboutsocexplorer.h \
87 regsExplorer/regsexplorer.h
88 regsExplorer/regsexplorer.h \
89 socexplorercoresettingsgui.h
88
90
89
91
90 include ( NicePyConsole/NicePyConsole.pri)
92 include ( NicePyConsole/NicePyConsole.pri)
91
93
92 win32{
94 win32{
93 RESOURCES = ../ressources/SocExplorer.qrc
95 RESOURCES = ../ressources/SocExplorer.qrc
94 }
96 }
95
97
96 unix{
98 unix{
97 RESOURCES = ../ressources/SocExplorer.qrc
99 RESOURCES = ../ressources/SocExplorer.qrc
98 }
100 }
99
101
100 TRANSLATIONS = ../translations/socexplorer_fr.ts \
102 TRANSLATIONS = ../translations/socexplorer_fr.ts \
101 ../translations/socexplorer_en.ts
103 ../translations/socexplorer_en.ts
102
104
103 FORMS += \
105 FORMS += \
104 regsExplorer/regsexplorernew.ui
106 regsExplorer/regsexplorernew.ui \
107 socexplorercoresettingsgui.ui
105
108
106 DISTFILES += \
109 DISTFILES += \
107 ../doc/PythonExamples/LEON3_LOAD.py \
110 ../doc/PythonExamples/LEON3_LOAD.py \
108 ../doc/PythonExamples/PythonPlugin.py \
111 ../doc/PythonExamples/PythonPlugin.py \
109 ../doc/PythonExamples/simpledemo1.py \
112 ../doc/PythonExamples/simpledemo1.py \
110 ../doc/PythonExamples/SocExplorerPlot.py \
113 ../doc/PythonExamples/SocExplorerPlot.py \
111 ../doc/PythonExamples/SocExplorerPlot2.py \
114 ../doc/PythonExamples/SocExplorerPlot2.py \
112 ../doc/PythonExamples/SocExplorerPlot3.py \
115 ../doc/PythonExamples/SocExplorerPlot3.py \
113 ../doc/PythonExamples/tcpterminaldemo.py \
116 ../doc/PythonExamples/tcpterminaldemo.py \
114 ../doc/PythonExamples/tcpterminaldemo2.py
117 ../doc/PythonExamples/tcpterminaldemo2.py
115
118
116
119
117
120
118
121
119
122
120
123
121
124
122
125
123
126
General Comments 0
You need to be logged in to leave comments. Login now